Demande.tn

🔒
❌
Il y a de nouveaux articles disponibles, cliquez pour rafraĂźchir la page.
Aujourd’hui — 23 septembre 2017Technos / IT

GNOME and KDE Join Librem 5 Linux Smartphone Party

Par Derick Sullivan M. Lobga

 

KDE and GNOME support Purism for Librem 5 Linux smartphone

Brief: Purism is making a true Linux smartphone called Librem 5. KDE and GNOME have just lent their support for Librem 5.

You probably already know that Purism has launched a crowdfunding campaign in a bid to create a Linux smartphone. The goal is to raise $1.5 million to bring the world’s first truly free and open source smartphone with enhanced user protection and end-to-end encryption into the market.

Librem 5 wants you to be able to run any major Linux distributions such as Debian, Arch, Ubuntu etc on your smartphone. And to support this ‘dream’, two big Linux desktop projects, GNOME and KDE are joining hands with Purism so that Librem 5 would be able to run KDE and GNOME desktop environments on it.

These announcements came at an interval of a few days and we have covered both news in this one article.

Librem 5 and KDE

The partnership with KDE is for KDE to adapt Plasma Mobile for Librem 5 smartphone. Plasma Mobile is a full-featured graphical environment developed by KDE for mobile devices. It has been tested on some devices but since it is free and open, it clashes with most smartphones as their hardware needs proprietary software to work.

Purism and KDE have a shared vision of “freedom, openness and personal control for end users”. This common goal has brought them together, as announced by KDE.

Building a Free Software and privacy-focused smartphone has been a dream of the KDE community for a long time….Partnering with Purism will allow us to ready Plasma Mobile for the real world and integrate it seamlessly with a commercial device for the first time,” Lydia Pintscher, president of KDE said.

Librem 5 and GNOME

GNOME Foundation has announced that it will create emulators, tools as well as build awareness in moving GNOME/GTK onto the Purism Librem 5 smartphone. If everything goes on well, the GNOME Foundation will enhance GNOME shell and its system performance with Purism that will enable features on the Librem 5.

It should be noted that GNOME technologies have been used in embedded devices like Nokia 770, N800 and N900 even though the developers had some challenging experience with the devices.

According to Neil McGovern, the executive director or GNOME Foundation, “Having a Free/Libre and Open Source software stack on a mobile device is a dream-come-true for so many people, and Purism has the proven team to make this happen”.

What it means for Librem 5

For Purism, getting an endorsement from such communities means the world is getting closer to a phone that “avoids the handcuffs of Android and iOS”. “Purism is excited to work with many communities and organizations to advance the digital rights of people,” Founder & CEO of Purism, Todd Weaver said.

At the time of writing this, the crowdfunding campaign had raised 47.70% ($625,464) of the required $1,500,000 with 31 days to go.

The initial plan was to ship the smartphone with a GNOME desktop environment and GTK toolkit-based custom user interface. Now they are partnering with both the GNOME and KDE teams in order to “test, support, and develop with KDE and the KDE community” as well as using the Qt toolkit and GTK to develop apps.

Purism had already used GNOME for its PureOS software which is used in its tablets and laptop computers. They say they will continue to test both GNOME or KDE-based software and will decide after the project is funded which of them to use to ship the phone with.

If you want to make Librem 5 a reality, please contribute to the project:

Support Librem 5

Hier — 22 septembre 2017Technos / IT

Four ways to build open source community in your company

Par Anne Bertucio

LOS ANGELES — The Open Community Conference was one of five tracks at the Linux Foundation’s recent Open Source Summit North America. Chaired by Jono Bacon, the tracks covered community management, open source office establishment and open source culture in organizations.

If you missed it, here are four takeaways worth applying to your work.

Find the right community manager

Community managers seem to come from all walks of life: the engineer; the marketer; the team lead. But what makes the best community manager? Alan Clark, director of industry initiatives, emerging standards and open source at SUSE, has been involved in open source communities for more than 15 years. He’s seen trends in community management come and go, but the constant success is when a community manager reflects the values of the community.
“Community management is a little different everywhere. It depends on the personalities of the managers and the personalities of the community.” Clark has been involved with both openSUSE and OpenStack, and offered the two as examples. “In the openSUSE community there’s very little marketing. It’s very developer-focused and less about promotion, social outreach and marketing. Most [community managers in openSUSE] come from engineering backgrounds, and that’s very appropriate, but in OpenStack, that wouldn’t reflect the needs of the overall community.”

“OpenStack has set core values that it has embraced, particularly transparency. The successful community manager has to personify those and be the enforcer of those. Community managers are the front line and they set the tone and the attitude of the community.”

Delete the bias against marketing

Marketing is often perceived as a lower status role in the tech industry, as DeirdrĂ© Straughan called out in her presentation, which means that emerging open source projects or organizations working with open source often think they don’t need or want marketing. This is a naive mistake, as good marketing––not the kind that insults your intelligence or abuses your information––is what communicates your open source work to the world. Toolkits let developers access your project, blueprints and roadmaps help people evaluate, training gives the skills to use and contribute, and yes, this is all “marketing.” Straughan challenged the audience to reconsider their bias against marketing and to recognize that great marketing is part of a successful open source strategy.

 

Identify the invested parties in your organization

Nithya Ruff, senior director of the open source practice at Comcast, and Duane O’Brien, open source programs evangelist at PayPal, urged people trying to start open source program offices in their organization to spend time identifying who at their organization has a vested interest in formally engaging with open source communities.

Is the legal team getting overwhelmed with requests for contribution information? Is engineering eagerly consuming open source? Is marketing desperate for help to clearly communicate the open-source basis for their products? Finding who has this special interest can act as the impetus to kickstart more formal engagement with open source communities.

Start with “inner source”

Shilla Saebi, open source community leader at Comcast, has found success by establishing open source practices internally, “inner source” as she’s dubbed it, which helps the organization and individuals develop policies around open source and become comfortable with contributing so they can successfully engage with open source communities.

Inner source looks similar to externally facing open source: licensing discussions with the legal team and meetups. At Comcast there are internal slack channels dedicated to open source projects: the OpenStack channel has more 1,200 members; Cloud Foundry, 900. Inner source acts as a practice for engaging with open source communities, growing familiarity and confidence that translates to external engagement.

Share your thoughts on what makes open source communities tick with @WhyHiAnnabelle and @Superuser on Twitter.

Cover Photo // CC BY NC

The post Four ways to build open source community in your company appeared first on OpenStack Superuser.

The Changelog 263: Conversations About Sustaining Open Source at Sustain 2017

This episode features conversations from Sustain 2017 at GitHub HQ with Richard Littauer, Karthik Ram, Andrea Goulet, and Scott Ford. Sustain was a one day conversation for open source software sustainers to share stories, resources, and ways forward to sustain open source.

Sponsors

  • Hired –  Get hired. It's free — in fact, they pay you to get hired. Our listeners get a double hiring bonus of $600.
  • Bugsnag –  Mission control for software quality! Monitor website or mobile app errors that impact your customers. Our listeners can try all the features free for 60 days ($118 value).
  • CircleCI –  CircleCI is a continuous integration and delivery platform that helps software teams rapidly release code with confidence by automating the build, test, and deploy process. Checkout the recently launched CircleCI 2.0!
  • Linode –  Our cloud server of choice. Get one of the fastest, most efficient SSD cloud servers for only $5/mo. Use the code changelog2017 to get 4 months free!

Featuring

Notes and Links

đŸ’Ÿ

  • 22 septembre 2017 Ă  19:00

AlternC Camp Ă  Lyon du 6 au 8 octobre 2017

Par azerttyu

Cela fait un petit moment qu'on n'a pas parlĂ© ici d'AlternC, ce projet libre dont la vocation est d'aider la gestion de l'hĂ©bergement de vos noms de domaines, courriels, sites web, listes de diffusion, etc. L'organisation du prochain dev camp est l’occasion de corriger tout ceci.
Le principe est de se retrouver dans un mĂȘme espace physique et temporel pour coder, corriger des points bloquants immĂ©diats, et prĂ©parer la suite.

Logo AlternC

Ces derniers temps les contributeurs principaux n'ont pu se focaliser comme voulu sur le suivi des versions Debian. Actuellement peu de contributions ont permis de rattraper ce retard. C'est une des nos premiĂšres urgences.

AlternC ?

AlternC est utilisĂ© tant par des sociĂ©tĂ©s d'hĂ©bergement que par des particuliers, des associations ou toutes autres entitĂ©s voulant hĂ©berger plus d'un projet Internet. Il est fortement liĂ© au fonctionnement Debian et peut ĂȘtre dans certains cas utilisĂ© avec des distributions telles que Ubuntu

Plan d'action

Nous souhaitons, durant trois jours, travailler en priorité sur les points suivants :

  • Publier des paquets 3.x.10 (principalement des corrections diverses et variĂ©es pour les versions Wheezy et Jessie).
  • Finaliser l'intĂ©gration de Let's Encrypt.
  • Corriger les incidents restants sur la version stable (principalement suivre le mouvement apache 2.2 vers 2.4).
  • Valider une mĂ©thodologie de migration Wheezy => Jessie (pour rattraper notre retard avec les versions LTS de Debian).
  • Publier une version stable pour Jessie (old-stable).
  • Identifier les problĂšmes pour la compatibilitĂ© avec Stretch.

Comme vous pouvez le lire, notre volonté est de rattraper autant que possible notre retard par rapport au cycle de vie Debian.

Et vous, et nous  ?

Ces trois journĂ©es sont ouvertes Ă  toutes personnes. Vous pourrez nous aider Ă  amĂ©liorer l'existant, nous suggĂ©rer les amĂ©liorations pour la suite, montrer nos dĂ©fauts et qualitĂ©s, traduire, boire un cafĂ©, un thĂ© ou un chocolat chaud …

Vous pouvez vous inscrire sur Framadate et faire vos remarques ci dessous.

OĂč ?

Le lieu n'est pas encore déterminé, l'information sera transmise par courriel et sur le framadate. Nous allons réserver une maison ou un appartement pour les trois jours ce qui nous laissera un maximum de liberté durant cette période. Vous pourrez venir et partir librement ;)

Lire les commentaires

XOSAN - un SAN virtuel pour XenServer

Par Fennings

XOSAN est une solution d’hyperconvergence destinĂ©e Ă  XenServer actuellement en cours de dĂ©veloppement par Vates, la sociĂ©tĂ© Ă©ditrice de Xen Orchestra. Il s’agit d’un SAN virtuel pour crĂ©er un espace de stockage partagĂ© en utilisant vos diffĂ©rents espaces de stockages existants. C’est une solution orientĂ©e 100 % logicielle.

La seconde phase de la beta est maintenant déployée et accessible à tous les utilisateurs qui veulent y participer.

NdM : XOSAN n'est pas sous licence libre.

Fonctionnement

XOSAN rĂ©unit tous les disques locaux existants de votre infrastructure dans un espace de stockage partagĂ© et virtuel, sans aucune limitation. C'est une solution entiĂšrement orientĂ©e logicielle qui ne nĂ©cessite pas l'achat de matĂ©riel additionnel Ă  votre infrastructure dĂ©jĂ  existante. Cette solution est capable de fonctionner sur un disque oĂč XenServer est dĂ©jĂ  installĂ©.

XoSAN

Objectifs

Les objectifs/bénéfices de la solution sont multiples:

  • ProtĂ©ger vos donnĂ©es grĂące Ă  la rĂ©plication des donnĂ©es sur des hĂŽtes multiples
  • Rendre possible la Haute DisponibilitĂ© pour XenServer sans avoir besoin d'utiliser un NAS ou un SAN
  • Rendre son infrastructure plus agile en ajoutant de nouveaux noeuds pour agrandir votre espace de stockage
  • Offrir la possibilitĂ© de travailler sur n'importe quel matĂ©riel: du HDD au SSD en configuration RAID ou non

Phases de beta pour XOSAN

Phase I

La premiÚre phase de la beta est terminée et a permis la réalisation d'une solution techniquement solide et performante exploitant la technologie GlusterFS.

Phase II

La deuxiĂšme phase de la beta XOSAN est maintenant ouverte. Cette deuxiĂšme phase de beta a pour objectif d’amĂ©liorer l’interface utilisateur et d’apporter une solution clĂ© en main et « user friendly ». Son second objectif est de rendre la solution plus flexible en offrant la possibilitĂ© d’ajouter ou de supprimer des noeuds ou encore de remplacer un noeud dĂ©faillant.

Phase III (finale)

La troisiĂšme et derniĂšre phase se concentrera sur le « tiering », c’est Ă  dire la possibilitĂ© d’utiliser un SSD comme systĂšme de cache pour les fichiers qui sont beaucoup utilisĂ©s dans le but de gagner en vitesse d’exĂ©cution.

Rejoindre la beta

Tous les utilisateurs de XenServer dĂ©sireux de tester la solution peuvent le faire lors de cette seconde phase de beta. Il suffit de disposer d’une version gratuite de Xen Orchestra et d’une infrastructure XenServer sur laquelle dĂ©ployer XOSAN. Pour plus d’infos, vous pouvez consulter la documentation.

ATTENTION: Il s'agit d'un logiciel en version BĂȘta, ne l'utilisez pas en production !

Lire les commentaires

userdel: user vivek is currently used by process 749 error and fix on Linux

Par Vivek Gite
I am trying to delete a user named vivek using the userdel command as follows
userdel -r vivek userdel: user vivek is currently used by process 749

How do I fix this problem and delete username vivek on a Debian Linux 9.x server?

How to find bash shell function source code on Linux/Unix

Par Vivek Gite
I am a new Linux server user. I cannot figure out how to find out the source code of a bash function named foo() which is defined. How to locate the file where a bash function is defined and how to view the source code of foo() from shell prompt itself?

Stuff The Internet Says On Scalability For September 22nd, 2017

Par Todd Hoff

Hey, it's HighScalability time: 

 

Ever feel like howling at the universe? (Greg Rakozy)

 

If you like this sort of Stuff then please support me on Patreon.

 

  • 10 billion: API calls made every second in Google datacenters; $767,758,000,000: collected by Apple on iPhones sold to the end of June; 20: watts of power consumed by human brain, autonomous vehicles peak at 3000 watts; 59%: drop in leads using AMP; 27%: success rate of AIs guessing passwords; 2.8 kilometers: distance devices running on almost zero power can xmit using backscatter; 96: age at which Lotfi Zadeh, inventor of Fuzzy Logic, passed away; 35%: store time series data in a RDBMS; $1.1 billion: Google's spend on self-driving tech;  $5.1 billion: Slack valuation; 15%: bugs reduced by strong typing; ~1 ft: new smartphone GPS accuracy; 

  • Quotable Quotes:
    • Napoleon: [Sir Hudson Lowe] was a man wanting in education and judgment. He was a stupid man, he knew nothing at all of the world, and like all men who knew nothing of the world, he was suspicious and jealous.
    • Rich Werner: Data center operations, to me, is 362 days of boredom. And then you get these hurricanes coming through, and it’s three days of pulling your hair out.
    • @pacoid: @kenneth0stanley #TheAIConf "We're not interested in complexity for its own sake" -- ref. operational closure in second-order cybernetics
    • Animats: Much as I like Rust, I have to agree. When you have to get it done, use Go. When you want to explore advanced experimental programming constructs, use Rust. The Go guys knew when to stop. Arguably they stopped too early, before generics or parameterized types, and "interface[]" is used too much. But that doesn't seem to be a big overhead item. Rust has the complexity of C++ plus additional complexity from the functional community. Plus lots of fancy template cruft.
    • @mims: People who say data is the new oil are wrong. Non-volatile flash memory is the new oil.
    • @cmeik: As former member of a NoSQL startup, "Safety, reliability [as well as pay up front, save later] doesn't sell" sure sounds familiar.
    • @PaulDJohnston: ... simply because we've had 20 years of "servers" and 10 years of "instances" and now "containers"... they are all the same...
    • Venkatraman Ramakrishnan~ Inventions in one discipline can build on—and spur—basic research in many others, often unwittingly. It’s a virtuous cycle, and scientists take joy in exploiting all of it. Scientists are very promiscuous and the good ones are the most promiscuous.
    • @rightfold: Most of programmers learn early to avoid premature optimization. Next step: teach people about premature distributed computing.
    • @indievc: “Not heroine…Not cocaine….But Venture Capital is the drug flowing through the veins of most Silicon Valley startups”
    • @skamille: Editing is a different profession than writing, but code review and programming are both performed by the same people
    • XNormal: Mainframes had the reputation of being very expensive. But this is misleading. In terms of cost per processing task they were much more efficient than mini and microcomputers.
    • @swardley: "Culture eats strategy for breakfast" is code for "I don't know what the heck I'm talking about but this meme sounds smart"
    • James Glanz: Yet another data center, west of Houston, was so well prepared for the storm — with backup generators, bunks and showers — that employees’ displaced family members took up residence and United States marshals used it as a headquarters until the weather passed.
    • @pacoid: Neuroevolution talk @kenneth0stanley #theaiconf -- "exact gradient is not always the best move"; evolution uses fitness fn, not objective fn
    • @GossiTheDog: Holy crap. CCleaner trojan 1st stage payload is on 700k PCs, with these orgs targeted for 2nd stage (successfully) 
    • Scott Aaronson: In the meantime, the survival of the human race might hinge on people’s ability to understand much smaller numbers than 10^122: for example, a billion, a trillion, and other numbers that characterize the exponential growth of our civilization and the limits that we’re now running up against.
    • Timothy Morgan: Compute and networking could hit the Moore’s Law wall at about the same time, and that is precisely what we expect.
    • ralmidani: As I've said before, universal web components are a pipe dream. Developers disagree on even the most trivial things, like the best way to parse a query string. What makes anyone think those disagreements will magically disappear once web components become a standard?
    • Mallory Locklear: [Virus] Jumps between species have driven most major evolutionary innovations in the viruses. Meanwhile, co-divergence has been less common than was assumed and has mostly caused incremental changes.
    • @SwiftOnSecurity: Linux is like if the creator of git wrote an operating system.
    • A troll ate the rest of the quotes. Luckily, if luck it be, a copy was made and you can read all of them by clicking through to the full post.

    Don't miss all that the Internet has to say on Scalability, click below and become eventually consistent with all scalability knowledge (which means this post has many more items to read so please keep on reading)...

Ÿom : Gnirehtet réécrit en Rust

Par Âźom

Il y a quelques mois, j’ai prĂ©sentĂ© Gnirehtet, un outil de reverse tethering pour Android que j’ai Ă©crit en Java.

Depuis, je l’ai rĂ©Ă©crit en Rust.

Et il est également open source ! Téléchargez-le, branchez un téléphone ou une tablette Android, et exécutez :

./gnirehtet run

(adb doit ĂȘtre installĂ©)

Pourquoi Rust?

À Genymobile, nous voulions que Gnirehtet ne nĂ©cessite pas d’environnement d’exĂ©cution Java (JRE), donc le besoin principal Ă©tait de compiler l’application vers un binaire exĂ©cutable natif.

Par consĂ©quent, j’ai d’abord pensĂ© la rĂ©Ă©crire en C ou C++. Mais Ă  ce moment-lĂ  (dĂ©but mai), apprendre Rust m’intĂ©ressait, aprĂšs avoir vaguement entendu parler de ses fonctionnalitĂ©s:

Cependant, je n’avais jamais Ă©crit une ligne de Rust ni entendu parler de son systĂšme de possession, d’emprunt ou de durĂ©es de vie.

Mais je suis convaincu que le meilleur moyen d’apprendre un langage de programmation est de travailler Ă  plein temps sur un projet dans ce langage.

J’Ă©tais motivĂ©, donc aprĂšs avoir vĂ©rifiĂ© que ça pouvait convenir (en gros, j’ai Ă©crit un exemple utilisant la bibliothĂšque d’I/O asynchrone mio, et je l’ai exĂ©cutĂ© Ă  la fois sur Linux et Windows), j’ai dĂ©cidĂ© de rĂ©Ă©crire Gnirehtet en Rust.

Apprendre Rust

Pendant la rĂ©Ă©criture, j’ai dĂ©vorĂ© successivement le Rust book, Rust by example et le Rustonomicon. J’ai beaucoup appris, et j’aime Ă©normĂ©ment ce langage. Beaucoup de ses fonctionnalitĂ©s me manquent maintenant quand je travaille sur un projet C++ :

À propos de l’apprentissage, Paul Graham a Ă©crit:

Reading and experience train your model of the world. And even if you forget the experience or what you read, its effect on your model of the world persists. Your mind is like a compiled program you’ve lost the source of. It works, but you don’t know why.

Pour les non-anglophones, ma propre traduction :

La lecture et l’expĂ©rience entraĂźnent votre modĂšle du monde. Et mĂȘme si vous oubliez l’expĂ©rience ou ce que vous avez lu, son effet sur votre modĂšle du monde persiste. Votre esprit est comme un programme compilĂ© dont vous auriez perdu le code source. Ça fonctionne, mais vous ne savez pas pourquoi.

Certains des concepts de Rust (comme les durĂ©es de vie ou la sĂ©mantique de mouvement par dĂ©faut) m’ont fourni un jeu de donnĂ©es significativement diffĂ©rent, qui a sans aucun doute affectĂ© mon modĂšle du monde (de la programmation).

Je ne vais pas prĂ©senter toutes ces fonctionnaliĂ©s (cliquez sur les liens de la documentation si ça vous intĂ©resse). À la place, je vais essayer d’expliquer oĂč et pourquoi Rust a resistĂ© au design que je voulais implĂ©menter, et comment repenser les problĂšmes dans le pĂ©rimĂštre des contraintes de Rust.

La partie suivant nécessite une certaine connaissance de Rust. Vous pourriez vouloir la passer pour aller directement aux stats.

Difficultés

Je trouvais la conception de l’application Java plutĂŽt rĂ©ussie, donc je voulais reproduire l’architecture globale dans la version Rust (avec d’Ă©ventuelles adaptations pour la rustifier).

Mais j’ai luttĂ© sur les dĂ©tails, en particulier pour satisfaire le borrow checker. Les rĂšgles sont simples:

First, any borrow must last for a scope no greater than that of the owner. Second, you may have one or the other of these two kinds of borrows, but not both at the same time:

  • one or more references (&T) to a resource,
  • exactly one mutable reference (&mut T).

En français :

PremiĂšrement, aucun emprunt ne doit avoir une portĂ©e plus grande que celle de son propriĂ©taire. DeuxiĂšmement, vous pouvez avoir l’un ou l’autre de ces types d’emprunts, mais pas les deux Ă  la fois:

  • une ou plusieurs rĂ©fĂ©rences (&T) vers une ressource,
  • exactement une rĂ©fĂ©rence mutable (&mut T).

Cependant, il m’a fallu un peu de temps pour rĂ©aliser comment elles entrent en conflit avec certains principes ou modĂšles de conception.

Voici donc mes retours. J’ai sĂ©lectionnĂ© 4 sujets qui sont suffisamment gĂ©nĂ©raux pour ĂȘtre indĂ©pendants de ce projet particulier :

Encapsulation

Les rĂšgles d’emprunt contraignent l’encapsulation. C’est la premiĂšre consĂ©quence que j’ai rĂ©alisĂ©e.

Voici un exemple canonique :

pub struct Data {
    header: [u8; 4],
    payload: [u8; 20],
}

impl Data {
    pub fn new() -> Self {
        Self {
            header: [0; 4],
            payload: [0; 20],
        }
    }

    pub fn header(&mut self) -> &mut [u8] {
        &mut self.header
    }

    pub fn payload(&mut self) -> &mut [u8] {
        &mut self.payload
    }
}

fn main() {
    let mut data = Data::new();
    let header = data.header();
    let payload = data.payload();
}

Nous créons juste une nouvelle instance de Data, puis associons à des variables locales des références mutables vers les tableaux header et payload, en passant par des accesseurs.

Cependant, cela ne compile pas :

$ rustc sample.rs
error[E0499]: cannot borrow `data` as mutable more than once at a time
  --> sample.rs:21:19
   |
25 |     let header = data.header();
   |                  ---- first mutable borrow occurs here
26 |     let payload = data.payload();
   |                   ^^^^ second mutable borrow occurs here
27 | }
   | - first borrow ends here

Le compilateur ne peut pas faire l’hypothĂšse que header() et payload() retournent des rĂ©fĂ©rences vers des donnĂ©es disjointes dans la structure Data. Par consĂ©quent, chacun emprunte la structure data entiĂšrement. Vu que les rĂšgles d’emprunt interdisent d’obtenir deux rĂ©fĂ©rences mutables vers la mĂȘme ressource, il rejette le second appel.

Parfois, nous faisons face Ă  des limitations temporaires parce que le compilateur n’est pas (encore) assez malin. Ce n’est pas le cas ici : l’implĂ©mentation de header() pourrait trĂšs bien retourner une rĂ©fĂ©rence vers payload, ou Ă©crire dans le tableau payload, enfreignant ainsi les rĂšgles d’emprunt. Et la validitĂ© d’un appel d’une mĂ©thode ne peut pas dĂ©pendre de l’implementation de la mĂ©thode.

Pour corriger le problĂšme, le compilateur doit ĂȘtre capable de savoir que les variables locales header et payload rĂ©fĂ©rencent des donnĂ©es disjointes, par exemple en accĂ©dant aux champs directement :

    let header = &mut data.header;
    let payload = &mut data.payload;

ou en exposant une méthode fournissant les deux références simultanément :

struct Data {
    fn header_and_payload(&mut self) -> (&mut [u8], &mut [u8]) {
        (&mut self.header, &mut self.payload)
    }
}

fn main() {
    let mut data = Data::new();
    let (header, payload) = data.header_and_payload();
}

De mĂȘme, dans l’implĂ©mentation d’une structure, les rĂšgles d’emprunt empĂȘchent de factoriser du code dans une mĂ©thode privĂ©e facilement. Prenons cet exemple (artificiel) :

pub struct Data {
    buf: [u8; 20],
    prefix_length: usize,
    sum: u32,
    port: u16,
}

impl Data {
    pub fn update_sum(&mut self) {
        let content = &self.buf[self.prefix_length..];
        self.sum = content.iter().cloned().map(u32::from).sum();
    }

    pub fn update_port(&mut self) {
        let content = &self.buf[self.prefix_length..];
        self.port = (content[2] as u16)  8 | content[3] as u16;
    }
}

Ici, le champ buf est un tableau stockant un préfixe et un contenu de maniÚre contiguë.

Nous voulons factoriser la maniĂšre dont nous rĂ©cupĂ©rons la slice content, pour que les mĂ©thodes update_*() n’aient pas Ă  se prĂ©occuper des dĂ©tails. Essayons :

 impl Data {
     pub fn update_sum(&mut self) {
-        let content = &self.buf[self.prefix_length..];
+        let content = self.content();
         self.sum = content.iter().cloned().map(u32::from).sum();
     }

     pub fn update_port(&mut self) {
-        let content = &self.buf[self.prefix_length..];
+        let content = self.content();
         self.port = (content[2] as u16) +
+    fn content(&mut self) -> &[u8] {
+        &self.buf[self.prefix_length..]
+    }
 }

Malheureusement, cela ne compile pas :

error[E0506]: cannot assign to `self.sum` because it is borrowed
  --> facto2.rs:11:9
   |
10 |         let content = self.content();
   |                       ---- borrow of `self.sum` occurs here
11 |         self.sum = content.iter().cloned().map(u32::from).sum();
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ assignment to borrowed `self.sum` occurs here

error[E0506]: cannot assign to `self.port` because it is borrowed
  --> facto2.rs:16:9
   |
15 |         let content = self.content();
   |                       ---- borrow of `self.port` occurs here
16 |         self.port = (content[2] as u16) 

Comme dans l’exemple prĂ©cĂ©dent, rĂ©cupĂ©rer une rĂ©fĂ©rence Ă  travers une mĂ©thode emprunte la structure complĂšte (ici, self).

Pour contourner le problÚme, nous pouvons expliquer au compilateur que les champs sont disjoints :

impl Data {
    pub fn update_sum(&mut self) {
        let content = Self::content(&self.buf, self.prefix_length);
        self.sum = content.iter().cloned().map(u32::from).sum();
    }

    pub fn update_port(&mut self) {
        let content = Self::content(&self.buf, self.prefix_length);
        self.port = (content[2] as u16)  8 | content[3] as u16;
    }

    fn content(buf: &[u8], prefix_length: usize) -> &[u8] {
        &buf[prefix_length..]
    }
}

Ça compile, mais cela va totalement Ă  l’encontre de la factorisation : l’appelant doit fournir les champs nĂ©cessaires.

Comme alternative, nous pouvons utiliser une macro pour inliner le code :

macro_rules! content {
    ($self:ident) => {
        &$self.buf[$self.prefix_length..]
    }
}

impl Data {
    pub fn update_sum(&mut self) {
        let content = content!(self);
        self.sum = content.iter().cloned().map(u32::from).sum();
    }

    pub fn update_port(&mut self) {
        let content = content!(self);
        self.port = (content[2] as u16)  8 | content[3] as u16;
    }
}

Mais c’est loin d’ĂȘtre idĂ©al.

Je pense que nous devons juste l’accepter : l’encapsulation entre parfois en conflit avec les rĂšgles d’emprunt. AprĂšs tout, ce n’est pas si surprenant : imposer les rĂšgles d’emprunt nĂ©cessite de suivre chaque accĂšs concret aux ressources, alors que l’encapsulation vise Ă  les abstraire.

Observateur

Le design pattern observateur est utile pour enregistrer des événements sur un objet.

Dans certains cas, ce pattern pose des difficultĂ©s d’implĂ©mentation en Rust.

Pour faire simple, considérons que les événements sont des valeurs u32. Voici une implémentation possible :

pub trait EventListener {
    fn on_event(&self, event: u32);
}

pub struct Notifier {
    listeners: VecBoxEventListener>>,
}

impl Notifier {
    pub fn new() -> Self {
        Self { listeners: Vec::new() }
    }

    pub fn registerT: EventListener + 'static>(&mut self, listener: T) {
        self.listeners.push(Box::new(listener));
    }

    pub fn notify(&self, event: u32) {
        for listener in &self.listeners {
            listener.on_event(event);
        }
    }
}

Par commodité, implémentons notre trait EventListener pour les closures :

implF: Fn(u32)> EventListener for F {
    fn on_event(&self, event: u32) {
        self(event);
    }
}

Ainsi, son utilisation est simple :

    let mut notifier = Notifier::new();
    notifier.register(|event| println!("received [{}]", event));
    println!("notifying...");
    notifier.notify(42);

Cela affiche :

notifying...
received [42]

Jusqu’ici, tout va bien.

Cependant, les choses se compliquent si nous voulons modifier un Ă©tat sur la rĂ©ception d’un Ă©vĂ©nement. Par exemple, implĂ©mentons une structure pour stocker tous les Ă©vĂ©nements reçus :

pub struct Storage {
    events: Vecu32>,
}

impl Storage {
    pub fn new() -> Self {
        Self { events: Vec::new() }
    }

    pub fn store(&mut self, value: u32) {
        self.events.push(value);
    }

    pub fn events(&self) -> &Vecu32> {
        &self.events
    }
}

Pour pouvoir remplir ce Storage sur chaque Ă©vĂ©nement reçu, nous devons d’une maniĂšre ou d’une autre le passer avec l’event listener, qui sera stockĂ© dans le Notifier. Par consĂ©quent, nous avons besoin qu’une instance de Storage soit partagĂ©e entre le code appelant et le Notifier.

Avoir deux rĂ©fĂ©rences mutables vers le mĂȘme objet enfreint Ă©videmment les rĂšgles d’emprunt, donc nous avons besoin d’un pointeur Ă  compteur de rĂ©fĂ©rences.

Cependant, un tel pointeur est en lecture seul, donc nous avons Ă©galement besoin d’un RefCell pour la mutabilitĂ© intĂ©rieure.

Ainsi, nous allons utiliser une instance de Rc>. Cela peut sembler trop verbeux, mais utiliser Rc> (ou Arc> pour la thread-safety) est trĂšs courant en Rust. Et il y a pire.

Voici ce que donne le code client :

    use std::cell::RefCell;
    use std::rc::Rc;

    let mut notifier = Notifier::new();

    // first Rc to the Storage
    let rc = Rc::new(RefCell::new(Storage::new()));

    // second Rc to the Storage
    let rc2 = rc.clone();

    // register the listener saving all the received events to the Storage
    notifier.register(move |event| rc2.borrow_mut().store(event));

    notifier.notify(3);
    notifier.notify(141);
    notifier.notify(59);
    assert_eq!(&vec![3, 141, 59], rc.borrow().events());

De cette maniĂšre, le Storage est correctement modifiĂ© Ă  partir de l’event listener.

Tout n’est pas rĂ©solu pour autant. Dans cet exemple, c’Ă©tait facile, nous avions accĂšs Ă  l’instance Rc>. Comment faire si nous avons seulement accĂšs au Storage, par exemple si nous voulons que le Storage s’enregistre lui-mĂȘme Ă  partir de l’une de ses mĂ©thodes, sans que l’appelant n’ait Ă  fournir l’instance Rc> ?

impl Storage {
    pub fn register_to(&self, notifier: &mut Notifier) {
        notifier.register(move |event| {
            /* how to retrieve a &mut Storage from here? */
        });
    }
}

Nous devons trouver un moyen de récupérer le Rc> à partir du Storage.

Pour cela, l’idĂ©e consiste Ă  rendre Storage conscient de son pointeur Ă  compteur de rĂ©fĂ©rences. Bien sĂ»r, cela n’a du sens que si Storage est construit dans un Rc>.

C’est exactement ce que enable_shared_from_this fournit en C++, donc nous pouvons nous inspirer de son fonctionnement : juste stocker un Weak>, downgradĂ© Ă  partir du Rc>, dans la structure elle-mĂȘme. De cette maniĂšre, nous pouvons l’utiliser pour rĂ©cupĂ©rer une rĂ©fĂ©rence &mut Storage Ă  partir de l’event listener :

use std::rc::{Rc, Weak};
use std::cell::RefCell;

pub struct Storage {
    self_weak: WeakRefCellStorage>>,
    events: Vecu32>,
}

impl Storage {
    pub fn new() -> RcRefCellSelf>> {
        let rc = Rc::new(RefCell::new(Self {
            self_weak: Weak::new(), // initialize empty
            events: Vec::new(),
        }));
        // set self_weak once we get the Rc instance
        rc.borrow_mut().self_weak = Rc::downgrade(&rc);
        rc
    }

    pub fn register_to(&self, notifier: &mut Notifier) {
        let rc = self.self_weak.upgrade().unwrap();
        notifier.register(move |event| rc.borrow_mut().store(event))
    }
}

Voici comment l’utiliser :

    let mut notifier = Notifier::new();
    let rc = Storage::new();
    rc.borrow().register_to(&mut notifier);
    notifier.notify(3);
    notifier.notify(141);
    notifier.notify(59);
    assert_eq!(&vec![3, 141, 59], rc.borrow().events());

Il est donc possible d’implĂ©menter le design pattern observateur en Rust, mais c’est un peu plus difficile qu’en Java ;-)

Lorsque c’est possible, il est probablement prĂ©fĂ©rable de l’Ă©viter.

Partage de données mutables

Mutable references cannot be aliased.

En français :

Les rĂ©fĂ©rences mutables ne peuvent pas ĂȘtre aliasĂ©es.

Comment partager des données mutables, alors ?

Nous avons vu que nous pouvions utiliser Rc> (ou Arc>), qui impose les rĂšgles d’emprunt Ă  l’exĂ©cution. Cependant, ce n’est pas toujours dĂ©sirable :

  • cela force une nouvelle allocation sur le tas,
  • chaque accĂšs a un coĂ»t Ă  l’exĂ©cution,
  • l’emprunt concerne toujours la ressource entiĂšre.

Au lieu de cela, nous pourrions utiliser des pointeurs bruts manuellement dans du code non-sûr, mais alors ce serait non-sûr.

Et il y a une autre solution, qui consiste Ă  exposer des vues temporaires d’emprunt d’un objet. Laissez-moi expliquer.

Dans Gnirehtet, un paquet contient une rĂ©fĂ©rence vers les donnĂ©es brutes (stockĂ©es dans un buffer quelque part) ainsi que les valeur des champs des en-tĂȘtes IP et TCP/UDP (parsĂ©es Ă  partir du tableau d’octets brut). Nous aurions pu utiliser une structure Ă  plat pour tout stocker :

pub struct Packet'a> {
    raw: &'a mut [u8],
    ipv4_source: u32,
    ipv4_destination: u32,
    ipv4_protocol: u8,
    // + other ipv4 fields
    transport_source: u16,
    transport_destination: u16,
    // + other transport fields
}

Le Packet aurait fourni des setters pour tous les champs d’en-tĂȘtes (modifiant Ă  la fois les champs du paquet et le tableau d’octets). Par exemple :

impl'a> Packet'a> {
    pub fn set_transport_source(&mut self, transport_source: u16) {
        self.transport_source = transport_source;
        let transport = &mut self.raw[20..];
        BigEndian::write_u16(&mut transport[0..2], port);
    }
}

Mais cette conception ne serait pas terrible (surtout que les champs d’en-tĂȘtes TCP et UDP sont diffĂ©rents).

À la place, nous voudrions extraire les en-tĂȘtes d’IP et de transport vers des structures sĂ©parĂ©es, gĂ©rant leur propre partie du tableau d’octets :

// violates the borrowing rules

pub struct Packet'a> {
    raw: &'a mut [u8], // the whole packet (including headers)
    ipv4_header: Ipv4Header'a>,
    transport_header: TransportHeader'a>,
}

pub struct Ipv4Header'a> {
    raw: &'a mut [u8], // slice related to ipv4 headers
    source: u32,
    destination: u32,
    protocol: u8,
    // + other ipv4 fields
}

pub struct TransportHeader'a> {
    raw: &'a mut [u8], // slice related to transport headers
    source: u16,
    destination: u16,
    // + other transport fields
}

Vous avez immĂ©diatement repĂ©rĂ© le problĂšme : il y a plusieurs rĂ©fĂ©rences vers la mĂȘme ressource, le tableau d’octets raw, en mĂȘme temps.

Remarquez que diviser le tableau n’est pas une possibilitĂ© ici, vu que les slices de raw se chevauchent : nous avons besoin d’Ă©crire le paquet complet en une seule fois vers la couche rĂ©seau, donc le tableau raw dans Packet doit inclure les headers.

Nous avons besoin d’une solution compatible avec les rĂšgles d’emprunt.

Voici celle à laquelle je suis parvenu :

  • stocker les donnĂ©es des en-tĂȘtes sĂ©parĂ©ment, sans les slices de raw,
  • crĂ©er des structures de vues pour les en-tĂȘtes d’IP et de transport, liĂ©es Ă  une durĂ©e de vie,
  • exposer des mĂ©thodes de Packet retournant des instances de vues.

Et voici une simplification de l’implĂ©mentation rĂ©elle :

pub struct Packet'a> {
    raw: &'a mut [u8],
    ipv4_header: Ipv4HeaderData,
    transport_header: TransportHeaderData,
}

pub struct Ipv4HeaderData {
    source: u32,
    destination: u32,
    protocol: u8,
    // + other ipv4 fields
}

pub struct TransportHeaderData {
    source: u16,
    destination: u16,
    // + other transport fields
}

pub struct Ipv4Header'a> {
    raw: &'a mut [u8],
    data: &'a mut Ipv4HeaderData,
}

pub struct TransportHeader'a> {
    raw: &'a mut [u8],
    data: &'a mut TransportHeaderData,
}

impl'a> Packet'a> {
    pub fn ipv4_header(&mut self) -> Ipv4Header {
        Ipv4Header {
            raw: &mut self.raw[..20],
            data: &mut self.ipv4_header,
        }
    }

    pub fn transport_header(&mut self) -> TransportHeader {
        TransportHeader {
            raw: &mut self.raw[20..40],
            data: &mut self.transport_header,
        }
    }
}

Les setters sont implĂ©mentĂ©s sur les vues, oĂč ils dĂ©tiennent une rĂ©fĂ©rence mutable vers le tableau brut :

impl'a> TransportHeader'a> {
    pub fn set_source(&mut self, source: u16) {
        self.data.source = source;
        BigEndian::write_u16(&mut raw[0..2], source);
    }

    pub fn set_destination(&mut self, destination: u16) {
        self.data.destination = destination;
        BigEndian::write_u16(&mut raw[2..4], destination);
    }
}

De cette maniĂšre, les rĂšgles d’emprunt sont respectĂ©es, et l’API est Ă©lĂ©gante :

    let mut packet = ;
    // "transport_header" borrows "packet" during its scope
    let mut transport_header = packet.transport_header();
    transport_header.set_source(1234);
    transport_header.set_destination(1234);

Limitations du compilateur

Rust est un langage jeune, et le compilateur a quelques problĂšmes ennuyeux.

Le pire, d’aprĂšs moi, est liĂ© aux durĂ©es de vie non-lexicales, qui provoque des erreurs inattendues :

struct Container {
    vec: Veci32>,
}

impl Container {
    fn find(&mut self, v: i32) -> Optionmut i32> {
        None // we don't care the implementation
    }

    fn get(&mut self, v: i32) -> &mut i32 {
        if let Some(x) = self.find(v) {
            return x;
        }
        self.vec.push(v);
        self.vec.last_mut().unwrap()
    }
}
error[E0499]: cannot borrow `self.vec` as mutable more than once at a time
  --> sample.rs:14:9
   |
11 |         if let Some(x) = self.find(v) {
   |                          ---- first mutable borrow occurs here
...
14 |         self.vec.push(v);
   |         ^^^^^^^^ second mutable borrow occurs here
15 |         self.vec.last_mut().unwrap()
16 |     }
   |     - first borrow ends here

Heureusement, cela devrait ĂȘtre corrigĂ© prochainement.

La fonctionnalitĂ© d’Impl Trait, permettant aux fonctions de retourner des types abstraits non-boxĂ©s, devrait aussi amĂ©liorer l’expĂ©rience (il y a aussi une proposition Ă©tendue).

Le compilateur produit gĂ©nĂ©ralement des messages d’erreur trĂšs utiles. Mais quand ce n’est pas le cas, ils peuvent ĂȘtre trĂšs dĂ©routants.

Sûreté et piÚges

Le premier chapitre du Rustonomicon dit :

Safe Rust is For Reals Totally Safe.

[…]

Safe Rust is the true Rust programming language. If all you do is write Safe Rust, you will never have to worry about type-safety or memory-safety. You will never endure a null or dangling pointer, or any of that Undefined Behavior nonsense.

En français :

La partie Sûre de Rust est Réellement Totallement Sûre.

[…]

Le Rust SĂ»r est le vrai langage de programmation Rust. Si vous n’Ă©crivez que du Rust SĂ»r, vous n’aurez jamais Ă  vous inquiĂ©tez de la sĂ»retĂ© des types ou de la mĂ©moire. Vous n’aurez jamais Ă  supporter un pointeur null ou dangling, ou l’un de ces comportements indĂ©finis insensĂ©s.

C’est le but. Et c’est presque vrai.

Leakpocalypse

Dans le passĂ©, il a Ă©tĂ© possible d’Ă©crire du code Rust sĂ»r accĂ©dant Ă  de la mĂ©moire libĂ©rĂ©e.

Cette “leakpocalypse” a conduit Ă  la clarification des guaranties de sĂ»reté : ne pas exĂ©cuter un destructeur est maintenant considĂ©rĂ© sĂ»r. En d’autres termes, la sĂ»retĂ© mĂ©moire ne peut plus reposer sur RAII (en fait, elle n’a jamais pu, mais cela n’a Ă©tĂ© remarquĂ© que tardivement).

En conséquence, std::mem::forget est maintenant sûr, et JoinGuard a été déprécié et supprimé de la bibliothÚque standard (il a été déplacé vers un crate séparé).

Les autres outils s’appuyant sur RAII (comme Vec::drain()) doivent prendre des prĂ©cautions particuliĂšres pour garantir que la mĂ©moire ne sera pas corrompue.

Ouf, la sûreté mémoire est (maintenant) sauvée.

Infinité indéfinie

En C et C++, les boucles infinies sans effets de bords sont un cas d’undefined behavior. À cause de cela, il est possible d’Ă©crire des programmes qui, de façon inattendue, rĂ©futent le dernier thĂ©orĂšme de Fermat.

En pratique, le compilateur Rust s’appuie sur LLVM, qui (actuellement) applique ses optimisations en faisant l’hypothĂšse que les boucles infinies sans effets de bords ont un comportement indĂ©fini. En consĂ©quence, de tels undefined behaviors se produisent Ă©galement en Rust.

Voici un exemple minimal pour l’observer :

fn infinite() {
    loop {}
}

fn main() {
    infinite();
}

Quand on l’exĂ©cute sans optimisations, il se comporte comme “attendu” :

$ rustc ub.rs && ./ub
^C                    (infinite loop, interrupt it)

Mais activer les optimisations fait paniquer le programme :

$ rustc -O ub.rs && ./ub
thread 'main' panicked at 'assertion failed: c.borrow().is_none()', /checkout/src/libstd/sys_common/thread_info.rs:51
note: Run with `RUST_BACKTRACE=1` for a backtrace.

Nous pouvons aussi produire des résultats inattendus sans plantage :

fn infinite(mut value: u32) {
    // infinite loop unless value initially equals 0
    while value != 0 {
        if value != 1 {
            value -= 1;
        }
    }
}

fn main() {
    infinite(42);
    println!("end");
}
$ rustc ub.rs && ./ub
^C                    (infinite loop, interrupt it)

Mais avec optimisations :

$ rustc -O ub.rs && ./ub
end

C’est un cas particulier, qui sera probablement corrigĂ© dans le futur. En pratique, les garanties de sĂ»retĂ© de Rust sont trĂšs fortes (au prix d’ĂȘtre contraignantes).

Stats

C’est tout pour mes retours sur le langage lui-mĂȘme.

En supplément, comparons les versions Java et Rust du serveur relais.

Nombre de lignes

$ cloc relay-{java,rust}/src
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Rust                            29            687            655           4506
Java                            37            726            701           2931
-------------------------------------------------------------------------------

(tests included)

Le projet Rust est significativement plus gros, pour plusieurs raisons :

  • il y a beaucoup de classes de vues d’emprunt ;
  • la version Rust dĂ©finit sa propre classe de selecteur d’I/O asynchrone, encapsulant Poll de plus bas niveau, alors que la version Java utilise le Selector standard ;
  • la gestion d’erreur pour l’analyse de la ligne de commande est plus verbeuse.

La version Java contient plus de fichiers car les tests unitaires sont sĂ©parĂ©s, alors qu’en Rust ils se trouvent dans le mĂȘme fichier que les classes qu’ils testent.

Juste pour information, voici les résultats pour le client Android :

$ cloc app/src
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Java                            15            198            321            875
XML                              6              7              2             76
-------------------------------------------------------------------------------
SUM:                            21            205            323            951
-------------------------------------------------------------------------------

Taille des binaires

--------------------------------------------
Java     gnirehtet.jar                   61K
--------------------------------------------
Rust     gnirehtet                      3.0M
         after "strip -g gnirehtet"     747K
         after "strip gnirehtet"        588K
--------------------------------------------

Le binaire Java lui-mĂȘme est bien plus petit. La comparaison n’est pas juste cependant, vu qu’il nĂ©cessite l’environnement d’exĂ©cution Java :

$ du -sh /usr/lib/jvm/java-1.8.0-openjdk-amd64/
156M	/usr/lib/jvm/java-1.8.0-openjdk-amd64/

Utilisation mémoire

Avec une seule connection TCP ouvert, voici la consommation mémoire pour le serveur relais en Java :

$ sudo pmap -x $RELAY_JAVA_PID
                  Kbytes     RSS   Dirty
total kB         4364052   86148   69316

(résultat filtré)

Et pour le serveur relais en Rust :

$ sudo pmap -x $RELAY_RUST_PID
                  Kbytes     RSS   Dirty
total kB           19272    2736     640

Regardez la valeur RSS, qui indique la mémoire réellement utilisée.

Comment on pouvait s’y attendre, la version Java consomme plus de mĂ©moire (86Mo) que la version Rust (moins de 3Mo). De plus, sa valeur est instable Ă  cause de l’allocation de petits objets et leur garbage collection, qui gĂ©nĂšre aussi davantage de dirty pages. La valeur pour Rust, quant Ă  elle, est trĂšs stable : une fois la connection crĂ©Ă©e, il n’y a plus d’allocations mĂ©moire du tout.

Utilisation CPU

Pour comparer l’utilisation CPU, voici mon scĂ©nario : un fichier de 500Mo est hĂ©bergĂ© par Apache sur mon ordinateur, je dĂ©marre le serveur relais avec perf stat, puis je tĂ©lĂ©charge le fichier Ă  partir de Firefox sur Android. DĂšs que le fichier est tĂ©lĂ©chargĂ©, je stoppe le serveur relais (Ctrl+C).

Voici les résultats pour la version Java :

$ perf stat -B java -jar gnirehtet.jar relay
 Performance counter stats for 'java -jar gnirehtet.jar relay':

      11805,458302      task-clock:u (msec)       #    0,088 CPUs utilized
                 0      context-switches:u        #    0,000 K/sec
                 0      cpu-migrations:u          #    0,000 K/sec
            28 618      page-faults:u             #    0,002 M/sec
    17 908 360 446      cycles:u                  #    1,517 GHz
    13 944 172 792      stalled-cycles-frontend:u #   77,86% frontend cycles idle
    18 437 279 663      instructions:u            #    1,03  insn per cycle
                                                  #    0,76  stalled cycles per insn
     3 088 215 431      branches:u                #  261,592 M/sec
        70 647 760      branch-misses:u           #    2,29% of all branches

     133,975117164 seconds time elapsed

Et pour la version Rust :

$ perf stat -B ./gnirehtet relay
 Performance counter stats for 'target/release/gnirehtet relay':

       2707,479968      task-clock:u (msec)       #    0,020 CPUs utilized
                 0      context-switches:u        #    0,000 K/sec
                 0      cpu-migrations:u          #    0,000 K/sec
             1 001      page-faults:u             #    0,370 K/sec
     1 011 527 340      cycles:u                  #    0,374 GHz
     2 033 810 378      stalled-cycles-frontend:u #  201,06% frontend cycles idle
       981 103 003      instructions:u            #    0,97  insn per cycle
                                                  #    2,07  stalled cycles per insn
        98 929 222      branches:u                #   36,539 M/sec
         3 220 527      branch-misses:u           #    3,26% of all branches

     133,766035253 seconds time elapsed

Je ne suis pas un expert pour analyser les rĂ©sultats, mais de ce que je comprends de la valeur task-clock:u, la version Rust consomme 4× moins de temps CPU.

Conclusion

RĂ©Ă©crire Gnirehtet en Rust a Ă©tĂ© une formidable expĂ©rience, oĂč j’ai appris un super langage et de nouveaux concepts de programmation. Et maintenant, nous avons une application native avec de meilleures performances.

Bon reverse tethering !

Discussions sur reddit.

Gravatar de Âźom
Original post of Âźom.Votez pour ce billet sur Planet Libre.

  • 21 septembre 2017 Ă  15:00

Le piratage serait sans effet sur les ventes légales de films, musique
etc

Par Korben

La civilisation humaine s'Ă©tant bĂątie en grande partie sur des mythes et des lĂ©gendes, il n'est pas rare d'en trouver encore Ă  notre Ă©poque oĂč pourtant la science est reine. Parmi les mythes rĂ©cents, on trouve bien sĂ»r ceux chers aux climatosceptiques, mais aussi le fameux changement de couleur de la piscine quand vous faites pipi dedans, l'existence du YĂ©ti ou celui qui dit qu'au cours de votre vie, vous avalez je ne sais combien de kilos d'insectes en dormant.

Mais mon préféré reste celui qui dit que le piratage fait baisser les ventes de films, de musique...etc.

En effet, on vient d'apprendre qu'en 2014, la Commission Européenne a payé 360 000 euros à un cabinet de consulting pour un rapport établissant les effets du piratage sur les ventes. Finalisé en mai 2015, ce rapport de 300 pages que vous pouvez consulter ici, nous apprend sans surprise, qu'il n'existe aucune preuve pouvant soutenir l'idée que le piratage a un effet négatif sur les ventes de contenus copyrightés. Et évidemment, il n'existe pas non plus de preuve prouvant le contraire, c'est-à-dire que le piratage a un effet positif sur la vente de contenus.

Julia Reda qui représente le Parti Pirate au parlement Européen a eu vent de l'affaire et a publié une demande auprÚs de la Commission Européenne pour avoir accÚs à ce rapport resté confidentiel. En gros, ce qu'on peut y lire, c'est qu'aucune preuve statistique ne permet d'établir qu'il y a un lien de cause à effet entre le piratage et les ventes de films ou de musique de maniÚre globale, mis à part pour une poignée de gros films ou séries à succÚs (les fameux blockbusters). Pour ces derniers, il y aurait pour 10 blockbusters piratés regardés, 4 de moins regardés légalement. Cela veut dire que dans le cas des blockbusters uniquement, il y a un effet de déplacement du légal vers l'illégal de 40%.

Autrement pour tout le reste, ce qui doit représenter 99,999 % du marché de la culture et du divertissement, il n'y a rien qui puisse prouver que cela impacte négativement ou positivement les revenus des ayants droit. Comme si le piratage et la vente légale étaient 2 concepts étrangers l'un à l'autre, sans aucun lien...

Bref, le mystĂšre reste entier et le mythe risque de perdurer encore un petit moment, mais si ce qui est vĂ©ritablement intĂ©ressant ici, c'est que durant 2 ans, ce rapport est restĂ© secret et on ne sait pas vraiment pourquoi. MĂȘme si je vous avoue, j'ai bien quelques petites idĂ©es.

Source

Cet article merveilleux et sans aucun Ă©gal intitulĂ© : Le piratage serait sans effet sur les ventes lĂ©gales de films, musique…etc ; a Ă©tĂ© publiĂ© sur Korben, le seul site qui t'aime plus fort que tes parents.

How to Add Percona MySQL Monitoring on Cacti

Par Pavlo Maiorchyk

In this article, I am going to show how to use cacti monitoring for MySQL. For test purposes, I will use Ubuntu 16.04 with cacti 0.8.8f and MySQL 5.6 installed. If you don't have anything installed refer to our setup cacti [...]

The post How to Add Percona MySQL Monitoring on Cacti appeared first on LinOxide.

Un cas de dopage : GĂ©gĂ© sous l’emprise du Dr Valvin

Par Goofy

Quand un libriste s’amuse Ă  reprendre et dĂ©velopper spectaculairement un petit Framaprojet, ça mĂ©rite bien une interview ! Voici Valvin, qui a dopĂ© notre, – non, votre Geektionnerd Generator aux stĂ©roĂŻdes !

GĂ©gĂ©, le gĂ©nĂ©rateur de Geektionnerd, est un compagnon dĂ©jĂ  ancien de nos illustrations plus ou moins humoristiques. VoilĂ  4 ans que nous l’avons mis Ă  votre disposition, comme en tĂ©moigne cet article du Framablog qui vous invitait Ă  vous en servir en toute occasion. Le rapide historique que nous mentionnions Ă  l’Ă©poque, c’est un peu une chaĂźne des relais qui se sont succĂ©dĂ© de William Carvalho jusqu’Ă  Gee et ses toons en passant par l’intervention en coulisses de Cyrille et Quentin.

Vous le savez, hormis le frĂ©nĂ©tique Luc qu’on est obligĂ©s de piquer d’une flĂšche hypodermique pour l’empĂȘcher de coder Ă  toute heure, on dĂ©veloppe peu Ă  Framasoft. Aussi n’est-il guĂšre surprenant que ce petit outil ludique soit restĂ© en sommeil sans Ă©volution particuliĂšre pendant ces derniĂšres annĂ©es oĂč la prioritĂ© allait aux services de DĂ©googlisons.

Enfin Valvin vint, qui Ă  l’occasion de l’ajout d’une tripotĂ©e de nouveaux personnages se mit Ă  coder vite et bien, poursuivant avec la complicitĂ© de Framasky – ĂŽ BeautĂ© du code libre ! – la chaĂźne amicale des contributeurs.

Mais faisons connaissance un peu avec celui qui vient d’ajouter gĂ©nĂ©reusement des fonctionnalitĂ©s sympathiques Ă  GĂ©gĂ©.

Commençons par l’exercice rituel : peux-tu te prĂ©senter pour nos lecteurs et lectrices. Qui es-tu, Valvin ?

Salut Framasoft, je suis donc Valvin, originaire de MontĂ©limar, j’habite maintenant dinch Nord avec ma petite famille. Je suis un peu touche-Ă -tout et il est vrai que j’ai une attirance particuliĂšre pour le Libre mais pas uniquement les logiciels.

 

Qu’est-ce qui t’a amenĂ© au Libre ? Tu es tombĂ© dedans quand tu Ă©tais petit ou bien tu as eu droit Ă  une potion magique ?

J’ai commencĂ© en tant qu’ingĂ©nieur sur les technologies Microsoft (dĂ©veloppement .NET, Active Directory, SQL Server…) J’avais bien commencĂ© non ? Puis Pepper m’a concoctĂ© une potion et puis …. vous savez qu’elle ne rĂ©ussit pas souvent ses potions ?

Plus sĂ©rieusement lors de mon parcours professionnel, j’ai travaillĂ© dans une entreprise oĂč Linux Ă©tait largement dĂ©ployĂ©, ce qui m’a amenĂ© Ă  rencontrer davidb2111, libriste convaincu depuis tout petit (il a dĂ» tomber dans la marmite …). Et je pense que c’est lui qui m’a mis sur la voie du Libre…

Cependant ce qui m’a fait passer Ă  l’action a Ă©tĂ© la 1re campagne « DĂ©googlisons Internet »… Elle a dĂ©butĂ© juste aprĂšs mon expĂ©rience de e-commerce, quand je gĂ©rais un petit site web de vente en ligne oĂč j’ai dĂ©couvert l’envers du dĂ©cor : Google analytics, adwords, comparateurs de prix… et pendant que j’intĂ©grais les premiers terminaux Android industriel.

Je suis maintenant un libriste convaincu mais surtout défenseur de la vie privée. Certains diront extrémiste mais je ne le pense pas.

Dans ta vie professionnelle, le Libre est-il prĂ©sent ou bien est-ce compliquĂ© de l’utiliser ou le faire utiliser ?
Aujourd’hui, je suis une sorte d’administrateur systĂšme mais pour les terminaux mobiles industriels (windows mobile/ce mais surtout Android). Pour ceux que ça intĂ©resse, ça consiste Ă  rĂ©fĂ©rencer du matĂ©riel, industrialiser les prĂ©parations, administrer le parc avec des outils MDM (Mobile Device Management), mais pas seulement !

Je suis en mission chez un grand compte (comme ils disent) oĂč le Libre est prĂ©sent mais pas majoritairement. On le retrouve principalement cĂŽtĂ© serveur avec Linux (CentOS), Puppet, Nagios/Centreon, PostgreSQL … (la liste est longue en fait). AprĂšs je travaille sur Android au quotidien mais j’ai un peu du mal Ă  le catĂ©goriser dans le Libre ne serait-ce qu’en raison de la prĂ©sence des Google Play Services.

J’ai la chance d’avoir mon poste de travail sous Linux mais j’utilise beaucoup d’outils propriĂ©taires au quotidien. (j’dĂ©marre mĂȘme des fois une VM Windows … mais chuuuut ! !).

Je suis assez content d’avoir mis en place une instance Kanboard (Framaboard) en passant par des chemins obscurs mais de nombreux utilisateurs ont pris en main l’outil ce qui en fait aujourd’hui un outil officiel.

On dĂ©couvre des choses diverses sur ton blog, des articles sur le code et puis un Valvin fan de graphisme et surtout qui est prĂȘt Ă  contribuer dĂšs qu’il y a passion ? Alors, tu as tellement de temps libre pour le Libre ?

Du temps quoi ?… Malheureusement, je n’ai pas beaucoup de temps libre entre le travail, les trajets quotidien (plus de 2 heures) et la famille. Du coup, une fois les enfants couchĂ©s, plutĂŽt que regarder la tĂ©lĂ©, j’en profite (entre deux dessins).
Mes contributions dans le libre sont principalement autour du projet de David Revoy, Pepper & Carrot. J’ai la chance de pouvoir vivre l’aventure Ă  ses cĂŽtĂ©s ainsi que de sa communautĂ©. Et dans l’univers de la BD, c’est inĂ©dit ! D’ailleurs je te remercie, Framasoft, de me l’avoir fait dĂ©couvrir :)
Si je peux filer un petit coup de main avec mes connaissances sur un projet qui me tient Ă  cœur, je n’hĂ©site pas. Et mĂȘme si ce n’est pas grand-chose, ça fait plaisir d’apporter une pierre Ă  l’Ă©difice et c’est ça aussi la magie du Libre !
J’ai eu parfois l’ambition de lancer moi mĂȘme des projets libres mais j’ai bien souvent sous-estimĂ© le travail que ça reprĂ©sentait …

Et maintenant, tu t’attaques au geektionnerd, pourquoi tout Ă  coup une envie d’amĂ©liorer un projet/outil qui vivotait un peu ?
Je dois avouer que c’est par hasard. J’ai vu un message sur Mastodon qui m’a fait dĂ©couvrir le projet. Il n’y a pas si longtemps, je m’Ă©tais intĂ©ressĂ© au projet Bird’s DessinĂ©s et j’avais trouvĂ© le concept sympa. Mais tout Ă©tait un peu verrouillĂ©, notamment les droits sur les rĂ©alisations. J’aime bien le dessin et la bande dessinĂ©e, le projet du gĂ©nĂ©rateur de Geektionnerd m’a paru trĂšs simple Ă  prendre en main… du coup, je me suis lancé !

Tu peux parler des problÚmes du cÎté code qui se sont posés, comment les as-tu surmontés  ?
Globalement, ça s’est bien passĂ© jusqu’au moment oĂč j’ai voulu ajouter des images distantes dans la bibliothĂšque. Le pire de l’histoire c’est que ça fonctionnait bien Ă  premiĂšre vue. On pouvait ajouter toutes les images que l’on voulait, les dĂ©placer… Nickel ! Et puis j’ai cliquĂ© sur « Enregistrer l’image » et lĂ … j’ai dĂ©couvert la magie de  CORS !

CORS signifie Cross Origin Ressource Sharing et intervient donc lorsque le site web tente d’accĂ©der Ă  une ressource qui ne se situe pas sur son nom de domaine.
Il est possible de créer une balise image html qui pointe vers un site extérieur du type :

<img src="https://www.peppercarrot.com/extras/html/2016_cat-generator/avatar.php?seed=valvin" alt="c'est mon avatar" />

En revanche, rĂ©cupĂ©rer cette image pour l’utiliser dans son code JavaScript, c’est possible mais dans certaines conditions uniquement. Typiquement, si j’utlise jquery et que je fais :

$.get("https://www.peppercarrot.com/extras/html/2016_cat-generator/avatar.php?seed=Linux", function(data){
    $("#myImg").src = data ;
}) ;

On obtient :

Cross-Origin Request Blocked : The Same Origin Policy disallows reading the remote resource at https://www.peppercarrot.com/extras/html/2016_cat-generator/avatar.php?seed=Linux. (Reason : CORS header 'Access-Control-Allow-Origin' missing).

En revanche, si on utilise une image hĂ©bergĂ©e sur un serveur qui autorise les requĂȘtes Cross-Origin, il n’y a pas de souci :

$.get("https://i.imgur.com/J2HZir3.jpg", function(data){
    $("#myImg").src = data ;
}) ;

Tout cela en raison de ce petit en-tĂȘte HTTP que l’on obtient du serveur distant :

Access-Control-Allow-Origin *

oĂč `*` signifie tout le monde, mais il est possible de ne l’autoriser que pour certains domaines.
Avec les canvas, ça se passait bien jusqu’Ă  la gĂ©nĂ©ration du fichier PNG car on arrivait au moment oĂč l’on devait rĂ©cupĂ©rer la donnĂ©e pour l’intĂ©grer avec le reste de la rĂ©alisation. J’avais activĂ© un petit paramĂštre dans la librairie JavaScript sur l’objet Image

image.crossOrigin = "Anonymous" ;

mais avec ce paramĂštre, seules les images dont le serveur autorisait le Cross-Origin s’affichaient dans le canvas et la gĂ©nĂ©ration du PNG fonctionnait. Mais c’Ă©tait trop limitatif.

Bref, bien compliqué pour par grand-chose !

J’ai proposĂ© de mettre en place un proxy CORS, un relais qui rajoute simplement les fameux en-tĂȘtes mais ça faisait un peu usine Ă  gaz pour ce projet. Heureusement, framasky a eu une idĂ©e toute simple de tĂ©lĂ©chargement d’image qui a permis de proposer une alternative.
Tout cela a fini par aboutir, aprÚs plusieurs tentatives à ce Merge Request : https://framagit.org/framasoft/geektionnerd-generator/merge_requests/6

Et aprÚs tous ces efforts quelles sont les fonctionnalités que tu nous as apportées sur un plateau ?

Chaud devant ! ! Chaud ! ! !

  • Tout d’abord, j’ai ajoutĂ© le petit zoom sur les vignettes qui Ă©tait trop petites Ă  mon goĂ»t

  • Ensuite, j’ai agrandi la taille de la zone de dessin en fonction de la taille de l’Ă©cran. Mais tout en laissant la possibilitĂ© de choisir la dimension de la zone car dans certains cas, on ne souhaite qu’une petite vignette carrĂ©e et cela Ă©vite de rĂ©-Ă©diter l’image dans un second outil.

  • Et pour terminer, la possibilitĂ© d’ajouter un image depuis son ordinateur. Cela permet de complĂ©ter facilement la bibliothĂšque dĂ©jĂ  bien remplie :)

Merci ! D’autres dĂ©veloppements envisagĂ©s, d’autres projets, d’autres cartoons dans tes cartons ?

D’autres dĂ©veloppements pour Geektionnerd ? Euh oui, j’ai plein d’idĂ©es … mais est ce que j’aurai le temps ?
– intĂ©gration Lutim pour faciliter le partage des rĂ©alisations
– recherche dans la librairie de toons Ă  partir de tags (nĂ©cessite un rĂ©fĂ©rencement de mĂ©ta-data par image)
– sĂ©paration des toons des bulles et dialogues : l’idĂ©e serait de revoir la partie gauche de l’application et trouver facilement les diffĂ©rents types d’images. Notamment en dĂ©coupant par type d’image : bulles / personnages / autres.
– ajout de rectangles SVG pour faire des cases de BD
– amĂ©lioration de la saisie de texte (multi-ligne) et sĂ©lection de la fonte pour le texte
– …
Je vais peut-ĂȘtre arrĂȘter là :)

Sinon dans les cartons, j’aimerais poursuivre mon projet Privamics dont l’objectif est de rĂ©aliser des mini-BD sur le sujet de la vie privĂ©e de façon humoristique. Mais j’ai vu avec le premier Ă©pisode que ce n’Ă©tait pas une chose si facile. Du coup, je privilĂ©gie mon apprentissage du dessin :)

Bien entendu, Pepper & Carrot reste le projet auquel je souhaite consacrer le plus de temps car je trouve que le travail que fait David est tout simplement fantastique !

Le mot de la fin est pour toi…
Un grand merci Ă  toi Framasoft, tu m’as dĂ©jĂ  beaucoup apportĂ© et ton projet me tient particuliĂšrement Ă  cœur.

Vive le Libre ! ! ! :)

Take a trip through music history with the Great 78 Project

Par clhermansen
Take a trip through music history with the Great 78 Project

A few weeks ago, a friend sent me a link to the Great 78 Project, "a community project for the preservation, research, and discovery of 78 rpm records." The project is supported by the Internet Archive, George Blood, and the


read more
  • 22 septembre 2017 Ă  07:01

4 must-have writing apps for Nextcloud

Par Tati
4 must-have writing apps for Nextcloud

If writing is part of your job or your everyday routine, you might find the Nextcloud open source file sync and share application a very useful tool. First, it provides you with free, secure, and easily accessible cloud file storage.


read more
  • 22 septembre 2017 Ă  07:00

Top 5: Emacs and Vim alternatives, Linux cluster admin tips, and more

Par Don Watkins
Top 5 articles for the week of September 22, 2017

In this week's top 5, we take a look at Emacs and Vim alternatives, Linux cluster admin tips, and more.


read more
  • 22 septembre 2017 Ă  07:00

Open Source Summit: Day 2 features TensorFlow, BlockChain, and HitRecord

Par greggpollack
Open Source Summit: Day 2

The actor and founder of HitRecord Joseph Gordon-Levitt kicked off the second day of the Open Source Summit. His open creative community, HitRecord, allows for the evolution of open source film projects. We learned how a company is using BlockChain to fight poverty while keeping plastic out of the ocean, and about how Microsoft and Google are now more deliberate about how they create a culture of openness inside and outside their companies.

Watch as Jason Hibbets and I give you a quick summary of day 2, and I manage to understand what TensorFlow is along the way.


read more
  • 21 septembre 2017 Ă  14:45

Plus que 3 jours de promos chez Amazon et Sonoff sur les Ă©quipements domotiques

Par christophe

Il ne reste plus que quelques jours pour profiter des grosses promos de la rentrĂ©e proposĂ©es par Amazon et Sonoff sur sa boutique AliExpress ! Trop tard pour profiter du Raspberry Pi 3 en promo Ă  29,17€ chez Gearbest mais il est toujours au prix trĂšs raisonnable de 37,70€ chez Amazon.

Il reste encore quelques offres intéressantes chez Amazon

Il y a encore de grosses remises (de 10 Ă  40%) sur de nombreux produits Sonoff sur la boutique AliExpress d’Itead :

  • Le module de commande WiFi 4 relais Sonoff 4CH et 4CH Pro (alimentation 5-24VDC, commande radio RF) prĂ©sentĂ© ici
  • La prise connectĂ©e Sonoff S20 hackĂ©e pour installer le firmware ESP Easy dans ce tutoriel

La promo se termine dans trois jours

La plupart des produits Sonoff sont certifiĂ©s FC/CE (Ă  l’exception des anciens modĂšles. Basic, S20…). Tous les produits Sonoff WiFi utilisent un SoC ESP8285 sur lequel il est trĂšs facile d’installer un autre firmware Open Source. Le plus connu ESP Easy, mais Ă©galement Tasmota ou Espurna. De nouveaux tutoriels arrivent pour expliquer comment faire… En attendant, bon shopping !

Cet article Plus que 3 jours de promos chez Amazon et Sonoff sur les Ă©quipements domotiques est apparu en premier sur Projets DIY - Domotique et objets connectĂ©s Ă  faire soi-mĂȘme.

Programmer l’ESP8266 avec l’IDE Arduino : librairies, GPIO, Web Serveur, Client Web

Par christophe

Les modules WiFi ESP8266 peuvent remplacer dans beaucoup d’applications l’Arduino en ajoutant Ă  moindre coĂ»t la connectivitĂ© Wi-Fi. Au lancement des modules ESP8266 (en 2014), la langage de programmation de prĂ©dilection Ă©tait de Lua (on peut d’ailleurs toujours programmer dans ce langage !). Rapidement, la grande majoritĂ© des librairies Arduino ont Ă©tĂ© adaptĂ©es pour fonctionner sur l’ESP8266. Aujourd’hui il est aussi simple de programmer un module ESP8266 qu’un Arduino en C++. Nous allons dĂ©couvrir dans ce tutoriel comment installer les librairies nĂ©cessaires sur l’IDE Arduino, et dĂ©couvrir au travers d’exemples simples les bases de la programmations de l’ESP8266.

Installer les cartes et les librairies pour les modules ESP8266 sur l’IDE Arduino

Lancez l’IDE Arduino et ouvrez les prĂ©fĂ©rences depuis le menu Fichier. Sur macOS, allez dans le menu Arduino puis PrĂ©fĂ©rences… Cliquez sur l’icĂŽne indiquĂ©e par la flĂšche rouge sur la photo ci-dessous.

ide arduino esp8266 preference

Dans le champ de saisie, collez l’adresse internet suivante puis validez

http://arduino.esp8266.com/staging/package_esp8266com_index.json

ide arduino libraire url esp8266

Cela permet d’indiquer Ă  l’IDE Arduino qu’il doit aller sur le site arduino.esp8266.com afin d’aller y rĂ©cupĂ©rer d’autres cartes compatibles. Maintenant, allez dans le menu Outils puis Type de Cartes et enfin Gestionnaire de carte

 ide arduino gestionnaire carte

Dans le champ de recherche, saisissez esp8266 pour trouver les nouvelles cartes Ă  installer. Si les cartes n’apparaissent pas, vĂ©rifiez dans les prĂ©fĂ©rences que l’URL est correcte. vĂ©rifiez Ă©galement la connexion Internet. Cliquer sur Installer.

ide arduino install esp8266 board

L’installation ne dure que quelques minutes. L’installation terminĂ©e, fermez le gestionnaire de carte et ouvrez de nouveau le menu Outils. Dans le sous-menu Type de Carte, vous avez maintenant une nouvelle section appelĂ©e ESP8266 Modules.

ide arduino esp8266 board list

Les principaux fabricants qui contribuent le plus Ă  la communautĂ© (Adafruit, ESPresso, Olimex, Sparkfun, WeMos…) se trouvent dans le menu. Pour les autres modules, choisissez simplement Generic ESP8266 Module.

Pour afficher le exemples installĂ©s avec les cartes ESP826, if suffit de choisir dans la liste puis d’aller dans le Fichier -> Exemples.

Avant d’aller plus loin, remarque sur l’ESP-01

esp8266 esp-01 module WifiL’ESP-01 est une version plus limitĂ©e de l’ESP8266. Il ne dispose que de 2 GPIO. Le module dispose d’une mĂ©moire flash plus petite (de 512Ko Ă  1MB). La programmation est identique mais “plus pĂ©nible” car il faut mettre le module dans un mode particulier avant de pouvoir tĂ©lĂ©verser le programme (Bootload mode). Ce n’est pas un module adaptĂ© pour l’apprentissage et dĂ©buter avec l’ESP8266. Si toutefois vous avez besoin d’infos, vous trouverez plusieurs tutoriels sur le blog en faisant une recherche avec le mot clĂ© ESP-01 dans le champ de recherche situĂ© dans le coin supĂ©rieur droit de la page.

Différences entre Arduino et ESP8266, repérage des broches

L’ESP8266 dispose de 9 E/S numĂ©riques au lieu de 14 pour l’Arduino Uno. Alors que sur l’Arduino Uno il n’y a que 6 sorties qui supportent le mode PWM (3, 5, 6, 9, 10 et 11), toutes les sorties de l’ESP8266 peuvent gĂ©nĂ©rer un signal PWM.

En résumé

Arduino / Genuino 101 ESP8266 (ESP-12x)
Micro-contrÎleur Arduio Uno et la plupart des cartes compatibles : ATmel ATmega328p

Le nouveau Genuino 101 : Intel Curie

Tensilica Xtensa LX106
WiFi
Bluetooth LE
Adressage 8…32bits 32bits
FrĂ©quence d’horloge 16 MHz 80 MHz
MĂ©moire flash 32ko 512…4Mo (1)
Nombre d’E/S x14 x11 (D0…D8 + RX/TX)
Nombre de sorties PWM Arduino Uno et clones : x6 (3, 5, 6, 9, 10, 11)

Arduino 101 : x4

Toutes les sorties sont PWM
Nombre d’entrĂ©es analogiques x6 (A0..A5), 10bits, 5V max. x1 (A0), 10 bits, 1V max. (2) 
UART (port série) x1 x1 (3)
I2C x1 x1
SPI x1 x1
Documentation technique Arduino Uno R3

Genuino 101

version 5.4

Le repĂ©rage des broches est lĂ©gĂšrement diffĂ©rent sur l’ESP8266. Chaque sortie est prĂ©cĂ©dĂ©e d’un D (pour Digital probablement). Dans un programme Arduino, on peut directement utiliser le repĂšre indiquĂ© sur la carte D1 ou l’Ă©quivalent Arduino 5.

(1) MĂ©moire externe. Aujourd’hui, presque tous les modĂšles disposent de 4Mo de mĂ©moire flash. La totalitĂ© n’est pas exploitable toutefois. Une partie est rĂ©servĂ©e au stockage de donnĂ©es (stockage de donnĂ©es utilisateur, interface HTML et code javascript de l’interface…). C’est la zone SPIFFS prĂ©sentĂ©e dans cet article.

(2) L’ESP8266 accepte 1V maximum sur la broche analogique. Certains modules de intĂšgrent un pont diviseur de tension qui permet de monter la tension. Par exemple la Wemos d1 mini accepte 3,3V max. 

(3) Un seul port sĂ©rie utilisable. L’autre broche TX est utilisĂ©e durant l’Ă©criture de la mĂ©moire flash

Attention. Chaque fabricant est libre d’attribuer les broches. C’est notamment le cas des broches des bus I2C et SPI. Il faudra vĂ©rifier la documentation technique de la carte. Vous pouvez Ă©galement consulter cet article qui rĂ©capitule les broches des principales cartes en vente
Broches ESP8266 Remarque Equivalent Arduino / Genuino 101 Autre utilisation
TX 1 CS1, TXD0
RX 3 RXD0
D0 PWM (1) 16 WAKE
D1 PWM 5
D2 PWM 4
D3 PWM 0 CS2
D4 PWM 2 TXD1
D5 PWM 14 CLK
D6 PWM 12 MISO
D7 PWM 13 MOSI, RXD2, CTS0
D8 PWM 15 CS, TXD2, RTS0
RST RST
A0 3.3V max. A0
3V3 3V
5V 800 mA maxi.
G GND (x3)

(1) ReliĂ© Ă  la broche GND Ă  la mise sous tension pour mettre l’ESP en bootload mode. Ce mode permet de rĂ©-installer le firmware d’origine ou charger un programme Arduino. Sur certaines cartes, WeMos d1 mini par exemple, cette opĂ©ration est prise en charge par le gestionnaire de carte. Cette opĂ©ration est donc inutile, le tĂ©lĂ©versement est transparent.

GĂ©nĂ©ralement, les fabricants publient un schĂ©ma des broches (pinout) qui indique la broche Ă©quivalente sur un Arduino Uno. Ici, par exemple, les broches d’une WeMos d1 mini. Ce schĂ©ma de branchement est valable pour toutes les cartes Ă  base de module ESP-12x.

Correspondance Pins GPIO WeMos D1 mini

Si vous voulez vous lancer dans la programmation en Lua, le numéro de broche à utiliser dans le code est également indiqué.

Attention au GPIO qui fonctionne Ă  une tension de 3.3V

ParticularitĂ© de l’ESP8266 par rapport Ă  l’Arduino Uno (ce n’est plus le cas pour le Genuino 101 et les nouvelles cartes Ă  base d’Intel Curie), le GPIO fonctionne sous une tension de 3,3V. Il faudra donc dans certain cas adapter vos montages. Pour cela, il existe des diviseurs de tension (5V vers 3.3V) ou l’inverse (3.3V vers 5V).

Comment programmer l’ESP8266 avec l’IDE Arduino ?

Matériel et circuit de test

Voici un petit montage à réaliser avec un ESP8266 (ici une WeMos d1 mini) et une Led qui vous permettra de tester les différents codes proposés dans ce tutoriel.

Pour mĂ©moire, voici un tableau rĂ©capitulatif de la tension d’alimentation typique en fonction de la couleur et du diamĂštre de la Led.

Couleur Longueur d’onde (nm) Tension (V) pour diamĂštre  3mm Tension(V) pour diamĂštre  5mm
Rouge 625-630  1,9-2,1 2,1-2,2
Bleu 460-470 3,0-3,2 3,2-3,4
Vert 520-525 2,0-2,2 2,0-2,2
Jaune 585-595 2,0-2,2 3,0-3,2
Blanc  460-470 3,0-3,2 1,9-2,1

La programmation classique

La premiĂšre chose Ă  savoir lorsqu’on dĂ©bute avec un module ESP8266, c’est qu’on peut le programmer exactement comme un Arduino. Contrairement aux micro-contrĂŽleurs ATTiny, moins puissants, le SoC de l’ESP8266 est capable d’exĂ©cuter toutes les commandes C++ du code Arduino. La seule condition Ă  respecter est d’utiliser la librairie adaptĂ©e pour ce dernier dĂšs qu’on veut utiliser le WiFi (paragraphe suivant).

Ouvrez l’IDE Arduino et collez ce code dans un nouveau projet avant de le tĂ©lĂ©verser.

Que fait ce programme ?

  • Une variable de type entier (int) permet d’indiquer sur quelle sortie la Led est branchĂ©e
  • Dans la boucle setup(), on indique que la broche (ici 16) est une sortie (OUTPUT)
  • La boucle loop() s’execute Ă  l’infini. A chaque passage
    • On met la sortie (16) au niveau bas (LOW), c’est Ă  dire que la tension de sortie est nulle (pas de courant)
    • On attend 1 seconde. Le dĂ©lais (Delay) est indiquĂ© en millisecondes (1000ms = 1s)
    • On met la sortie (16) au niveau haut (HIGH), c’est Ă  dire que la tension de sortie est de 5V (le courant passe)
    • On attend 2 secondes
    • Et ainsi de suite
int led = 16;

void setup() {
  pinMode(led, OUTPUT);     // Initialise la broche "led" comme une sortie - Initialize the "LED" pin as an output
}

// Cette boucle s'exécute à l'infini
// the loop function runs over and over again forever
void loop() {
  digitalWrite(led, LOW);   // Eteint la Led - Turn the LED OFF 
  delay(1000);              // Attendre 1 seconde - Wait for a second
  digitalWrite(led, HIGH);  // Allume la Led - Turn the LED off by making the voltage HIGH
  delay(2000);              // Pause de 2 secondes - Wait 2 secondes
}

Maintenant, remplacez dans la sortie 16 par le repĂ©rage Ă©quivalent de l’ESP8266, Ă  savoir D0, ce qui donne 

int led = D0;

Comme vous pouvez le constater, le programme fonctionne Ă  l’identique.

Remarque. MĂȘme si la variable est de type int (integer), on Ă©crit une chaine de caractĂšre dans le code. C’est normal. Au moment de la compilation, la rĂ©fĂ©rence Ă  la broche sera remplacĂ©e dans le code par la librairie ESP8266.

Programmation Web Serveur : connecter l’ESP8266 au rĂ©seau WiFi

La programmation Web Serveur permet d’ajouter une interface Web (Ă©crite dans le langage HTML et javascript) Ă  un projet ESP8266. C’est Ă©galement possible avec un Arduino mais cela prend tout son sens avec un ESP8266 qui nativement dispose d’une connexion WiFi.

Reprenons le code précédent et ajoutons les deux librairies nécessaires

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>

On va créer deux variables pour définir le SSID (identifiant du réseau WiFi) et le mot de passe avant de créer un objet qui va contenir le serveur Web (objet C++)

const char* ssid = "xxxx";           // Identifiant WiFi
const char* password = "xxxxxxxxx";  // Mot de passe WiFi
ESP8266WebServer server(80);         // On instancie un serveur qui ecoute sur le port 80

Le code de la fonction setup fait les opérations suivantes

  • Serial.begin(115200)
      on ouvre le port série à 115200 bauds
  • WiFi.begin(ssid, password)
      l’ESP8266 se connecte au rĂ©seau WiFi
  • La boucle while Ă©crit un point sur le port sĂ©rie toute les 500ms jusqu’Ă  ce que l’ESP8266 soit connectĂ© au WiFi
    WiFi.status() != WL_CONNECTED
     (trĂšs mauvaise idĂ©e lorsqu’on fonctionne sur batterie d’ailleurs, mais c’est juste pour comprendre le fonctionnement)
  • Serial.println(WiFi.localIP())
     écrit sur le port sĂ©rie l’adresse IP attribuĂ©e par la box internet ou le routeur Ă  l’ESP8266
  • server.on("/", [](){
      server.send(200, "text/plain", "Page d'accueil");   // Ajoute un point d'entree, une page web 
    });
    On ajoute un point d’entrĂ©e, c’est Ă  dire une adresse internet (URL) sur laquelle on affichera pour le moment un simple texte
  • server.on("/parametres", [](){
      server.send(200, "text/plain", "Une page de parametres");
    });
    Une seconde page qui pourrait ĂȘtre une page de paramĂštres
  • server.begin()
     enfin, on démarre le serveur web

Il ne reste plus qu’Ă  demander Ă  l’ESP8266 d’Ă©couter les demandes et d’afficher les pages correspondantes. Pour cela on ajoute la commande 

server.handleClient()
 dans la fonction loop().

Collez le code complet dans un nouveau projet et téléversez le sur la WeMos.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
const char* ssid = "XXXX";           // Identifiant WiFi
const char* password = "XXXXXXXXX";  // Mot de passe WiFi
ESP8266WebServer server(80);         // On instancie un serveur qui ecoute sur le port 80

int led = D0;

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  Serial.println("");
  // on attend d'etre connecte au WiFi avant de continuer
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  // on affiche l'adresse IP attribuee pour le serveur DSN
  Serial.println("");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  
  // on definit les points d'entree (les URL a saisir dans le navigateur web) et on affiche un simple texte 
  server.on("/", [](){
    server.send(200, "text/plain", "Page d'accueil");
  });
  server.on("/parametres", [](){
    server.send(200, "text/plain", "Une page de parametres");
  });
  // on demarre le serveur web 
  server.begin();
  pinMode(led, OUTPUT);     // Initialise la broche "led" comme une sortie - Initialize the "LED" pin as an output
}

// Cette boucle s'exécute à l'infini - the loop function runs over and over again forever
void loop() {
  // a chaque iteration, la fonction handleClient traite les requetes 
  server.handleClient();
  
  digitalWrite(led, LOW);   // Eteint la Led - Turn the LED OFF 
  delay(1000);              // Attendre 1 seconde - Wait for a second
  digitalWrite(led, HIGH);  // Allume la Led - Turn the LED off by making the voltage HIGH
  delay(1000);              // Pause de 2 secondes - Wait 2 secondes
}

Ouvrez le moniteur sĂ©rie pour rĂ©cupĂ©rer l’adresse IP de l’ESP8266 sur le rĂ©seau local.

Ouvrez maintenant un navigateur internet er saisissez l’adresse IP ou IP_ESP8266/parametres.

Et voilĂ , en quelques lignes de code, vous venez de connecter l’ESP8266 au rĂ©seau local (et internet par la mĂȘme occasion). Vous pouvez accĂ©der Ă  une interface WEB depuis n’importe quel ordinateur ou smartphone. En faisant une redirection de port sur votre box internet ou routeur, vous pouvez mĂȘme accĂ©der Ă  l’interface hors de chez vous avec une connexion 3G/4G.

Attention. La connexion n’est pas chiffrĂ©e. Elle n’est pas protĂ©gĂ©e. Tout le monde peut avoir accĂšs aux commandes de votre interface. Il faudra ajouter des protections (mot de passe…)

Programmation Web Serveur : piloter le GPIO depuis internet !

Nous allons maintenant voir comment ajouter des commandes pour piloter le GPIO depuis une interface. Il existe plusieurs mĂ©thodes pour gĂ©nĂ©rer le code HTML de l’interface qui sera envoyĂ©e au navigateur internet. Ici, on va simplement crĂ©er une chaine (String) qui va contenir le code HTML. Tout est expliquĂ© en dĂ©tail dans ce tutoriel. Chaque ligne est expliquĂ©e dans le code. Ce qu’il faut retenir :

  • Le code HTML est construit en assemblant des chaines de caractĂšres
  • Il est possible d’intĂ©grer le contenu de variable. Ici l’Ă©tat de la sortie D0contenu dans la chaine etatD0.
  • Chaque changement d’Ă©tat est envoyĂ© au serveur web qui tourne sur l’ESP8266 Ă  l’aide d’un formulaire sous la forme d’une requĂȘte HTTP de type POST.
  • Ici, l’actualisation est dĂ©clenchĂ©e manuellement en appuyant sur un bouton (submit)
String getPage(){
  String page = "<html lang=fr-FR><head><meta http-equiv='refresh' content='10'/>";
  page += "<title>ESP8266 Web Server Demo - www.projetsdiy.fr</title>";
  page += "<style> body { background-color: #fffff; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }</style>";
  page += "</head><body><h1>ESP8266 Web Server Demo</h1>";
  page += "<h3>GPIO</h3>";
  page += "<form action='/' method='POST'>";
  page += "<ul><li>D0 (etat: ";
  page += etatD0;
  page += ") ";
  page += "<INPUT type='radio' name='D0' value='1'>ON";
  page += "<INPUT type='radio' name='D0' value='0'>OFF</li></ul>";
  page += "<INPUT type='submit' value='Actualiser'>";
  page += "<br><br><p><a hrf='https://www.projetsdiy.fr'>www.projetsdiy.fr</p>";
  page += "</body></html>";
  return page;
}

Maintenant, on modifie dans le setup le point d’entrĂ©e vers la page d’accueil. On branche le point d’entrĂ©e “/” vers la fonction handleRoot.

server.on ( "/", handleRoot );

Lorsqu’on affiche la page principale (“/”) ou que le serveur web reçoit une requĂȘte POST (actualisation du GPIO), la fonction handleRoot est appelĂ©e. La fonction server.hasArg permet brancher des actions. Ici, si la requĂȘte contient l’argument (hasArg), alors c’est qu’on doit changer l’Ă©tat du GPIO. On exĂ©cute la fonction handleSubmit, sinon on actualise la page.

void handleRoot(){ 
  if ( server.hasArg("D0") ) {
    handleSubmit();
  } else {
    server.send ( 200, "text/html", getPage() );
  }  
}

La fonction handleSubmit rĂ©cupĂšre la valeur de l’argument “D0” avec la fonction server.arg puis il suffit de tester la valeur de celle-ci pour rĂ©aliser le bon traitement. Attention, c’est une chaine de caractĂšre. Il faut donc tester comme ceci == “1” et non pas == 1. On en profite pour stocker l’Ă©tat de la sortie dans la variable etatD0.

void handleSubmit() {
  // Actualise le GPIO / Update GPIO 
  String LEDValue;
  LEDValue = server.arg("D0");
  Serial.print("Set GPIO to "); Serial.println(LEDValue);
  if ( LEDValue == "1" ) {
    digitalWrite(D0, 1);
    etatD0 = "On";
    server.send ( 200, "text/html", getPage() );
  } else if ( LEDValue == "0" ) {
    digitalWrite(D0, 0);
    etatD0 = "Off";
    server.send ( 200, "text/html", getPage() );
  } else {
    Serial.println("Err Led Value");
  }
}

Collez le code complet suivant en modifiant identifiant et mot de passe WiFi.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
const char* ssid = "XXXX";          // Identifiant WiFi
const char* password = "XXXXXXXX";  // Mot de passe WiFi
ESP8266WebServer server(80);        // On instancie un serveur qui ecoute sur le port 80

int led = D0;
String  etatD0 = "Off";

String getPage(){
  String page = "<html lang=fr-FR><head><meta http-equiv='refresh' content='10'/>";   // C'est du code HTML, la page s'auto-actualise    
  page += "<title>ESP8266 Web Server Demo - www.projetsdiy.fr</title>";               // Titre de la barre du navigateur
  page += "<style> body { background-color: #fffff; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }</style>"; // style de la page
  page += "</head><body><h1>ESP8266 Web Server Demo</h1>";  // Titre de la page (H1)
  page += "<h3>GPIO</h3>";                                  // Sous-titre (H3)
  page += "<form action='/' method='POST'>";                // Le formulaire sera envoye avec une requete de type POST 
  page += "<ul><li>D0 (etat: ";                             // Premiere ligne de la liste (ul) avec D0
  page += etatD0;                                           // on concatene la chaine contenant l'etat de la sortie
  page += ") ";
  page += "<INPUT type='radio' name='D0' value='1'>ON";     // Bouton pour activer D0
  page += "<INPUT type='radio' name='D0' value='0'>OFF</li></ul>"; // et le desactiver
  page += "<INPUT type='submit' value='Actualiser'>";       // Bouton d'actualisation
  page += "<br><br><p><a hrf='https://www.projetsdiy.fr'>www.projetsdiy.fr</p>";
  page += "</body></html>";
  return page;
}
void handleRoot(){ 
  if ( server.hasArg("D0") ) {
    handleSubmit();
  } else {
    server.send ( 200, "text/html", getPage() );
  }  
}

void handleSubmit() {
  // Actualise le GPIO / Update GPIO 
  String LEDValue;
  LEDValue = server.arg("D0");
  Serial.print("Set GPIO to "); Serial.println(LEDValue);
  if ( LEDValue == "1" ) {
    digitalWrite(D0, 1);
    etatD0 = "On";
    server.send ( 200, "text/html", getPage() );
  } else if ( LEDValue == "0" ) {
    digitalWrite(D0, 0);
    etatD0 = "Off";
    server.send ( 200, "text/html", getPage() );
  } else {
    Serial.println("Err Led Value");
  }
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  Serial.println("");
  // on attend d'etre connecte au WiFi avant de continuer
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  // on affiche l'adresse IP qui nous a ete attribuee
  Serial.println("");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());

  // on definit les points d'entree (les URL a saisir dans le navigateur web) et on affiche un simple texte
  server.on ( "/", handleRoot );

  // on demarre le serveur web
  server.begin();
  pinMode(led, OUTPUT);     // Initialise la broche "led" comme une sortie - Initialize the "LED" pin as an output
}

// Cette boucle s'exécute à l'infini - the loop function runs over and over again forever
void loop() {
    // a chaque iteration, on appelle handleClient pour que les requetes soient traitees
  server.handleClient();
}

Voici l’interface obtenue

Maintenant que c’est plus clair, vous pouvez aller encore un peu plus loin dans les dĂ©tails de la programmation Web Serveur de l’ESP8266 en lisant cet article. Vous pourrez rĂ©aliser ce type d’interface en suivant ce projet de station mĂ©tĂ©o en 5 Ă©tapes.

esp8266 web server spiffs bootstrap dht22 bmp180 google charts

Tous les tutoriels sur la programmation Web Server des ESP8266

Serveur Web (Interface)

Programmation Client Web :

La programmation Client Web permet de faire communiquer un module ESP8266 avec un autre serveur, un autre ESP8266, une application mobile… Voici quelques exemples d’application :

  • Transmettre des mesures (tempĂ©rature, humiditĂ©, taux de particules, pression atmosphĂ©rique, luminositĂ©, bruit…)
  • Transmettre des Ă©tats (dĂ©tecteur d’ouverture de porte ou fenĂȘtre, contacteur…)

Voici plusieurs articles sur le sujet avec des exemples d’application pour faire communiquer l’ESP8266 avec Jeedom ou Domoticz (affichage dĂ©portĂ©)

Client Web (communication)

Questions courantes (FAQ)

Sur quelles plateformes l’IDE Arduino est-il disponible ?

L’IDE Arduino est disponible sur tous les systĂšmes d’exploitation (Windows, macOS, Linux, Linux ARM). Quelque soit votre environnement, vous pouvez donc dĂ©velopper vos projets ESP8266 avec l’IDE Arduino. Allez sur le site de la fonction Arduino pour rĂ©cupĂ©rer l’installeur qui convient Ă  votre ordinateur ou mini-PC.

Peut-on programmer un ESP8266 sur un Mac ?

Oui, l’IDE Arduino est disponible sur macOS Ă©galement. Le kit de dĂ©veloppement (SDK) d’Espressif Ă©tant Ă©crit en python, il est possible de programmer les modules ESP8266 comme sur un PC Windows.

Peut-on programmer l’ESP8266 depuis Linux ARM ?

Oui, si vous possĂ©dez un Raspberry Pi ou un mini-PC Ă©quivalent fonctionnant sous Linux ARM (un Orange Pi par exemple), il est tout Ă  fait possible d’utiliser l’IDE Arduino.

Comment développer sans programmation avec le Firmware ESP Easy

Si vous dĂ©butez avec les micro-contrĂŽleurs et que tout ce que vous avez lu prĂ©cĂ©demment vous a un peu effrayĂ©, pas de problĂšme. Le projet ESP Easy est fait pour vous ! ESP Easy est une interface qui permet de dĂ©velopper des sondes ou des actionneurs par simple configuration. L’interface est en anglais mais tout est expliquĂ© dans ces tutoriels en français.

Quel modĂšle d’ESP8266 choisir  pour dĂ©buter ?

Les cartes de dĂ©veloppement Ă  base d’ESP-12x (WeMos d1 Mini, Geekcreit…) sont les mieux pour dĂ©buter. Le tĂ©lĂ©versement est gĂ©rĂ© de façon totalement transparente par le SDK ESP8266 depuis l’IDE Arduino. Vous pouvez utiliser le comparateur de prix pour trouver la meilleure offre sur Internet.

Peut-on utiliser des cartes NodeMCU ou micropython ?

Oui absolument. Ce sont d’autres firmwares. NodeMCU permet d’exĂ©cuter du code Lua. DĂšs le premier tĂ©lĂ©versement, le firmware sera remplacĂ© par le code Arduino. Vous pourrez rĂ©-installer le firmware NodeMCU (suivez ce tutoriel pour cela) ou micropython ultĂ©rieurement.

C’est quoi le modĂšle ESP-WROOM-32 ?

LoLin32 Lite de Wemos.cc

Le module ESP-WROOM-32 est le nom de code du successeur de l’ESP8266, l’ESP32. Il est plus puissant, moins gourmand, plus sĂ©curisĂ©, plus pro (bus CAN), il apporte Ă©galement le support du Bluetooth en plus du WiFi. Le prix des cartes de dĂ©veloppement ESP32 Ă  fortement chutĂ© ces derniers mois. Elles sont maintenant quasiment au mĂȘme prix. Pour en savoir plus, rendez-vous sur la catĂ©gorie ESP32 de Projets DIY. Ici, la Lolin32 Lite de Wemos.cc

Quelques livres pour débuter en C/C++

La programmation Arduino fait appel Ă  des notions de programmation objet du C/C++. Il existe de trĂšs bons livres d’initiation ainsi que des tutoriels sur le Web pour aller plus loin que les notions abordĂ©es ici

Cet article Programmer l’ESP8266 avec l’IDE Arduino : librairies, GPIO, Web Serveur, Client Web est apparu en premier sur Projets DIY - Domotique et objets connectĂ©s Ă  faire soi-mĂȘme.

WallpaperDownloader: Automate Your Wallpaper Management in Linux

Par Aquil Roshan

One of the main reasons why I use Linux on my computers is customizability. And I’m sure I’m not the only one. Having an imagination for your desktop and realizing it, well, I’m pretty sure no other OS will beat Linux here. On other operating systems too, there are tools which are capable of altering the desktop to some extent, but they are nothing compared to Linux tools.

To begin with, there is a wide variety of desktop environments you can use on your Linux desktop. And if you are not completely satisfied with any of them, you can go ahead and use extensions for fine-tuning. And how can we forget about wallpapers when we are talking desktop customization?

WallpaperDownloader

WallpaperDownloader is a nifty application by Eloy García Almadén which has got you covered as far as wallpapers are concerned. WallpaperDownloader is a Java-based application which not only downloads wallpapers but is also a full-fledged wallpaper manager.

It is simple to use. It has got every functionality of a wallpaper manager. Right from downloading, storing, changing to space management. It works on Mate, GNOME Shell, Unity, XFCE and KDE Plasma (5.0 and above).

Basically, all you have to do is fill in your screen resolution, select the wallpaper providers and enter the keywords for wallpapers and rest is taken care of by WallpaperDownloader. Images are downloaded and changed automatically at your specified time interval.

WallpaperDownloader Menu

You can also customize the time interval for the wallpapers to change.

WallpaperDownloader Menu

I input “Game of Thrones” as keywords and it was definitely impressive. BTW did you check out the Game of Thrones parody by SUSE Linux? A major Linux distro got dissed. So check it out. It’s war.

WallpaperDownloader in action

Nuff said. The installation instructions of WallpaperDownloader for different distros are given below.

Arch Linux/ Manjaro/ Antergos:

Run the below command in the terminal

yaourt wallpaperdownloader

Ubuntu/ Linux Mint/ Elementary OS and other derivatives:

Run the below commands in the terminal

sudo add-apt-repository ppa:eloy-garcia-pca/wallpaperdownloader
sudo apt-get update
sudo apt install wallpaperdownloader

Launch WallpaperDownloader from the Dash or the menu. And put in the parameters. Just be sure not to close the application but click on the  ‘minimize’ button. That’s it. Give it a minute or two to see the changes.

Wrapping up

WallpaperDownloader is the best wallpaper tool for Linux. And it is a must-have in your arsenal if you’re serious about desktop appearance customization. Do give it a try. Use the comments below and let us know what applications and extensions you use to make your desktop more aesthetic. We’d love to hear. Don’t forget to share this article. Cheers.

À partir d’avant-hierTechnos / IT

Paths to autonomous workload management at the edge

Par Gregory Katsaros

It’s been estimated that in the next three to five years years the number of connected devices will reach a staggering 50 billion globally.

Even if that number sounds extreme, it’s undeniable that advancements in silicon technology (e.g. shrinking of computing and sensor components) and the evolution of 5G networks will definitely drive the rise of capable edge devices and create much more relevant use cases.

Given that scenario, when it comes to the technology to support it, several associated challenges need to be  identified and addressed first.

The recent OpenDev conference aimed to raise the awareness and foster collaboration in this domain. The topic of autonomous workload management at the edge was one of the working sessions at the conference. It focused on technical constraints, requirements and operational considerations when an application/workload has to be orchestrated at the edge. The main assumption is that several edge computing use cases (e.g. micro-edge/mobile edge such as set-top boxes, terminals etc.) will demand highly autonomous behavior due to connectivity constraints, latency, cost etc. The scale of edge infrastructure might also drive this autonomous behavior of the edge platform while the central management of all these edge devices will be an enormous task. To this end, several operational considerations were discussed as summarized below.

Workload orchestration

When it comes to autonomous workload management at the edge, effective orchestration is the most important issue. No matter if it is on bare metal, virtual machines or application containers, the need for automation and use of software-defined methodologies is apparent. In the NFVi world nowadays there’s a clear tendency towards model-driven declarative approaches such as TOSCA for addressing orchestration. The expectation is that the edge platform should include a functional component responsible not only for the orchestration and management of resources (e.g. VMs or container) but also the running applications or VNFs. Such an entity takes care of runtime healing and scaling as well as provisioning (edge-side or centrally triggered). Even if the goal is the autonomous operation of the workload orchestration, it’s expected that there will be some kind of central orchestration entity (or regional manager) that will still keep a reference of the edge state or drive provisioning of the edge. It feels like the absolute autonomous behavior of a mesh-like edge network is a bit futuristic and difficult to have in the short term, at least at large scale.

State and policy management

Autonomous workload orchestration also implies autonomous state management. In order to effectively orchestrate the state not only of the hosting platform (e.g. the virtual machine or container) has to be captured but also the services or application state should be monitored. Today, most of state management operations are handled by orchestration components (at the resources level) and the applications/VNF vendors themselves. However, there is no combined view of the state which results in pretty primitive fault handling: when the state of a workload is faulty, then the whole resource is restarted. In addition, the Service Function Chaining (SFC) or the applications’ micro-services paradigm introduce a composable state concept which potentially has to be considered. State abstraction is also important: a regional orchestrator might not need to keep the state of all components of an SFC but just an abstracted state of the whole SFC. On the other hand, the edge orchestrator must know the state of each service in the chain. The policy enforcement should also follow the same pattern with the state propagation. All-in-all, the above-mentioned points suggest the need for a more capable state management structure that can tackle these new requirements. Whether the existing orchestrators are responsible for these features or new modules and/or protocols have to be invented is up for discussion.

Managing packages of local repositories

Autonomous operation of the workload orchestration at the edge requires local repositories of images and software packages. Assuming that the connection of the edge device to the core network is either unreliable or very thin, only the control plane operations should be transferred over the air. It’s being suggested that the orchestration systems should explore cached or local repositories that would be synchronized on-demand by some central component. Multicast features for pushing updates to the edge repositories should be considered too, especially if the scale of edge devices increases exponentially.
Even if most of the issues and ideas discussed here are nor new neither unique, we can’t assume that the technologies and systems developed for data center operations can directly solve edge computing use cases. Perhaps it’s best to look at the problem with a fresh perspective and try to architect an edge computing platform that could serve all use cases (from micro to large edge), leveraging existing technology where and when possible but also investing in new.

About the author

Gregory Katsaros is a services, platforms and cloud computing expert who has been working for several years in research and development activities and projects related to the adoption of such technologies and transformation of the industry. Katsaros has special interest in services and resources orchestration as well as network function virtualization and software defined networking technologies.

He holds a Ph.D. from the National Technical University of Athens on “Resource monitoring and management in Service Oriented Infrastructures and Cloud Computing” and has been contributing to research communities with research and code.

In the last few years, he’s  been leading projects related to services and cloud computing, distributed systems, interoperability, orchestration, SDN, NFV transformation and more. He’s interested in transforming the telco and enterprise sector by embracing automation and orchestration technologies, as well as investigating edge computing.

Cover Photo // CC BY NC

The post Paths to autonomous workload management at the edge appeared first on OpenStack Superuser.

❌