Syndiquer le contenu
Mis à jour : il y a 23 heures 57 min

Les logiciels libres de caisse de mieux en mieux pris en compte par Bercy

13 décembre, 2018 - 09:29

Depuis le 1er janvier 2018, toute personne utilisant un logiciel ou système de caisse doit détenir un document attestant de la conformité de son outil à la réglementation visant à lutter contre la fraude à la TVA. Un dispositif inscrit à l’article 286 3o bis du code général des impôts et initialement issu de la loi de finances pour 2016, date à laquelle l’April s’est engagée pour la promotion et la défense des logiciels libres ayant des fonctions d’encaissement.

Sommaire

Le 1er janvier 2019 marquera la fin d’une année dite de « tolérance » des services fiscaux. Bien qu’il demeure des pistes d’amélioration importantes, l’April est rassurée par rapport à la première version du texte. Particulièrement suite à la mise à jour du BOFIP (Bulletin officiel des finances publiques — Impôts) en juillet 2018 à laquelle l’association a participé, d’abord en rencontrant les personnes en charge du dossier au sein du ministère, puis en répondant à un appel à commentaires sur la version « projet » du document. Dans les grandes lignes, il ressort de cette mise à jour une bien meilleure sécurité juridique ; meilleure définition et champ d’application plus précis notamment. Pas de grand changement en ce qui concerne le logiciel libre. Des rigidités demeurent, comme pour l’auto‐attestation, mais la dynamique est positive et encourageante.

Chronologie du dossier
  • La loi de finances pour 2016 a créé une nouvelle réglementation des logiciels de caisse dans l’objectif de lutter contre la fraude à la TVA. Dispositif inscrit au 3ᵒ bis du I de l’article 286 du code général des impôts (CGI) et entré en vigueur au 1er janvier 2018. Appliquée telle quelle, la nouvelle réglementation aurait interdit de fait l’utilisation de logiciels libres de caisse en rendant théoriquement illicite toute modification par les utilisateurs.
  • En août 2016, une première publication au BOFIP, le BOI-TVA-DECLA-30-10-30 (ancienne version), est venue préciser le périmètre de la réglementation. Ce document est doublement important : d’une part, il a force de loi, il est opposable à l’administration, et, d’autre part, il reconnaît explicitement la possibilité d’utiliser des logiciels libres de caisse. Un document que l’April avait commenté, soulignant les avancées du texte ainsi que les améliorations attendues.
  • En juin 2017, le gouvernement répond dans un communiqué de presse à l’expression d’une inquiétude grandissante quant au périmètre exact du dispositif. Le document confirme l’exclusion des logiciels de comptabilité et annonce une année de tolérance administrative jusqu’au 1er janvier 2019. L’annonce est traduite en norme dans la loi de finances pour 2018 (article 105).
  • Les services de Bercy en charge du dossier font un appel à commentaires sur leur projet de mise à jour du BOFIP fin 2017, auquel l’April contribue. Le 4 juillet 2018 la nouvelle version du BOFIP est mise en ligne. Plus précisément, il s’agit d’une mise à jour du BOI-TVA-DECLA-30-10-30, colonne vertébrale du dispositif, et du BOI-CF-COM-20-60-20 qui précise les modalités du contrôle des logiciels de caisse par les services fiscaux.

Indéniablement, la mise à jour du BOFIP confirme une dynamique de sécurisation juridique précisant davantage le champ d’application, clarifiant et améliorant les définitions, recadrant ce qui relève des responsabilités de chacun. Plus spécifiquement, en ce qui concerne les logiciels libres, on sent une réelle volonté d’avoir un texte proportionné qui ne restreigne les libertés informatiques qu’à hauteur, selon ses rédacteurs, de ce qui est nécessaire à l’objet du texte, c’est‐à‐dire la lutte contre la fraude à la TVA. Pour autant, le paradigme de l’informatique privatrice pensée en silo reste présent et impose ses contraintes. Il reste une marge de progression encore importante pour les logiciels libres. Le cas de l’auto‐attestation en est l’exemple éloquent.

Résumé des principales questions et problématiques Qui est concerné ? Quels logiciels ?

Le site des services fiscaux propose un outil très simple destiné à savoir si l’on est ou non concerné par le dispositif.

Toute personne assujettie à la taxe sur la valeur ajoutée (TVA) qui enregistre les règlements de ses clients au moyen d’un logiciel ou d’un système de caisse. C’est la fonctionnalité d’encaissement qui importe, plus précisément « l’enregistrement extra‐comptable des paiements reçus ». Ne sont donc pas concernés les logiciels ou systèmes qui déclenchent « obligatoirement, instantanément et automatiquement, sans intervention humaine, une écriture dans le système d’information comptable ». Le moyen de paiement ou le fait que le système soit hébergé localement ou en ligne n’a d’ailleurs aucune incidence sur l’application ou non du dispositif.
Paragraphes de référence : Qui ? ; § 1 et 10, Quels logiciels ? ; § 30, 35 et 40 BOI-TVA-DECLA-30-10-30 (BOI-TVA ci‐après).

§ 30 BOI-TVA :

« Un logiciel ou système de caisse est un système informatique doté d’une fonctionnalité de caisse, laquelle consiste à mémoriser et à enregistrer extra‐comptablement des paiements reçus en contrepartie d’une vente de marchandises ou de prestations de services c’est‐à‐dire que le paiement enregistré ne génère pas concomitamment, automatiquement et obligatoirement la passation d’une écriture comptable. […] Seule cette fonctionnalité de caisse, et non les autres fonctions telles que celles relatives à la pesée, doivent être certifiées [ou attestées, N. D. R]. […] »

§40 BOI-TVA :

« Un logiciel, quelle que soit sa qualification (de caisse, comptable ou de gestion), qui dispose d’une fonctionnalité de caisse doit satisfaire aux conditions d’inaltérabilité, de sécurisation, de conservation et d’archivage des données en vue du contrôle de l’administration fiscale. »

Quelles sont les obligations ?
  • Pour les personnes utilisatrices : en cas de contrôle, elles devront fournir (ou « produire ») une certification ou une attestation individuelle remise par l’éditeur établissant que les fonctions d’encaissement du logiciel ou système satisfont les « conditions d’inaltérabilité, de sécurisation, de conservation et d’archivage des données en vue du contrôle de l’administration fiscale » (les « quatre conditions »). Elles doivent donc avoir un document à jour correspondant à la version du logiciel ou système qu’elles utilisent. Paragraphes de référence : § 270 à 290 BOI-TVA
  • Pour les intégrateurs (compris dans la qualification d’éditeurs du dispositif)1 : faire certifier leur logiciel ou système de caisse, ou attester que celui‐ci satisfait les quatre conditions. La mise à jour du BOFIP vient préciser ce qui est attendu en termes de respect de celles‐ci, donc le niveau de responsabilité attaché aux éditeurs, confirmant ainsi qu’il ne s’agit pas d’exiger une inaltérabilité absolue, par exemple, mais davantage d’empêcher la dissimulation des données originales. Paragraphes de référence sur la notion d’éditeur : § 300, 310 et 315 BOI-TVA.
  • La mise à jour du BOFIP marque une importante avancée sur la question des obligations, en distinguant plus clairement ce qui est attendu des intégrateurs et des utilisateurs et en abaissant l’intensité des obligations. Il semblerait en ce sens que l’on soit passé d’une apparente obligation stricte de résultat vers ce qui s’assimilerait davantage à une obligation de moyens renforcée. Paragraphes de référence : sur l’inaltérabilité § 80 à 120, sur la sécurisation § 130 à 150 BOI-TVA.
Est‐il possible d’utiliser des logiciels libres ?

Oui. Le texte définit le logiciel libre en rappelant les quatre libertés et intègre dans la dynamique du dispositif la liberté pour l’utilisateur de modifier son logiciel, dans le respect des quatre conditions. C’était la principale avancée de la première version du BOFIP, traduite dans la manière dont est définie la notion d’éditeur. Ainsi, le « dernier intervenant ayant paramétré le logiciel ou système lorsque son intervention a eu pour objet ou effet de modifier un ou des paramètres permettant le respect des conditions d’inaltérabilité, de sécurisation, de conservation et d’archivage des données », sera éditeur. Dit autrement, l’utilisateur est libre de modifier son logiciel. Et s’il fait une modification qui concerne une ou plusieurs des quatre conditions, une modification « majeure », c’est lui qui sera considéré comme l’éditeur du logiciel et il sera donc responsable des obligations qui s’y attachent. Une précision indispensable pour éviter qu’un éditeur de logiciel libre soit indéfiniment responsable des éventuels comportements délictueux de son client.
Paragraphes de référence : § 40, pour la définition de logiciel libre, §300, 310 et § 315, sur l’aménagement de la notion d’éditeur.

Parallèlement, la liberté pour l’utilisateur d’effectuer des modifications « mineures » est explicitée. Ces modifications ne concernant pas les fonctionnalités d’encaissement sont possibles sans entacher la validité de l’attestation ou de la certification. Le BOFIP précise que l’attestation doit clairement identifier « la racine de la dernière version majeure ». (§ 380 BOI-TVA)

§ 40 BOI-TVA :

 « Un logiciel libre est un logiciel dont les utilisateurs ont un libre usage, une libre étude, une libre modification et une libre distribution. Un logiciel propriétaire, au contraire, ne permet ni légalement ni techniquement d’exercer ces quatre libertés, qui permettent aux utilisateurs d’adapter le logiciel à leurs besoins spécifiques. »

À propos de l’attestation individuelle :

Une attestation est « individuelle ». Elle se fait donc au cas par cas, pour chaque client, sur la base du modèle BOI-LETTRE-000242. À l’inverse, un certificat délivré par une autorité agréée a une portée générale. Ces documents concernent une version « majeure » d’un logiciel ou système, ou plus précisément de ses fonctionnalités d’encaissement.
Paragraphes de référence : § 360 à 390 du BOI-TVA.

Qui peut attester ?

N’importe qui peut attester « pour autrui ». Cela signifie que l’éditeur qui atteste verra sa responsabilité engagée si le logiciel est contrôlé et ne satisfait pas les « quatre conditions ». Cependant, si l’utilisateur a effectué une modification « majeure », il est alors considéré comme éditeur de la version utilisée, rompant donc le lien de responsabilité. L’ajout d’une mention au § 300 BOI-TVA explicite clairement ce point ; « une attestation délivrée par un éditeur engage sa responsabilité sous réserve que les dispositifs techniques garantissant sécurisation, inaltérabilité, conservation et archivage ne sont pas modifiés par un tiers. »

Est‐il possible d’attester pour soi‐même ?

Oui. Suite à sa mise à jour, le BOFIP assouplit un peu cette possibilité en ne la conditionnant plus exclusivement à la détention d’un code NACE (Nomenclature des Activités économiques dans la Communauté Européenne). Il ne s’agit plus que d’un moyen de preuve pour démontrer une « activité réelle et corroborée » d’édition de logiciel. C’est un progrès certain, mais il nous semble possible d’aller beaucoup plus loin sans affaiblir le dispositif. Nous estimons notamment qu’une activité matériellement démontrable d’édition du logiciel (contributions à une forge logicielle basée sur Git, par exemple) pourrait être un élément de preuve proportionné.
Paragraphe de référence : § 375 BOI-TVA.

Que se passe‐t‐il en cas de mise à jour « majeure » invalidant l’attestation émise ?

Précision importante apportée par cette mise à jour du BOFIP et issue d’une des propositions de l’April : c’est à l’utilisateur qu’incombe d’avoir un logiciel et une attestation à jour. Si ce genre de situation sera aisément précisé — dans des contrats de prestation, par exemple — il s’agit d’une clarification importante qui évite à un éditeur qui maintient à jour son logiciel pour qu’il satisfasse les quatre conditions, d’être responsable si un utilisateur ne maintient pas son système à jour ou s’il ne renouvelle pas son attestation, potentiellement devenue caduque s’il mettait à jour son logiciel vers une nouvelle version majeure.
Paragraphe de référence : § 290 BOI-TVA.

Précisons également que la mise à jour du BOFIP a été l’occasion de combler un manque important : l’obligation de recourir à des formats ouverts pour enregistrer des données d’archivage (§ 230 BOI-TVA). La question des formats ouverts est fondamentale et intrinsèque à toute réflexion sur le logiciel libre. Sans cette garantie d’interopérabilité il ne peut y avoir de libertés informatiques pleines et entières. Cette obligation sans équivoque apportée au BOFIP est donc un apport judicieux au dispositif.

Quelle suite ?

À un mois de la fin de la période de « tolérance administrative », l’April se montre confiante dans l’application de la réglementation pour les acteurs et utilisateurs de logiciels libres de caisse, particulièrement eu égard à l’attitude constructive de l’administration fiscale sur ce dossier.

Ne nous y trompons pas. L’objet de cette loi était d’adresser les mauvaises pratiques, parfois frauduleuses, de certains éditeurs de logiciels privateurs. Ainsi, malgré les craintes initiales liées à la rédaction du texte, l’April et les représentants de logiciels libres français concernés par cette loi ont accueilli positivement cette réglementation qui permet d’assainir le marché des logiciels de caisse et d’apporter davantage de sécurité juridique.

Dans ses premières versions, le dispositif était révélateur d’une représentation purement privative de l’informatique, sous forme de boîte noire, et était disproportionné dans ses atteintes aux libertés informatiques. Bien que l’on ne soit pas encore totalement sorti de ce paradigme, l’April salue l’attitude constructive des services de Bercy en charge du dossier et note une dynamique positive dans les évolutions successives du BOFIP. Jusqu’à aboutir aujourd’hui à une version bien plus équilibrée qui intègre de manière globalement satisfaisante le logiciel libre et ses modèles de développement. L’association restera évidemment mobilisée sur ce sujet et espère maintenir cette qualité d’échanges avec l’administration, dans un esprit de transparence et de coopération, valeurs fondamentales du mouvement du logiciel libre.

  1. Le dispositif utilise le terme d’« éditeur » pour qualifier la catégorie de personnes concernées par les obligations de certification et d’attestation. Mais la notion d’éditeur doit être entendue dans un sens large, englobant par exemple le prestataire qui fera de l’intégration et/ou qui s’occupera de maintenir le système à jour dès lors qu’il sera « le dernier intervenant ayant paramétré le logiciel ou système lorsque son intervention a eu pour objet ou effet de modifier un ou des paramètres permettant le respect des conditions d’inaltérabilité, de sécurisation, de conservation et d’archivage des données » (§ 310 BOI-TVA). Nous parlerons ainsi régulièrement d’intégrateur en substitution du terme éditeur, plus caractéristique de l’informatique privatrice. Il nous semble en effet que dans le domaine de l’encaissement, les logiciels libres sont essentiellement communautaires. La vente de prestation est le fait d’intégrateurs qui peuvent être minoritaires parmi les contributeurs directs au code source du logiciel. 

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Meilleures contributions LinuxFr.org : les primées de novembre 2018

12 décembre, 2018 - 20:40

Nous continuons sur notre lancée de récompenser ceux qui chaque mois contribuent au site LinuxFr.org (dépêches, commentaires, logo, journaux, correctifs, etc.). Vous n’êtes pas sans risquer de gagner un abonnement à GNU/Linux Magazine France ou encore un livre des éditions Eyrolles ou ENI. Voici les gagnants du mois de novembre 2018 :

Abonnement d’un an à GNU/Linux Magazine France (éditions Diamond)

Livres des éditions Eyrolles et ENI

Les livres qu’ils ont sélectionnés sont en seconde partie de la dépêche. N’oubliez pas de contribuer, LinuxFr.org vit pour vous et par vous !

Certains gagnants n’ont pas pu être joints ou n’ont pas répondu. Les lots ont été ré-attribués automatiquement. N’oubliez pas de mettre une adresse de courriel valable dans votre compte ou lors de la proposition d’une dépêche. En effet, c’est notre seul moyen de vous contacter, que ce soit pour les lots ou des questions sur votre dépêche lors de sa modération. Tous nos remerciements aux contributeurs du site ainsi qu’à GNU/Linux Magazine France, aux éditions Eyrolles et ENI.

Les livres sélectionnés par les gagnants :

                        Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Firefox 64 bitte !

12 décembre, 2018 - 20:15

La version 64 de Firefox a été publiée le 11 décembre 2018.

Alors que la précédente version apportait son lot de changements principalement sous le capot (gros travail d’enrichissement de l’API WebExtensions, déport de l’exécution des WebExtensions dans un processus dédié sous GNU/Linux, passage au compilateur Clang sous MS Windows…), cette version apporte deux nouveautés majeures : une sous le capot, avec l’intégration du nouveau moteur de rendu graphique WebRender, activée par défaut sur certaines configurations ; l’autre au niveau de l’interface, avec la possibilité très attendue par certains de pouvoir interagir sur plusieurs onglets simultanément.

Comme d’habitude, le détail des nouveautés suit en deuxième partie.

Sommaire Zoom sur deux changements majeurs en cours : WebRender et Mozilla Android Components Le nouveau moteur de rendu graphique WebRender

Après le remplacement du moteur de style de Firefox par un nouveau, écrit en Rust dans le cadre du projet Servo (Quantum CSS, intégré à la version 57), le remplacement du moteur de rendu graphique de Firefox par celui issu du même projet Servo (WebRender) est en cours, avec même son activation par défaut pour certaines configurations dès cette version !

À cette occasion, un effort de pédagogie est fait sur le Mozilla Gfx Team Blog, au travers d’une succession de billets intéressants :

Mozilla Android Components

Nous vous avions déjà parlé des Mozilla Android Components, voici à présent un aperçu technique de la chose. Ces composants sont en train de devenir la base technique commune des navigateurs de Mozilla pour Android, et ont vocation à être adoptés à l’extérieur de Mozilla. Ils permettent d’adosser le moteur de rendu de son choix : Gecko, Servo ou Blink (Android Web View).

Nouveautés pour le bureau

Les nouveautés de la version bureau sont :

  • la sélection simultanée de plusieurs onglets pour les déplacer, les épingler, les marquer ou encore les rendre silencieux (d’autres possibilités à venir, comme de pouvoir envoyer plusieurs onglets simultanément vers un autre appareil) est désormais possible ;
  • les utilisateurs de Windows 10 possédant une carte NVIDIA profiteront en avant‐première du nouveau moteur de rendu graphique WebRender, pour des performances améliorées ;
  • les flux RSS ne sont plus pris en charge, sauf à passer par des extensions ;
  • le menu contextuel que l’on peut dérouler sous l’icône des extensions affichées sur la barre d’outils offre dorénavant la possibilité directe de désinstaller l’extension (en plus de pouvoir « Gérer l’extension ») ;
  • la page « about:performance » a été refondue : nous vous l’avions annoncé dans les prévisions de la dépêche précédente et c’est déjà implémenté : désormais la consommation énergétique est mentionnée et la possibilité de fermer les onglets est offerte (il manque la consommation de mémoire par rapport à la maquette qui avait été proposée : rassurez‐vous, c’est prévu pour la prochaine version) ;
  • après la version Windows (Firefox 63), c’est aux versions macOS et GNU/Linux d’être à présent compilées via Clang : les distributions vont‐elles suivre ce choix pour leur paquet du navigateur ? Fedora a déjà répondu par l’affirmative ;
  • le déploiement en entreprise se trouve facilité sur macOS ;
  • comme annoncé, Firefox retire effectivement sa confiance aux certificats TLS de Symantec, suite à l’historique de mauvaises pratiques de cette société en la matière.
Nouveautés pour Android

Peu de changements. Citons, outre de petites améliorations et corrections :

  • le défilement (scrolling) a été amélioré : plus rapide et réactif ;
  • comme pour la version bureau, les certificats TLS de Symantec ne sont plus considérés comme fiables.
Actualités afférentes Qu’attendre de la version 65 ?

Le gestion du format WebP, une clarification de la partie « Blocage de contenu » des préférences du logiciel (ce n’est pas du luxe), une sécurité améliorée via une meilleure protection contre la corruption de pile (stack‐smashing) sur GNU/Linux, Android et macOS…

La version « Nightly » inclut désormais un paramètre permettant d’activer le mode Wayland

Tout est expliqué ici.

L’accélération matérielle de la composition sous GNU/Linux, ça en est où ?

Réponse courte : nulle part.

Firefox Lite 1.0.0 pour Android

Cette nouvelle variante de Firefox pour Android vous a été présentée dans une récente dépêche.

AV1

Le décodage de l’AV1, le codec nouvelle génération proposé par l’organisation à but non lucratif Alliance for Open Media, pourrait apparaître dans Firefox 65 [rapport de bogue]. Dans cette optique, la v0.1 de dav1d, le décodeur de référence issu du développement conjoint de VideoLAN, VLC et FFmpeg, vient de paraître.

Goodbye, EdgeHTML

Après Opera, c’est au tour du navigateur Web de Microsoft d’abandonner son propre moteur de rendu au profit de celui de Google Chrome, Blink, qui va ainsi renforcer sa position dominante : c’est catastrophique pour les standards du Web, et ceci alors qu’Apple n’investit plus depuis longtemps dans WebKit, le moteur de rendu de Safari (pour ne pas concurrencer son business autour des applications) et que les parts de marché de Gecko, le moteur de rendu de Firefox, sont au plus bas (lire le billet anglophone de Mozilla). :(

Thunderbird migre aussi vers les Web Extensions

La communauté de développement de Thunderbird a finalement décidé de s’attaquer au problème des extensions à travers la solution choisie par Mozilla pour Firefox : des nouvelles API sont en cours de développement pour développer de nouvelles extensions.

Par rapport à XUL, ces API seront plus simples à utiliser, plus stables et clairement documentées. Pour la documentation à jour, la communauté est en train de tester l’outil readthedocs pour garder automatiquement la documentation à jour.

Beaucoup d’extensions vont devoir être réécrites (note d’Adrien Dorsaz : je pense notamment à ExchangeCalendar à laquelle j’ai un peu contribué), mais, si ça se passe aussi bien que pour Firefox, les API seront bien plus simples à utiliser que XUL, seront mieux documentées et aussi plus stables.

Heureusement, Thunderbird est encore capable de charger des extensions XUL (comme le calendrier Lightning) en créant des Web Extensions avec un fichier manifest qui précise que c’est une extension XUL (legacy) et qu’il faut faire le chargement des overlays (méthodes de modification des interfaces XUL par ajout de surcouche). Seulement, Thunderbird est en train de supprimer petit à petit ses overlays, donc cette méthode ne fonctionnera pas indéfiniment.

Danke schön !

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

ONLYOFFICE est maintenant disponible dans Pydio Cells

12 décembre, 2018 - 14:49

Abstrium SAS, une entreprise française de développement de logiciels open source, et Ascensio System SIA, la maison‐mère lettone de ONLYOFFICE, ont annoncé un partenariat technique pour fournir aux utilisateurs de Pydio Cells la possibilité de travailler sur des documents en ligne en utilisant les éditeurs de documents ONLYOFFICE (déjà présentés sur LinuxFr.org).

Pydio est une plate‐forme Web de gestion de fichiers pour entreprise sous licence AGPL 3.

L’intégration avec ONLYOFFICE est disponible à partir de la version 1.2.3 de Pydio Cells Enterprise grâce au connecteur intégré développé par Abstrium. Pour en profiter, il faut avoir ONLYOFFICE Document Server (Community ou Integration Edition) installé.

ONLYOFFICE Document Server ce sont des éditeurs de texte, de classeurs et de présentations qui se chargent dans le navigateur Web pour une édition collaborative en temps réel, avec commentaires et messagerie instantanée.

ONLYOFFICE vient déjà de signer deux accords de collaboration importants, avec ownCloud puis Nextcloud. La collection de connecteurs pour ONLYOFFICE s’enrichit très rapidement. Actuellement, il y a des connecteurs pour Alfresco, Confluence, Nextcloud, ownCloud, SharePoint, XWiki, Liferay, CommuniGate. On peut également connecter ONLYOFFICE à PowerFolder, eXo Platform et Moodle.

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Quelques frameworks web C++ (2/2)

12 décembre, 2018 - 10:31

Actuellement, il existe de nombreux langages et frameworks intéressants pour le développement web backend. Dans ce domaine, le C++ n'est pas le langage le plus à la mode, mais il possède cependant des atouts intéressants. En effet, le C++ possède de nombreuses bibliothèques (dont des frameworks web), il est réputé pour ses performances, enfin ses dernières normes le rendent plus agréable à utiliser.

L'objectif de cet article est de donner un aperçu des outils C++ disponibles pour le développement web backend, à partir d'un exemple d'application. Les codes sources présentés ici sont disponibles sur ce dépôt git. Les différents frameworks utilisés sont résumés en annexe (partie 2). Enfin, une liste de bibliothèques C++ est disponible sur Awesome C++.

Partie 2 : frameworks web.

Sommaire Les frameworks web Les micro-frameworks, à la Sinatra/Flask

Les micro-frameworks web, comme Sinatra en Ruby ou Flask en Python, ont pour objectif d'être simples et légers. Ils proposent principalement des fonctionnalités pour traiter des requêtes HTTP ainsi qu'un mécanisme de routage d'URL. Si nécessaire, ils peuvent être complétés par d'autres bibliothèques (génération de HTML, accès à une base SQL…).

Il existe plusieurs micro-frameworks C++, par exemple crow (voir animals-crow) ou silicon (voir animals-silicon) :

#include <silicon/api.hh> #include <silicon/backends/mhd.hh> #include <silicon/middlewares/sqlite_connection.hh> #include <silicon/middleware_factories.hh> #include "symbols.hh" using namespace sl; using namespace std; ... int main() { // create app auto api = http_api( // serve the about page GET / _about = [] () { return renderAbout(); }, // serve the home page (and filter the animals using the "myquery" parameter) GET / _animals * get_parameters(_myquery = optional(string())) = [] (const auto & p, sqlite_connection & c) { vector<Animal> animals = getAnimals(p.myquery, c); return renderHome(p.myquery, animals); }, // serve static files (located in the "mystatic" directory) GET / _mystatic = file_server("./mystatic") ); // create a connection factory to the database auto factory = middleware_factories( sqlite_connection_factory("animals.db") ); // run a server on port 3000 mhd_json_serve(api, factory, 3000); }

Ici, les fonctionnalités du C++ moderne rendent le code concis et plutôt agréable à lire (par exemple la lambda pour la route _animals).

Dans une phase de prétraitement, Silicon génère le fichier symbols.hh, qui déclare les symboles définis par le programmeur, notamment les routes (_about, _home, _mystatic…). Ceci permet de vérifier statiquement que les routes sont utilisées correctement dans le code. D'autres langages utilisent l'introspection pour effectuer ce genre de vérification mais C++ ne possède pas cette fonctionnalité.

Les frameworks asynchrones, à la Node.js

Les frameworks asynchrones, comme Node.js/Express en JavaScript, proposent les mêmes fonctionnalités que les micro-frameworks classiques mais via des fonctions non-bloquantes. Ainsi, si une requête a besoin d'une ressource, l'application peut passer à une autre requête en attendant que la ressource soit disponible. Ceci permet d'améliorer les performances générales de l'application mais nécessite un style de programmation particulier, à base de promesses connectées à des fonctions callbacks par des then pour former une chaine de traitements asynchrones.

Il existe différents frameworks asynchrones en C++, par exemple cpprestsdk (voir animals-cpprestsdk) et pistache (voir animals-pistache) :

#include "Animal.hpp" #include "View.hpp" #include <pistache/http.h> #include <pistache/router.h> #include <pistache/endpoint.h> using namespace Pistache; using namespace std; // define server app class App : public Http::Endpoint { private: Rest::Router router; public: App(Address addr) : Http::Endpoint(addr) { auto opts = Http::Endpoint::options() .flags(Tcp::Options::InstallSignalHandler) .flags(Tcp::Options::ReuseAddr); init(opts); // create a route for the about page Rest::Routes::Get(router, "/about", [=](const Rest::Request &, Http::ResponseWriter response) { response.send(Http::Code::Ok, renderAbout()); return Rest::Route::Result::Ok; }); // create a route for the home page Rest::Routes::Get(router, "/", [=](const Rest::Request & request, Http::ResponseWriter response) { auto myquery = request.query().get("myquery").getOrElse(""); const vector<Animal> animals = getAnimals(myquery); response.send(Http::Code::Ok, renderHome(move(myquery), move(animals))); return Rest::Route::Result::Ok; }); // create a route for serving static files Rest::Routes::Get(router, "/static/:filename", [=](const Rest::Request & request, Http::ResponseWriter response) { auto filename = request.param(":filename").as<string>(); // the Pistache API is non-blocking; for example, serveFile returns // a Promise, for attaching a callback function Http::serveFile(response, "static/" + filename) .then( [=](ssize_t s){ cout << filename << " (" << s << " bytes)" << endl; }, Async::NoExcept); return Rest::Route::Result::Ok; }); setHandler(router.handler()); } }; // run server app on port 3000 int main() { App app({Ipv4::any(), 3000}); app.serve(); }

On retrouve ici une gestion classique des routes (avec le nom de la route et sa fonction de traitement). Cependant, on a désormais un fonctionnement asynchrone, via des fonctions non bloquantes. Par exemple pour la route "static", la fonction serveFile retourne une promesse que l'on connecte à une fonction callback, qui affiche un message de log une fois la promesse résolue.

Les frameworks MVC, à la RoR/Django

Les frameworks web MVC, comme Ruby on Rails ou Python Django, sont des outils classiques dont l'objectif est d'implémenter tout type d'application web. Ils fournissent généralement toutes les fonctionnalités nécessaires : routage d'URL, système de templating, accès à des bases de données, système d'authentification… Les frameworks MVC ne semblent pas être le domaine de prédilection du C++ mais on trouve tout de même quelques outils intéressants, notamment cppcms.

En plus des fonctionnalités classiques d'un framework MVC, cppcms propose un système de templating assez évolué, avec héritage de vues et gestion de contenu. Par exemple, on peut définir une vue principale MasterView et en dériver des vues AboutView et HomeView qui héritent des caractéristiques de MasterView et les complètent. Enfin, on peut associer un contenu à ces vues (paramètres des templates), également avec un système d'héritage. En reprenant l'exemple précédent, on peut définir un contenu MasterContent pour la vue MasterView, la dériver en HomeContent pour la vue HomeView et utiliser directement MasterContent pour la vue AboutView (pas de nouveau paramètre dans le template).

Au niveau du code, le fichier animals-cppcms/src/content.h définit les contenus :

// define how to exchange data between the C++ code and the templates namespace content { // content for MasterView and AboutView struct MasterContent : cppcms::base_content { std::string title; // the "title" parameter in master.tmpl }; // datatype for the form in HomeView struct InfoForm : cppcms::form { cppcms::widgets::text myquery; InfoForm() { add(myquery); } }; // content for HomeView // inherits from MasterContent, because HomeView inherits from MasterView struct HomeContent : MasterContent { std::vector<Animal> animals; // the "animals" parameter in home.tmpl InfoForm info; // the "info" parameter in home.tmpl }; }

Le fichier animals-cppcms/src/master.tmpl définit la vue MasterView :

<% c++ #include "content.h" %> <% skin myskin %> <% view MasterView uses content::MasterContent %> <!-- "title" is set in the C++ code and used in the "render" template below --> <% template title() %> <%= title %> <% end %> <!-- "page_content" is set in the sub-template and used in the "render" template below --> <% template page_content() %> to be overriden in sub-templates <% end %> <!-- main template that uses the two previous ones and that is called from the C++ code --> <% template render() %> <html> <head> <style> body { background-color: azure; } ... </style> </head> <body> <!-- adds the "title" template defined above --> <h1><% include title() %></h1> <!-- adds the "page_content" template defined above --> <div> <% include page_content() %> </div> </body> </html> <% end template %> <% end view %> <% end skin %>

Le fichier animals-cppcms/src/about.tmpl définit la vue AboutView :

<% skin myskin %> <!-- inherits from MasterView --> <% view AboutView uses content::MasterContent extends MasterView %> <!-- defines "page_content", that is used in MasterView --> <% template page_content() %> <p>Generated by <a href='http://cppcms.com/wikipp/en/page/main'>Cppcms</a></p> <p><a href='<% url "/" %>'>Home</a></p> <% end template %> <% end view %> <% end skin %>

Le fichier animals-cppcms/src/about.tmpl définit la vue HomeView :

<% skin myskin %> <!-- inherits from MasterView --> <% view HomeView uses content::HomeContent extends MasterView %> <!-- defines "page_content", that is used in MasterView --> <% template page_content() %> <!-- creates a form using the "info" attribute defined in HomeContent --> <form method="get" action="" > <% form as_p info %> </form> <!-- add the HTML elements corresponding to the "animals" attribute defined in HomeContent --> <% foreach animal in animals %> <% item %> <a class="aCss" href="img/<%= animal.image %>" > <div class="divCss"> <p><%= animal.name %></p> <img class="imgCss" src="img/<%= animal.image %>" /> </div> </a> <% end %> <% end foreach %> <p style="clear:both"><a href='<% url "/about" %>'>About</a></p> <% end template %> <% end view %> <% end skin %>

Enfin le programme principal définit le routage d'URL et initialise les contenus avant de lancer le rendu des vues. Fichier animals-cppcms/src/main.cpp :

// main application class App : public cppcms::application { public: App(cppcms::service &srv) : cppcms::application(srv) { // about page dispatcher().assign("/about", &App::about, this); mapper().assign("about","/about"); // home page dispatcher().assign("", &App::home, this); mapper().assign(""); // images dispatcher().assign("/img/([a-z_0-9_\-]+\.jpg)", &App::serveJpg, this, 1); // root url mapper().root("/animals"); } private: void about() { // AboutView inherits from MasterView and uses the same content type (MasterContent) content::MasterContent c; c.title = "About (Cppcms)"; // render the AboutView template render("AboutView", c); } void home() { // HomeView inherits from MasterView and uses its own content type // (HomeContent, that inherits from MasterContent) content::HomeContent c; // data defined in MasterContent c.title = "Animals (Cppcms)"; // data defined in HomeContent c.info.load(context()); c.animals = getAnimals(c.info.myquery.value()); // render the HomeView template render("HomeView", c); } void serveJpg(string filename) { // open and send the image file ifstream ifs("img/" + filename); if (ifs) { response().content_type("image/jpeg"); response().out() << ifs.rdbuf(); } else { response().status(404); } } }; // create and run the application int main(int argc, char ** argv) { try { cppcms::service srv(argc, argv); srv.applications_pool().mount(cppcms::applications_factory<App>()); srv.run(); } catch(exception const & e) { cerr << e.what() << endl; } return 0; }

Les frameworks MVC sont des outils efficaces pour implémenter des applications complexes. Cependant, ils nécessitent un apprentissage assez conséquent et peuvent être surdimensionnés pour des petites applications simples.

Les frameworks basés templates, à la PHP

Le framework tntnet propose un système basé templates, à la manière de PHP. Si ce framework est assez anecdotique dans l'ecosystème C++, il semble cependant plutôt efficace dans son approche : écrire du code HTML classique et y ajouter des sections de code C++ là où c'est nécessaire.

Par exemple, le fichier animals-tntent/src/myimg.ecpp définit une application qui affiche une image dont le nom est passé en paramètre :

<%args> filename; </%args> <html> <body> <img src="static/img/<$filename$>" /> </body> </html>

De même, le fichier animals-tntent/src/home.ecpp définit une application plus complexe (appel de fonction C++, génération de code HTML via une boucle en C++…) :

<%args> myquery; </%args> <%pre> #include "Animal.hpp" </%pre> <html> <head> <link rel="stylesheet" type="text/css" href="static/style.css"> </head> <body> <h1>Animals (Tntnet)</h1> <form> <p> <input type="text" name="myquery" value="<$myquery$>"> </p> </form> <%cpp> for (const Animal & animal : getAnimals(myquery)) { </%cpp> <a href="myimg?filename=<$animal.image$>"> <div class="divCss"> <p> <$animal.name$> </p> <img class="imgCss" src="static/img/<$animal.image$>" /> </div> </a> <%cpp> } </%cpp> <p style="clear: both"><a href="/about">About</a></p> </body> </html>

Enfin, tntnet propose différents types de déploiement : programme CGI, serveur autonome, serveur d'applications tntnet compilées dans des bibliothèques dynamiques. Par exemple, pour implémenter un serveur autonome (animals-tntent/src/main.cpp) :

#include <tnt/tntnet.h> // run server on port 3000 int main() { try { tnt::Tntnet app; app.listen(3000); app.mapUrl("^/$", "home"); // route the "/" url to the "home" application app.mapUrl("^/about$", "about"); // route the "/about" url to the "about" application app.mapUrl("^/myimg$", "myimg"); // ... app.mapUrl("^/(static/.*)", "$1", "static@tntnet"); app.run(); return 0; } catch (const std::exception & e) { std::cerr << e.what() << std::endl; return -1; } }

À noter que ce type de framework est peut-être moins adapté au développement d'applications complexes (lisibilité des templates, réutilisation…).

Les frameworks basés widgets

Ces outils s'inspirent des frameworks d'interfaces graphiques de bureau, comme Qt ou gtkmm, c'est-à-dire basés sur une hiérarchie de widgets composant l'interface et intéragissant via un mécanisme de signal-slot.

Les frameworks web basés widgets sont étonnament peu répandus, même tous langages confondus, alors que leur potentiel semble important. En effet, ils permettent de développer une application fullstack client-serveur en utilisant une bibliothèque d'interface graphique classique et sans avoir à trop se préoccuper de l'architecture réseau de l'application.

En C++, le framework le plus abouti dans cette catégorie est certainement Wt. Wt possède de nombreux widgets classiques ou évolué, un ORM SQL, un système d'authentification, la possibilité de manipuler du HTML/CSS… En Wt, le programme principal se résume à router des URL vers les applications correspondantes (animals-wt/src/main.cpp) :

... int main(int argc, char ** argv) { try { WServer server(argc, argv, WTHTTP_CONFIGURATION); // route the url "/about" to an application "AboutApp" server.addEntryPoint(EntryPointType::Application, [](const WEnvironment & env) { return make_unique<AboutApp>(env); }, "/about"); // route the url "/" to an application "HomeApp" server.addEntryPoint(EntryPointType::Application, [=](const WEnvironment & env) { return make_unique<HomeApp>(env); }, "/"); server.run(); } catch (Dbo::Exception & e) { cerr << "Dbo::Exception: " << e.what() << endl; } return 0; }

Ces applications Wt correspondent à des interfaces graphiques classiques mais avec une architecture client-serveur. Par exemple pour définir l'application "about" (page statique) via le système de template HTML/CSS, il suffit de définir la classe suivante (animals-wt/src/AboutApp.hpp) :

... // Application class implementing the about page class AboutApp : public Wt::WApplication { private: // main HTML template of the application const std::string _app_template = R"( <h1>About (Wt)</h1> <p>Generated by <a href="https://www.webtoolkit.eu/wt">Wt</a></p> <p><a href="/">Home</a></p> )"; public: // create the application AboutApp(const Wt::WEnvironment & env) : Wt::WApplication(env) { // load css useStyleSheet({"style.css"}); // create the main widget using the HTML template root()->addWidget(std::make_unique<Wt::WTemplate>(_app_template)); } };

Pour une application plus complexe, par exemple la page affichant les animaux, on peut définir un nouveau widget AnimalWidget qui implémente une vignette, puis utiliser cette classe pour afficher tous les animaux lus dans la base de données (voir animals-wt/src/HomeApp.hpp) :

... bool isPrefixOf(const std::string & txt, const std::string & fullTxt) { return std::inner_product(std::begin(txt), std::end(txt), std::begin(fullTxt), true, std::logical_and<char>(), std::equal_to<char>()); } // widget showing an animal (name + image + anchor) class AnimalWidget : public Wt::WAnchor { private: // pointer to the WText that contains the animal name Wt::WText * _animalName; public: AnimalWidget(const Animal & animal) { // set anchor href const std::string imagePath = "img/" + animal.image; setLink(Wt::WLink(imagePath)); // create a container widget, inside the anchor widget auto cAnimal = addWidget(std::make_unique<Wt::WContainerWidget>()); cAnimal->setStyleClass("divCss"); // create a text widget, inside the container auto cText = cAnimal->addWidget(std::make_unique<Wt::WContainerWidget>()); cText->setPadding(Wt::WLength("1em")); _animalName = cText->addWidget(std::make_unique<Wt::WText>(animal.name)); // create an image widget, inside the container auto img = cAnimal->addWidget(std::make_unique<Wt::WImage>(imagePath)); img->setStyleClass("imgCss"); } void filter(const std::string & txt) { // show the widget if txt is null or if it is a prefix of the animal name setHidden(txt != "" and not isPrefixOf(txt, _animalName->text().toUTF8())); } }; // Application class implementing the home page class HomeApp : public Wt::WApplication { private: // the line edit widget (for querying animal to show/hide) Wt::WLineEdit * _myquery; // the animal widgets std::vector<AnimalWidget*> _animalWidgets; // main HTML template of the application const std::string _app_template = R"( <h1>Animals (Wt)</h1> <p>${myquery}</p> ${animals} <p style="clear: both"><a href="/about">About</a></p> )"; // show all animals that match the _myquery prefix void filterAnimals() { for(auto aw : _animalWidgets) aw->filter(_myquery->text().toUTF8()); } public: // create the application HomeApp(const Wt::WEnvironment & env) : WApplication(env) { // load css useStyleSheet({"style.css"}); // create the main widget using the HTML template auto r = root()->addWidget(std::make_unique<Wt::WTemplate>(_app_template)); // create the remaining widgets and bind them to the template placeholders _myquery = r->bindWidget("myquery", std::make_unique<Wt::WLineEdit>()); // connect the widget _myquery to the function filterAnimals _myquery->textInput().connect(this, &HomeApp::filterAnimals); // create a container widget for the animals auto w = r->bindWidget("animals", std::make_unique<Wt::WContainerWidget>()); // open the database Wt::Dbo::Session session; session.setConnection(std::make_unique<Wt::Dbo::backend::Sqlite3>("animals.db")); session.mapClass<AnimalDb>("animals"); // query the database Wt::Dbo::Transaction transaction(session); Wt::Dbo::collection<Wt::Dbo::ptr<AnimalDb>> dboAnimals = session.find<AnimalDb>(); for (const Wt::Dbo::ptr<AnimalDb> & dboAnimal : dboAnimals) { // add a widget auto aw = w->addWidget(std::make_unique<AnimalWidget>(*dboAnimal)); // store a pointer, for future updates _animalWidgets.push_back(aw); } } };

À première vue, cette implémentation peut sembler plus longue et plus compliquée que les implémentations précédentes. Cependant, son code devrait sembler familier à n'importe quel développeur d'interface graphique de bureau. De plus, cette implémentation gère l'ensemble de l'application (fullstack), et non la partie serveur uniquement. Par exemple, la connexion du signal _myquery->textInput() à la fonction HomeApp::filterAnimals implique des mises-à-jour en temps-réel côté client, ce qui serait nettement plus difficile à implémenter avec les frameworks précédents.

Intégration avec Nix

Avant de conclure, voici une petite remarque concernant l'intégration, dans un projet de code, des frameworks présentés. En effet, ces frameworks sont rarement présents dans les logithèques des OS et doivent donc généralement être installées manuellement. Pour cela, on choisit classiquement l'une des deux solutions suivantes :

  • télécharger le code source de la bibliothèque, l'installer dans un dossier local ou système et régler les variables d'environnement de façon à trouver la bibliothèque;
  • intégrer la bibliothèque directement au projet, par exemple via les sous-modules git, et configurer le projet de façon à trouver la bibliothèque.

Aucune de ces solutions n'est vraiment satisfaisante : la première solution introduit une dépendance externe peu portable qu'il faut mettre à jour manuellement; la seconde solution introduit des duplications de code potentielles et nécessite une configuration de projet particulière.

Une troisième solution, particulièrement avantageuse, consiste à utiliser le système de paquets Nix. Par exemple, pour récupérer et empaqueter cpprestsdk depuis son projet github, il suffit d'écrire le fichier Nix suivant (voir animals-cpprestsdk/nix/cpprestsdk.nix) :

{ stdenv, fetchFromGitHub, cmake, boost, openssl, websocketpp, zlib }: stdenv.mkDerivation { name = "cpprestsdk"; src = fetchFromGitHub { owner = "Microsoft"; repo = "cpprestsdk"; rev = "204a52610234ac5180e80a6883b62c0ad085f51e"; sha256 = "0mj2m6n889zdhwxdx24ljxfqryivvn3w9vzs94ppzcx5apa5jb3w"; }; enableParallelBuilding = true; buildInputs = [ boost cmake openssl websocketpp zlib ]; }

Pour inclure, dans un projet, des frameworks ainsi empaquetés, il suffit alors de les appeler dans le fichier de configuration default.nix du projet (voir animals-cpprestsdk/default.nix) :

with import <nixpkgs> {}; let _cpprestsdk = callPackage ./nix/cpprestsdk.nix {}; _ctml = callPackage ./nix/ctml.nix {}; _sqlite_orm = callPackage ./nix/sqlite_orm.nix {}; in stdenv.mkDerivation { name = "animals-cpprestsdk"; src = ./.; buildInputs = [ boost _cpprestsdk _ctml openssl sqlite _sqlite_orm ]; buildPhase = '' g++ -O2 -o animals-cpprestsdk src/*.cpp -lcpprest -lboost_system -lssl -lsqlite3 sqlite3 animals.db < animals.sql ''; installPhase = '' mkdir -p $out/static cp animals-cpprestsdk $out/ cp animals.db $out/ cp $src/static/* $out/static/ ''; }

On peut alors facilement compiler et lancer le programme, avec les commandes suivantes :

nix-build cd result ./animals-cpprestsdk

Cette méthode à l'avantage de rendre les dépendances explicites et isolées mais sans duplication. Elle facilite également la réutilisation et les mises-à-jour.

Conclusion

Pour développer des applications web backend, le C++ est une option tout à fait envisageable. Avec ses dernières évolutions, le langage est généralement plus simple et plus sûr à utiliser, sans compromis sur les performances. De nombreuses bibliothèques C++ sont disponibles pour le développement web : templating, génération de HTML, connexion SQL, ORM, … Les frameworks web sont également nombreux et variés : framework MVC à la RoR/Django, micro-framework à la Sinatra/Flask, framework asynchrone à la Node.js, framework basé template à la PHP, et même framework fullstack basé widget, … Enfin, on notera qu'avec Nix, il est très facile de configurer un projet intégrant ce genre de bibliothèques. Bien évidemment, tout ceci intéressera essentiellement des développeurs qui connaissent déjà C++ car beaucoup d'autres langages ont également des outils très intéressant pour le développement web.

Annexe : résumé des projets et des frameworks présentés

À noter qu'il s'agit uniquement d'exemples d'associations. Il est généralement possible d'utiliser n'importe quel framework web avec n'importe quel générateur HTML et n'importe quelle interface SQL.

projet framework web générateur HTML interface SQL animals-cppcms cppcms (framework MVC) cppcms (système de templates) cppcms (connecteur SQL) animals-cpprestsdk cpprestsdk (framework réseau asynchrone) ctml (générateur de documents) sqlite_orm (ORM) animals-crow http: crow (micro-framework) crow (système de templates) sqlpp11 (ORM) animals-nodejs (Javascript/Node.js) express (micro-framework asynchrone) pug (générateur de documents) better-sqlite3 (connecteur SQL) animals-pistache pistache (micro-framework asynchrone) kainjow mustache (système de templates) sqlite_modern_cpp (connecteur SQL) animals-scotty (Haskell) scotty (micro-framework) lucid and clay (générateurs de documents) sqlite-simple (connecteur SQL) animals-silicon silicon (micro-framework) aucun silicon (connecteur SQL) animals-tntnet tntnet (framework basé templates) tntnet (système de templates) tntnet (connecteur SQL) animals-wt wt (framework basé widgets) wt (système de widgets + templates) wt (ORM) Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Revue de presse de l’April pour la semaine 49 de l’année 2018

11 décembre, 2018 - 08:39

La revue de presse de l’April est régulièrement éditée par les membres de l’association. Elle couvre l’actualité de la presse en ligne, liée au logiciel libre. Il s’agit donc d’une sélection d’articles de presse et non de prises de position de l’Association de promotion et de défense du logiciel libre.

Sommaire

[acteurspublics.com] Bastien Guerry : « Le logiciel libre a besoin d’une vraie stratégie de mutualisation au sein de l’État »
Par Émile Marzolf, le vendredi 7 décembre 2018. Extrait :

« Le tout nouveau “référent logiciels libres” d’Etalab, Bastien Guerry, ancien entrepreneur d’intérêt général, explique à Acteurs publics comment le logiciel libre gagne du terrain dans l’administration et à quels défis il se heurte. »

[ITforBusiness] Officiel : Microsoft Edge adopte Chromium et l’open source
Par Laurent Delattre, le jeudi 6 décembre 2018. Extrait :

« Microsoft annonce un profond changement de stratégie autour de son navigateur Web, Edge. Celui‐ci ne disparaît pas mais adopte le moteur de rendu Chromium et une nouvelle philosophie de développement. »

Et aussi :

[The Conversation] Débat : L’« open science », une expression floue et ambiguë
Par Alexandre Hocquet, le mercredi 5 décembre 2018. Extrait :

« Qu’est‐ce que la “science ouverte” ? En quoi la science actuelle est‐elle “fermée” et que recouvre l’expression “ouvrir la science” comme l’indique le slogan des journées ? »

[Echo Sciences] Le FabLab, un lieu d’émancipation sociale : discours ou réalité ?
Par Éléonore Pérès, le mercredi 5 décembre 2018. Extrait :

« Pour qui s’intéresse un peu à la culture scientifique et technique et à sa place en société, le terme FabLab ne doit pas être inconnu. Il résonne beaucoup dans la sphère de la médiation des sciences et dans les médias depuis quelques années. A travers les idées de “faire soi‐même” et “d’apprendre en faisant”, les FabLabs sont souvent synonymes d’inclusion sociale et de capacitation (ou “empowerment”). Mais qu’en est‐il de la réalité ? »

[Journal du Net] À l’Open CIO Summit, la tentation open source des groupes toujours plus forte
Par Antoine Crochet‐Damais, le mercredi 5 décembre 2018. Extrait :

« À l’Open CIO Summit, la tentation open source des groupes toujours plus forte Les DSI du CAC 40 mettent en avant le rôle des logiciels libres pour passer outre les technologies commerciales et propriétaires. Avec des indicateurs de résultats financiers à la clef. »

Et aussi :

[ZDNet France] La Commission européenne privilégie le logiciel libre
Par Thierry Noisette, le lundi 3 décembre 2018. Extrait :

« Le CNLL, qui fédère 300 entreprises en France, rappelle les débats sur la préférence aux logiciels libres, rejetée par le gouvernement époque Hollande. »

Et aussi :

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Quelques cadriciels Web C++ (1/2)

9 décembre, 2018 - 23:19

Actuellement, il existe de nombreux langages et cadriciels (frameworks) intéressants pour le développement Web côté serveur. Dans ce domaine, le C++ n’est pas le langage le plus à la mode, mais il possède cependant des atouts intéressants. En effet, le C++ dispose de nombreuses bibliothèques (dont des cadriciels Web), il est réputé pour ses performances, enfin ses dernières normes le rendent plus agréable à utiliser.

L’objectif de cet article est de donner un aperçu des outils C++ disponibles pour le développement Web back‐end, à partir d’un exemple d’application. Les codes sources présentés ici sont disponibles sur ce dépôt Git. Les différents cadriciels utilisés sont résumés en annexe (partie 2). Enfin, une liste de bibliothèques C++ est disponible sur Awesome C++.

Partie 1 : exemple d’application, génération de HTML et accès à une base de données.

    Sommaire Exemple d’application Application finale

    On veut implémenter une application qui permet d’afficher des images d’animaux stockées sur le serveur. Un formulaire permet d’indiquer le début du nom des animaux à afficher. On peut afficher l’image complète en cliquant sur la vignette et l’on peut afficher une page d’information via un lien en bas de page. Les données des animaux (noms et fichiers) sont stockées dans une base SQLite sur le serveur.

    Ici, la génération des pages HTML est effectuée sur le serveur, même si la tendance actuelle est plutôt de proposer une API côté serveur et de générer le code HTML côté client.

    Architecture MVC

    De façon très classique, on peut organiser le code de cette application selon une architecture de type MVC, c'est-à-dire en distinguant les données (Modèle), leur affichage (Vue) et leur gestion (Contrôleur).

    Pour notre application, les images sont disponibles sur le serveur et on utilise une base de données Sqlite contenant une table avec les noms et fichiers des animaux. Fichier animals.sql:

    CREATE TABLE animals ( id INTEGER PRIMARY KEY, name TEXT, image TEXT ); INSERT INTO animals (name, image) VALUES('dolphin', 'dolphin-marine-mammals-water-sea-64219.jpg'); INSERT INTO animals (name, image) VALUES('dog', 'night-garden-yellow-animal.jpg'); INSERT INTO animals (name, image) VALUES('owl', 'owl.jpg'); ...

    La partie Modèle se résume alors à un type Animal et à une fonction getAnimals qui interroge la base de données et retourne les Animal dont le nom commence par le préfixe donné. Fichier Animal.hpp:

    #include <string> #include <vector> // Animal datatype struct Animal { std::string name; std::string image; }; // query database (select animals whose name begins with myquery) std::vector<Animal> getAnimals(const std::string & myquery);

    La partie Vue contient deux fonctions retournant des pages au format HTML : renderAbout retourne la page d'information et renderHome retourne la page principale avec les animaux demandés par l'utilisateur. Fichier View.hpp :

    #include "Animal.hpp" // render the about page to HTML std::string renderAbout(); // render the home page to HTML std::string renderHome( const std::string & myquery, const std::vector<Animal> & animals);

    Enfin la partie Contrôleur récupère les événements du client puis met à jour le modèle et la vue. Pour notre application, il n'y a pas de traitement compliqué à réaliser, juste à récupérer les requêtes HTTP et à appeler les fonctions précédentes.

    Exemple en JavaScript

    Avant de voir comment développer cette application en C++, voici une implémentation possible en JavaScript, basée sur le classique framework Node.js.

    Pour accéder à la base de données, on peut utiliser le paquet better-sqlite3. Il suffit d'ouvrir la base de données, d'exécuter une requête SQL et de récupérer les données au format JSON. Fichier animals-nodejs/src/animals.js :

    "use strict"; const db = require("better-sqlite3")("animals.db"); // query database (select animals whose name begins with myquery) exports.getAnimals = myquery => db.prepare("SELECT name,image FROM animals WHERE name LIKE ?||'%'").all(myquery);

    Pour la vue, le paquet pug permet de générer du code HTML à partir d'une chaîne de caractères, en utilisant un formatage particulier. Ceci apporte plusieurs avantages : le formatage utilisé est plus concis à écrire que du code HTML, il n'y a pas de risque d'oublier de fermer une balise HTML, on peut traiter facilement des données d'entrée, par exemple la liste des animaux à afficher… Fichier animals-nodejs/src/view.js :

    "use strict"; const pug = require('pug'); // render the about page to HTML const aboutFunc = pug.compile(` doctype html html head link(rel="stylesheet", type="text/css", href="static/style.css") body h1 About (Node.js) p Generated by a(href="https://nodejs.org/en/") Node.js | , a(href="https://expressjs.com/") Express | , a(href="https://github.com/JoshuaWise/better-sqlite3") Better-sqlite3 | and a(href="https://pugjs.org/api/getting-started.html") Pug a(href="/") Home `); exports.renderAbout = aboutFunc; // render the home page to HTML const homeFunc = pug.compile(` doctype html html head link(rel="stylesheet", type="text/css", href="static/style.css") body h1 Animals (Node.js) form(action="/", method="get") input(name="myquery", value=myquery) each animal in animals a(href="static/"+animal.image) div(class="divCss") p= animal.name img(src="static/"+animal.image, class="imgCss") p(style="clear:both") a(href="/about") About `); exports.renderHome = (myquery, animals) => homeFunc(myquery, animals);

    Cependant Pug ne vérifie pas les types de balises. Par exemple, si on demande une balise toto, Pug génèrera bien le code <toto> … </toto>, alors que cette balise n'existe pas dans la norme HTML.

    Enfin, on utilise le très classique express, pour lancer un serveur avec routage des requêtes HTTP. Fichier animals-nodejs/src/app.js :

    "use strict"; const port = 3000; const view = require("./view.js") const animal = require("./animal.js") const express = require("express"); const app = express(); // serve the about page app.get("/about", function (request, response) { const html = view.renderAbout(); response.send(html); }); // serve the home page (and filter the animals using the myquery parameter) app.get("/", function (request, response) { const myquery = request.query.myquery ? request.query.myquery : "" const animals = animal.getAnimals(myquery); const html = view.renderHome({myquery, animals}); response.send(html); }); // serve static files (located in the "static" directory) app.use("/static", express.static("./static")); // run a server listening on port 3000 app.listen(port, function () { console.log(`Listening on port ${port}...`); });

    À noter que Node.js est un framework asynchrone, c'est-à-dire que des fonctions peuvent être appelées de façon non-bloquante. Ceci permet d'optimiser les performances de l'application générale, au prix d'un peu de complexité de programmation (Promise/callback, async/await…). Pour notre application, cela n'a pas vraiment d'influence, car la principale fonction potentiellement concernée (la fonction d'accès à la base de données, via better-sqlite3) est bloquante.

    Exemple en Haskell

    L'application est également simple à implémenter en Haskell, avec le framework scotty.

    Pour le modèle, on définit un type Animal et une fonction d'accès à la base de données par requête SQL via sqlite-simple. Fichier animals-scotty/src/Animal.hs :

    {-# LANGUAGE OverloadedStrings #-} module Animal where import qualified Data.Text.Lazy as L import qualified Database.SQLite.Simple as SQL import Database.SQLite.Simple.FromRow (FromRow, fromRow, field) -- Animal datatype data Animal = Animal { animalName :: L.Text , animalImage :: L.Text } deriving Show -- deserialize an Animal from the database instance FromRow Animal where fromRow = Animal <$> field <*> field -- query database (select animals whose name begins with myquery) getAnimals :: L.Text -> IO [Animal] getAnimals myquery = do let req = "SELECT name,image FROM animals WHERE name LIKE ?||'%'" SQL.withConnection "animals.db" (\conn -> SQL.query conn req (SQL.Only myquery))

    Pour la génération du code HTML et du code CSS, Haskell dispose de DSL (Domain Specific Languages), ici lucid et clay. Ceci permet non seulement d'assurer le formatage correct des balises mais également que ces balises sont bien correctes. Ainsi, si on essaie de générer une balise toto (qui n'existe pas dans la norme HTML), le compilateur indiquera une erreur. Fichier animals-scotty/src/View.hs :

    {-# LANGUAGE OverloadedStrings #-} module View where import Animal import qualified Clay as C import Control.Monad(forM_) import Lucid import qualified Data.Text.Lazy as L -- render the about page to HTML aboutPage :: L.Text aboutPage = renderText $ html_ $ do head_ $ style_ $ L.toStrict $ C.render $ myCss body_ $ do h1_ "About (Scotty)" p_ $ do "Generated by " a_ [href_ "http://hackage.haskell.org/package/scotty"] "Scotty" p_ $ a_ [href_ "/"] "Home" -- render the home page to HTML homePage :: L.Text -> [Animal] -> L.Text homePage myquery animals = renderText $ html_ $ do head_ $ style_ $ L.toStrict $ C.render $ myCss body_ $ do h1_ "Animals (Scotty)" -- add the HTML form form_ [action_ "/", method_ "get"] $ do input_ [name_ "myquery", value_ $ L.toStrict myquery] -- add every animal in a HTML div forM_ animals $ \ animal -> do let img = L.toStrict $ L.concat ["./img/", animalImage animal] a_ [href_ img] $ div_ [class_ "divCss"] $ do p_ $ toHtml $ animalName animal img_ [src_ img, class_ "imgCss"] p_ [style_ "clear: both"] $ a_ [href_ "/about"] "About" -- our CSS styles myCss :: C.Css myCss = do C.a C.# C.byClass "aCss" C.? do C.textDecoration C.none C.color C.inherit C.body C.? do C.backgroundColor C.azure C.div C.# C.byClass "divCss" C.? do C.backgroundColor C.beige C.border C.solid (C.px 1) C.black C.margin (C.em 1) (C.em 1) (C.em 1) (C.em 1) C.width (C.px 320) C.textAlign C.center C.float C.floatLeft C.img C.# C.byClass "imgCss" C.? do C.width (C.px 320) C.height (C.px 240)

    Enfin, le serveur principal se résume à router les requêtes HTTP en utilisant les fonctions du framework scotty. Fichier animals-scotty/src/Main.hs :

    {-# LANGUAGE OverloadedStrings #-} import Animal import View import Control.Monad.Trans (liftIO) import Network.Wai.Middleware.RequestLogger (logStdoutDev) import Network.Wai.Middleware.Static (addBase, staticPolicy) import Web.Scotty (get, html, middleware, param, rescue, scotty) -- run a server listening on port 3000 main = scotty 3000 $ do -- show logs middleware logStdoutDev -- serve the about page get "/about" $ html aboutPage -- serve the home page (and filter the animals using the myquery parameter) get "/" $ do myquery <- param "myquery" `rescue` (\_ -> return "") animals <- liftIO $ getAnimals myquery html $ homePage myquery animals -- serve static files (located in the "static" directory) middleware $ staticPolicy $ addBase "static"

    Par conception, Haskell permet également de faire de l'asynchrone assez facilement (langage fonctionnel pur, runtime supportant les green-threads…).

    Au final, l'implémentation Haskell est assez similaire à l'implémentation Javascript. La principale différence est que Haskell fait du typage statique, ce qui allonge légèrement le code mais permet de détecter les erreurs de typage plus précocement.

    Génération de HTML Les générateurs de documents HTML

    C++ ne semble pas avoir d'outils de génération de documents HTML aussi aboutis que Lucid en Haskell. La bibliothèque CTML permet de définir la structure arborescente d'un document puis d'en générer le code HTML correspondant. Cependant, sa syntaxe est assez verbeuse et il n'y a pas de vérification des balises. Exemple d'utilisation (animals-cpprestsdk/src/View.cpp) :

    const string css = R"( body { background-color: azure; } ... )"; string renderHome(const string & myquery, const vector<Animal> & animals) { CTML::Document doc; doc.AddNodeToHead( CTML::Node("style", css)); doc.AddNodeToBody( CTML::Node("h1", "Animals (Cpprestsdk)")); doc.AddNodeToBody( CTML::Node("form") .AppendChild( CTML::Node("input") .UseClosingTag(false) .SetAttribute("type", "text") .SetAttribute("name", "myquery") .SetAttribute("value", myquery))); for (const Animal & animal : animals) doc.AddNodeToBody( CTML::Node("a.aCss") .SetAttribute("href", "static/"+animal.image) .AppendChild( CTML::Node("div.divCss") .AppendChild( CTML::Node("p", animal.name)) .AppendChild( CTML::Node("img.imgCss") .UseClosingTag(false) .SetAttribute("src", "static/"+animal.image)))); doc.AddNodeToBody( CTML::Node("p") .SetAttribute("style", "clear:both") .AppendChild( CTML::Node("a", "About") .SetAttribute("href", "/about"))); return doc.ToString(CTML::Readability::MULTILINE); } string renderAbout() { ... } Les systèmes de templating

    Ces systèmes consistent à écrire des templates paramétrables, c'est-à-dire du code HTML dans lequel on utilise des paramètres qui seront remplacés par les valeurs indiquées lors du rendu du template.

    Les frameworks MVC proposent généralement des systèmes de templating évolués, mais il existe également des outils indépendants, par exemple mustache. Mustache est un formalisme qui possède des implémentations dans de nombreux langages, dont plusieurs en C++. Par exemple, animal-pistache/src/View.cpp utilise l'implémentation kainjow mustache et le code suivant (animals-crow/src/View.cpp) l'implémentation du framework crow :

    const string css = ... string renderHome(const string & myquery, const vector<Animal> & animals) { // create the template const string homeTmpl = R"( <html> <head> <style> {{mycss}} </style> </head> <body> <h1>Animals (Crow)</h1> <form> <p> <input type="text" name="myquery" value="{{myquery}}"> </p> </form> {{#animals}} <a href="static/{{image}}"> <div class="divCss"> <p> {{name}} </p> <img class="imgCss" src="static/{{image}}" /> </div> </a> {{/animals}} <p style="clear: both"><a href="/about">About</a></p> </body> </html> )"; // create a context containing the data to use in the template crow::mustache::context ctx; ctx["mycss"] = css; ctx["myquery"] = myquery; for (unsigned i=0; i<animals.size(); i++) { ctx["animals"][i]["name"] = animals[i].name; ctx["animals"][i]["image"] = animals[i].image; } // render the template using the context return crow::mustache::template_t(homeTmpl).render(ctx); } string renderAbout() { ... } Génération « à la main »

    Il est également relativement simple de générer du code HTML manuellement, en utilisant les flux de chaines C++. Cependant cette méthode ne facilite pas la réutilisation de code ni la vérification du code HTML produit. Exemple de génération manuelle (animals-silicon/src/main.cpp) :

    string renderHome(const string & myquery, const vector<Animal> & animals) { // create a string stream ostringstream oss; // generate some HTML code, in the stream oss << R"( <html> <head> <link rel="stylesheet" type="text/css" href="mystatic/style.css"> </head> <body> <h1>Animals (Silicon)</h1> <form> <p> <input type="text" name="myquery" value=")" << myquery << R"("> </p> </form> )"; for (const Animal & a : animals) { oss << R"( <a href="mystatic/)" << a.image << R"("> <div class="divCss"> <p>)" << a.name << R"(</p> <img class="imgCss" src="mystatic/)" << a.image << R"(" /> </div> </a>)"; } oss << R"( <p style="clear: both"><a href="/about">About</a></p> </body> </html> )"; // return the resulting string return oss.str(); } string renderAbout() { ... } Accès à une base de données SQL Les connecteurs SQL

    Ils permettent de construire explicitement des requêtes SQL, de les envoyer au système de base de données et d'en récupérer le résultat. Les connecteurs SQL sont généralement faciles à utiliser (il suffit de connaitre le langage SQL) mais ils ne vérifient pas que les requêtes sont correctes.

    De nombreux frameworks proposent des connecteurs SQL. Par exemple, cppcms (voir animals-cppcms/src/Animal.cpp), tntnet (voir animals-tntnet/src/Animal.cc) et silicon (voir animals-silicon/src/main.cpp). Il existe également des connecteurs indépendants, par exemple sqlite_modern_cpp (voir animals-pistache/src/Animal.cpp) :

    #include "Animal.hpp" #include <sqlite_modern_cpp.h> using namespace sqlite; using namespace std; vector<Animal> getAnimals(const string & myquery) { vector<Animal> animals; try { // open database database db("animals.db"); // query database and process results db << "SELECT name,image FROM animals WHERE name LIKE ?||'%'" << myquery >> [&](string name, string image) { animals.push_back({name, image}); }; } catch (exception & e) { cerr << e.what() << endl; } return animals; } Les ORM

    Les ORM (Object-Relational Mapping) permettent de convertir des données d'une table SQL vers une classe C++, et réciproquement. Ceci permet d'utiliser la base de façon plus sûre, car les données sont vérifiées par le système de typage et vérifiées à la compilation puisque les requêtes sont réalisées par des fonctions C++. Cependant, un ORM définit sa propre couche d'abstraction équivalente au SQL, mais forcément moins connue.

    Il existe différents ORM C++, par exemple wt dbo (voir animals-wt/src/main.cpp), sqlpp11 (voir animals-crow/src/Animal.cpp), ou sqlite_orm (voir animals-cpprestsdk/src/Animal.cpp):

    #include "Animal.hpp" #include <sqlite_orm/sqlite_orm.h> using namespace std; using namespace sqlite_orm; vector<Animal> getAnimals(const string & myquery) { vector<Animal> animals; // open database and map the "animals" table to the "Animal" datatype auto storage = make_storage( "animals.db", make_table("animals", make_column("name", &Animal::name), make_column("image", &Animal::image))); // query database auto results = storage.get_all<Animal>(where(like(&Animal::name, myquery+"%"))); // process results for(auto & animal : results) animals.push_back(animal); return animals; }

    Suite en partie 2 (frameworks web), dans laquelle il sera question de micro-frameworks tels que Sinatra et Flask pour le Ruby et le Python, et de Crow et Silicon pour le C++.

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    L’édition 2018 de Rust est sortie !

    9 décembre, 2018 - 23:19

    L’édition 2018 du langage Rust est sortie. Cette dépêche est une traduction et un résumé de la documentation officielle.

    Certaines nouveautés ne sont pas si nouvelles, mais c’est toujours utile d’en parler si vous n’avez pas trop suivi l’évolution du langage depuis un an.

    Sommaire Édition ? Jamais entendu parler de ça Qu’est‐ce qu’une édition en Rust ?

    Il faut savoir qu’une nouvelle version de Rust sort toutes les six semaines. On peut donc vite être noyé dans les mises à jour et les nouveautés. Afin de pouvoir visualiser les nouveautés avec plus de recul, et surtout ajouter certains breaking changes, le langage a (et aura) une nouvelle édition tous les deux ou trois ans.

    La première édition était celle de 2015, qui regroupe la version 1.0 et une partie des mises à jour qui ont suivi. Cette version 2018 regroupe les dernières nouveautés, dont une partie n’est pas accessible dans l’édition 2015.

    Quid de la stabilité ?

    Entendre parler de breaking change peut faire peur, mais l’équipe de Rust a bien étudié son coup. L’unité de compilation en Rust est le crate (caisse en anglais) contrairement au C par exemple, où c’est le fichier. Chacun des crates d’un projet peut utiliser une édition différente du langage. On peut, par exemple, créer un nouveau crate 2015 et utiliser un crate 2018, qui utilise de nouveaux mots-clés sans problèmes.

    Le langage peut donc avoir des changements incompatibles sans que le code des utilisateurs n’en soit impacté.

    En revanche, la bibliothèque standard ne peut en aucun cas avoir de breaking changes, puisque si l’on change un type entre les éditions 2015 à 2018, par exemple, on ne peut plus passer une instance de ce type d’un crate à l’autre.

    Comment utiliser cette édition ?

    Dans les faits, cela signifie que :

    • si vous voulez créer un nouveau projet, la commande cargo new créera un nouveau projet directement avec l’édition 2018 ; concrètement, une nouvelle ligne est ajoutée dans le manifeste : edition = "2018" ;
    • si vous voulez mettre à jour un projet existant, il suffit de lancer la commande cargo fix --edition, ce qui va rendre les sources compatibles avec la dernière version.
    Quelles sont les nouveautés ?

    Venons‐en au fait : quoi de neuf ?

    Le système de modules Les chemins

    Le système de modules de la première édition était l’un des éléments difficiles à appréhender pour un débutant. Par exemple, selon qu’on utilisait un chemin dans une instruction use ou dans le code, ça pouvait compiler ou pas : le système de chemins pouvait sembler quelque peu incohérent. Dans l’édition 2018, tout est harmonisé : dans tous les cas, il faut utiliser crate comme racine du chemin pour se référer au module de base, et self pour le module courant. L’équipe de Rust est encore en débat pour savoir lequel des deux sera le comportement par défaut en cas de chemin relatif.

    Les dépendances externes

    La directive extern crate n’est plus nécessaire quand on veut utiliser une dépendance externe. Effectivement, ça faisait doublon puisque l’information est dans tous les cas dans le manifeste du projet Cargo.toml.

    Les macros

    Les macros, qu’elles soient procédurales ou non, ressemblent de plus en plus aux autres items du langage. On les importe maintenant dans le scope avec use, tout comme le reste : use mon::chemin::ma_macro;. Il y a encore du travail à faire sur les macros (hygiène, macros 2.0…), mais elles pourront bientôt s’utiliser à tout point de vue comme des fonctions.

    Quel fichier pour quel module

    Maintenant, quand on veut mettre un sous‐module dans un dossier, on n’a plus besoin du fichier mod.rs. Avant :

    | |- foo | |- mod.rs | |- autre_module.rs

    Après :

    | |- foo.rs |- foo | |- autre_module.rs

    Ça permet de ne pas avoir tout un tas de fichiers mod.rs ouverts en même temps dans un éditeur (c’est vrai qu’on s’y perdait vite dans les gros projets).

    De nouveaux types de modifieurs de visibilité

    On peut mettre tout un tas de paramètres au mot clef pub pour un comportement un peu similaire au mot-clef friend en C++ : pub(crate), pub(a::b::c), etc. Il y a plus de détails dans la documentation du langage.

    Directive use imbriquée

    L’utilisation de use est plus souple. On peut maintenant marquer :

    use std::{ fs::File, io::Read, path::{ Path, PathBuf } }; Système de trait

    Maintenant, il existe une syntaxe plus explicite et symétrique pour la répartition dynamique vs statique :

    // Géré à la compilation via monomorphisation : fn foo(it: impl Iterator<Item = i32>) { for i in it { // ... } } // Géré pendant le runtime : fn foo(it: Box<dyn Iterator<Item = i32>>) { for i in it { // ... } }

    La notation impl peut remplacer l’introduction d’un type générique (sauf dans les cas les plus complexes) en simplifiant la syntaxe. Ainsi, on aurait pu écrire :

    fn foo<T>(it: T) where T: Iterator<Item = i32> { for i in it { // ... } } Simplification concernant les types « lifetime » Lifetimes non lexicaux

    Il y aurait beaucoup à dire à ce sujet, mais le borrow‐checker (la partie du compilateur qui vérifie la sécurité du code) a été réimplémenté avec un algorithme différent. Il est maintenant plus souple, dans le sens ou il élimine plus de faux‐positifs. Le précédent borrow‐checker refusait certaines choses qui auraient dû être acceptées, par exemple :

    let mut v = vec![1, 2, 3]; v.push(v.len()) Pattern matching plus intelligent

    Le pattern matching n’oblige plus à faire des contorsions quand on met des références en correspondance. Par exemple, avant on devait écrire :

    let s: &Option<String> = &Some("hello".to_string()); match s { // On match s avec `&Some(_)` puisque s est une référence, // et pour la valeur interne on doit marquer `ref s` // puisqu'on ne peut pas déplacer le contenu d'une donnée // qui a été empruntée. &Some(ref s) => println!("s is: {}", s), _ => (), };

    En 2018, le code est plus simple, et plus intuitif :

    let s: &Option<String> = &Some("hello".to_string()); match s { // Le compilateur comprend qu'on veut récupérer une référence // sur la valeur interne. La référence est pour ainsi dire passée // de l'option à la valeur interne. Some(s) => println!("s is: {}", s), _ => (), }; Simplification dans l’écriture des « lifetimes » génériques

    Il s’agit d’un certain nombre de cas de figure où l’écriture était inutile, redondante, etc. En vrac :

    • tout comme les types de données, les types lifetime ont un identificateur anonyme '_ ; on l’utilise dans le cas d’un type avec un lifetime générique : Foo<'_> ;
    • plus besoin de spécifier le lifetime générique quand on implémente un trait pour une référence : impl Trait for &Foo { /* etc. */ } ;
    • plus besoin de spécifier l’interdépendance des types de données génériques avec les types lifetime génériques dans le cas d’une struct, par exemple : T: 'a.
    Autres

    Voici une liste de fonctionnalités plus complexes, et donc que je détaillerai moins :

    Notations pour le code asynchrone

    Il sera plus simple d’écrire du code asynchrone grâce aux mots‐clefs async et await. Cette fonctionnalité n’est pas encore stable, mais les mots‐clefs sont réservés pour l’édition 2018.

    SIMD, 128 bits

    Sont pris en charge officiellement les opérations SIMD et les types entiers sur 128 bits i128 et u128.

    Macros procédurales

    Tous les types de macros procédurales ont été stabilisés pour 2018 :

    • les instructions derive : #[derive(Foo)] ;
    • les attributs : #[foo(/* etc. */)] ;
    • les macros appelées comme des fonctions : foo!(/* etc. */).
    Zéro ou une occurrence dans les macros

    Maintenant, les mêmes répéteurs que pour les expressions rationnelles existent dans l’implémentation des macros :

    • * pour zéro répétition ou plus ;
    • + pour une répétition ou plus ;
    • ? pour zéro ou une occurrence.
    On peut faire du « pattern-matching » avec des slices fn main() { bonjour(&[]); // sortie : Eh, il n'y a personne ici. bonjour(&["Linus"]); // sortie : Coucou, Linus, j'ai l'impression que tu es tout seul. bonjour(&["Linus", "Richard"]); // sortie : Coucou, Linus et Richard. Content de voir que vous êtes au moins deux ! bonjour(&["Linus", "Richard", "Lennart"]); // sortie : Bonjour à tous, j'ai l'impression que nous sommes trois aujourd'hui. } fn bonjour(people: &[&str]) { match people { [] => println!("Eh, il n'y a personne ici."), [tout_seul] => println!("Coucou, {}, j'ai l'impression que tu es tout seul.", tout_seul), [premier, second] => println!("Coucou, {} et {}. \ Content de voir que vous êtes au moins 2 !", premier, second), _ => println!("Bonjour à tous, j'ai l'impression que nous sommes {} aujourd'hui.", people.len()), } } Conclusion

    Le langage a beaucoup avancé au cours des trois dernières années, avec de nouvelles fonctionnalités excitantes et des simplifications bienvenues. Je ne peux que vous conseiller de lire la documentation officielle à ce sujet.

    La communauté attend encore avec impatience bien d’autres choses (je vous invite à voir la liste des RFC pour vous faire une idée) et je suis convaincu que la prochaine édition sera tout aussi riche en nouveautés que celle‐ci.

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Nouvelles de Git : 2.20.0, Git Merge, etc.

    9 décembre, 2018 - 18:25

    La version 2.20.0 de Git, logiciel de gestion de versions décentralisé, vient tout juste d’être étiquetée par Junio Hamano, le mainteneur. Elle contient comme toujours un nombre important d’améliorations, même si elles ne sont pas forcément visibles par la plupart des utilisateurs (certaines nouveautés sont détaillées en seconde partie de la dépêche).

    Pour être tenu au courant de l’actualité Git, il y a Git Rev News, une lettre d’actus mensuelle qui contient pas mal d’infos en tout genre liées à Git (Git Rev News est éditée depuis presque quatre ans par un petit groupe de développeurs et de fans dont je fais partie).

    Il y a aussi prochainement la conférence Git Merge à Bruxelles le 1er février prochain, juste avant le FOSDEM (2 et 3 février). Oui, c’est au même endroit, appelé The EGG Brussels, que la Git Merge 2017 qui avait aussi lieu juste avant le FOSDEM. Comme d’habitude, le jour précédant la Git Merge proprement dite (donc le 31 janvier), des workshops sont proposés et, en parallèle, il y a un Git Contributor Summit auquel tous les développeurs de Git ou d’un logiciel lié à l’écosystème de Git sont invités.

    Revenons sur les nouveautés de la version 2.20.0. En particulier sur git rebase, qui est maintenant complètement (ou presque) réécrit en C (bien qu’il soit toujours possible d’utiliser l’ancienne version en configurant rebase.useBuiltin à false).

    Une autre amélioration, à laquelle j’ai aussi un peu participé, est un ensemble d’options de stockage appelé delta-islands initialement développé par GitHub il y a plusieurs années. Cela permet d’améliorer significativement les performances lorsque l’on stocke tous les divergences (forks) d’un dépôt (repo) dans le même dépôt sous‐jacent. GitLab travaille actuellement à cela en utilisant justement les delta-islands, suite à une demande de Drupal.

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Proxmox VE 5.3 vient avec CephFS

    9 décembre, 2018 - 10:32

    Proxmox Server Solutions GmbH, développeur de la plate‐forme de virtualisation libre Proxmox VE, a publié Proxmox VE 5.3. C’est une plate‐forme de gestion de virtualisation libre qui est basée sur Debian 9.6 et un noyau Linux 4.15 modifié. Elle permet de gérer des machines virtuelles KVM et des conteneurs LXC.

    La nouveauté importante concerne le système de fichiers CephFS. La suite de l’article en dit plus.

    CephFS dans l’interface Web

    Si vous faites une mise à jour depuis une version antérieure, CephFS est disponible après une éventuelle installation des paquets supplémentaires via la ligne de commande.

    CephFS est un système de fichiers distribué conforme à POSIX et construit sur la grappe de serveurs (cluster) Ceph. Comme Ceph RBD (Rados Block Device), qui est déjà intégré à Proxmox VE, CephFS sert maintenant d’interface alternative au stockage Ceph. Pour CephFS, Proxmox permet de stocker des fichiers de sauvegarde, des images ISO et des modèles de conteneur VZDump. Le système de fichiers distribué CephFS élimine le besoin de stockage de fichiers externe tel que NFS ou Samba, ce qui permet de réduire les coûts matériels et simplifie la gestion. Le système de fichiers CephFS peut être créé et configuré en quelques clics dans l’interface de gestion Proxmox VE.

    Gestion du stockage

    Deux nouveautés concernent la gestion du stockage :

    • via la gestion des disques, il est possible d’ajouter facilement des volumes RAID ZFS, des pools LVM et LVM en allocation fine et dynamique (thin‐provisioning), ainsi que des disques simples supplémentaires avec un système de fichiers traditionnel ;
    • le greffon de stockage ZFS sur iSCSI existant peut désormais accéder à la cible LIO du noyau Linux au lieu de l’ancien module IET.

    Virtualisation

    Au chapitre de la virtualisation, les nouveautés sont :

    • la « nested virtualisation » : l’imbrication est activée pour les conteneurs LXC, ce qui permet d’utiliser LXC ou LXD à l’intérieur d’un conteneur, ou de virtualiser à l’intérieur d’une machine virtuelle ;
    • l’accès aux serveurs NFS ou CIFS / Samba peut être configuré à l’intérieur de conteneurs ;
    • vGPU et PCI(-e) pass‐through : pour les utilisateurs aventureux, cette version apporte une configuration simplifiée, via l’interface graphique Web, des processeurs graphiques virtuels — vGPU —, tels que l’Intel KVMGT, et de l’accès direct au bus PCI par une machine virtuelle — PCI pass‐through.
    Proxmox ?

    Proxmox VE est sous licence GNU Affero GPL v3. Proxmox Server Solutions propose un support pour les entreprises à partir de 74,90 € par an et par processeur.

    Le projet open‐source Proxmox VE compte une vaste base d’utilisateurs dans le monde avec plus de 230 000 installations. L’interface de gestion Web est traduite en vingt langues. Plus de 40 000 membres sont actifs dans le forum de soutien communautaire. Plus de 13 000 clients de sociétés de toutes tailles, de tous secteurs et de toutes industries font confiance aux services de support Proxmox VE proposés par Proxmox Server Solutions GmbH.

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Agenda du Libre pour la semaine 50 de l’année 2018

    8 décembre, 2018 - 19:20

    Calendrier Web, regroupant des événements liés au Libre (logiciel, salon, atelier, install party, conférence), annoncés par leurs organisateurs. Voici un récapitulatif de la semaine à venir. Le détail de chacun de ces 45 événements (1 en Belgique, 42 en France, 0 au Luxembourg, 2 au Québec, 0 en Suisse et 0 en Tunisie) est en seconde partie de dépêche.

    Sommaire [FR Paris] Sécurité informatique à base d'outils libres (formation) - Du lundi 10 décembre 2018 à 09h30 au mardi 11 décembre 2018 à 18h00.

    Cette formation de 2 jours vous propose d'acquérir les connaissances nécessaires pour faire une analyse contextuelle et évolutive des niveaux de sécurité requis dans votre organisation afin de protéger vos communications.

    Nous procéderons à l'analyse de votre "modèle de menace", puis nous nous intéresserons aux données que vous produisez, stockez, diffusez. Enfin, nous nous pencherons sur les données sensibles concernant les publics et autres organisations avec lesquels vous coopérez. Vous serez formé·e·s à l'utilisation d'outils que vous pourrez mettre en place pour préserver la sécurité de vos communications et la vie privée des personnes avec lesquelles vous travaillez (Tor, VPN, Tails, PGP, etc.).

    Informations pratiques

    • Formateur Benjamin Cadon, du Labomedia (la page de leur wiki qui traite du sujet ici)
    • Tarifs (frais pédagogiques)

      • bénévoles des membres et relais Ritimo 40
      • bénévoles associatifs 60
      • bénéficiaires de la formation professionnelle 500
    • Inscription le formulaire ici https://ritimo.info/limesurvey/index.php/861785?lang=fr

    • Lieu CICP (21ter rue Voltaire, Paris XI)

    A propos des formations e-change

    Les formations et ateliers e-change ont été mis en place pour accompagner les associations à afin qu’elles s’approprient les outils numériques, pour leurs activités et faire émerger des projets associatifs d’éducation au numérique.
    C’est pourquoi Ritimo vous invite à participer à ces formations, ateliers et temps d’échanges, portant à la fois sur les dimensions techniques, la valorisation des contenus et les démarches liées aux logiciels libres.

    [FR Montpellier] Wikipermanence - Le lundi 10 décembre 2018 de 18h00 à 22h00.

    Une Wikipermanence est une rencontre physique entre des wikipédiens chevronnés et de nouveaux ou futurs wikipédiens qui souhaitent acquérir des connaissances et des conseils sur le fonctionnement de Wikipédia. Il ne s’agit pas d’une simple rencontre entre wikipédiens la Wikipermanence organisée par le groupe local de Montpellier est là pour répondre aux questions, permettre des démonstrations, offrir une aide aux premiers pas et permettre un suivi.

    Pour cette soirée, chacun amène ce qu’il veut à manger et à boire pour un repas partagé.

    Cette rencontre nous permettra d’aborder les sujets suivants

    Si vous avez des propositions, n’hésitez pas à compléter la page dédiée sur Wikipédia.

    N’hésitez pas à venir c’est sans inscription, et vous l’aurez deviné, libre et gratuit

    Wikipédia est une encyclopédie libre rédigée collaborativement par des milliers d’internautes. Mais, saviez-vous que vous pouviez y participer En apportant des connaissances, en créant ou améliorant des articles, en prenant des photos, ou simplement en corrigeant des fautes, vous pouvez contribuer à ce grand projet d’encyclopédie collaborative.

    Alors, venez participer aux rendez-vous des Wikipermanences de Montpellier qui auront lieu à l’Atelier de Pigistes, le deuxième lundi de chaque mois, de 18h00 à 22h00.

    Cet événement vous est proposé dans le cadre du partenariat qui lie le Club de la Presse, Wikimédia France et Montpel’libre.

    Tramway lignes 1 et 3, arrêts Port-Marianne et Rives du Lez
    GPS Latitude 43.603095 | Longitude 3.898166

    [FR Grenoble] Atelier – Des cartes interactives dans Wikipedia - Le lundi 10 décembre 2018 de 18h30 à 20h30.

    Les collectifs OpenStreetMap Grenoble et Wikimedia Grenoble organisent une soirée commune pour vous apprendre à intégrer des cartes interactives dans Wikipedia.

    Depuis peu, il est possible d’ajouter dans les articles Wikipedia des cartes interactives, de façon très simple pour les débutants, grâce au modèle “Carte interactive”. Il est également possible, pour les plus aguerris, d’exploiter des informations issues de Wikidata et de Commons pour insérer des visualisations cartographiques riches.

    Le tout repose sur OpenStreetMap pour les fonds de carte et les bibliothèques de base.

    Programme

    • Présentation des outils disponibles,
    • Initiation des débutants & mise en pratique.

    **Niveau: Une connaissance basique du wikicode est utile mais pas indispensable.

    Je m'inscris

    [FR Rennes] Réunion mensuelle OpenStreetMap - Le lundi 10 décembre 2018 de 19h00 à 21h00.

    Les contributeurs OSM 35 proposent chaque 2e lundi du mois une réunion autour du projet de cartographie collaborative OpenStreetMap.

    L'occasion de découvrir le projet, de venir échanger sur les nouveautés, de partager vos initiatives.

    Plus d'informations sur la communauté locale

    [FR Lyon] Debian Monter un serveur de fichiers… Entre autres - Le lundi 10 décembre 2018 de 19h30 à 21h30.

    *Atelier
    *

    Dans cette nouvelle déclinaison des Lundi Debian & Cie, l'ALDIL vous propose d'installer un serveur avec GNU/Linux Debian sur 8 séances.

    • Les premières séances seront dédiées à l'installation du serveur, à la gestion de la configuration avec Ansible et à la mise en place de sauvegardes (avec rsnapshot et/ou borgbackup).
      ^

    • Puis nous mettrons en place un annuaire LDAP avec Fusion Directory et un serveur de fichiers avec NFS et/ou Samba.
      ^

    • Pour les survivants, création d'un proxy pour la mise à jour des machines clientes (apt-cacher-ng) et pourquoi pas un peu de DNS en dessert.

     ou sans allergie au Doliprane. Entrée libre et gratuite dans la limite des places disponibles.

    Le deuxième lundi du mois, d'octobre à mai.

    [FR Saint-Étienne] Permanence du libre - Le lundi 10 décembre 2018 de 19h30 à 22h00.

    Tous les lundis soir à partir de 19h30

    Rencontrer les bénévoles, passer sous GNU/Linux, poser des questions sur le libre, les logiciels, l'hébergement…

    Pour passer votre ordinateur sous GNU/linux, nous vous invitons à nous prévenir avant votre passage)

    [FR Paris] Atelier Hebdomadaire de Contribution au Libre - Le mardi 11 décembre 2018 de 10h00 à 19h00.

    Une journée de co-travail sur le thème de la contribution au logiciel libre.

    Chacun vient avec son sujet individuel avec l'intention d'y travailler au cotés d'autres contributrices/teurs.

    Le prix d'entrée est de 25 euros pour la journée (tarif Narma).

    [CA-QC Montréal] Ville de Montréal & Logiciels Libres quelles opportunités pour les entreprises - Le mardi 11 décembre 2018 de 13h30 à 18h00.

    Monsieur Ferron présentera la politique du logiciel libre de la Ville de Montréal, les retombées qu'aura cette politique sur le développement des entreprises du Québec, ainsi que sur les initiatives se basant sur cette politique dans les autres paliers gouvernementaux.

    Vous êtes une entreprise dans le service-conseils TI ou dans le développement de logiciels et de matériels libres Ne manquez pas cette occasion de découvrir les opportunités de contrat qu'offrira cette politique de la Ville de Montréal.

    Mr Pierre-Antoine Ferron est chargé d'expertise et de pratique (Gouvernance TI et partenariats) au Cabinet du directeur - Service des technologies de l'information.

    Lieu Centre culturel de la Petite Italie Casa d'Italia (M° Jean Talon | Sortie rue Berri)

    [FR Tours] Permanence ADeTI - Le mardi 11 décembre 2018 de 18h30 à 20h30.

    La permanence d'ADeTI est un moment d'accueil avec des bénévoles pour apprendre à utiliser un ordinateur sous GNU/Linux (Ubuntu, Linux Mint, Debian, …)  mais aussi

    • réparer les problèmes de logiciels sur son ordinateur
    • prendre des conseils pour choisir des logiciels alternatifs
    • différencier les logiciels libres utilisables pour répondre aux besoins
    • préserver et réfléchir sur ses usages (vie privée, éthique, …)

    Mais c'est aussi un moment consacré pour

    • partager des connaissances et échanger des savoirs
    • maîtriser les formats ouverts et la pérennité de ses documents
    • Confidentialité, intégrité et disponibilité des systèmes d'information
    • Diversité des alternatives
    • Indépendance

    Nous accueillons également des membres de l'association Touraine Data Network qui peuvent répondre aux questions concernant les réseaux connexion à Internet, alternatives aux "Box" et aux opérateurs commerciaux.

    [FR Lyon] Rencontre wikimédienne - Le mardi 11 décembre 2018 de 18h30 à 20h00.

    Rencontre mensuelle de la cabale de la quenelle (groupe wikimédien lyonnais).

    Discussion des projets et collaborations en cours ou à venir autour d’une boisson.

    Rejoignez nous

    [FR Paris] Résister à la publicité et à la surveillance publicitaire en ligne - Le mardi 11 décembre 2018 de 19h00 à 21h30.

    Cette soirée est organisée par les associations La Quadrature du Net et Résistance à l'agression publicitaire dans le cadre notamment de leurs campagnes de dons respectives https://don.laquadrature.net et https://soutenir.antipub.org/.

    Sur Internet comme dans l'espace public et ailleurs, la publicité nous manipule, elle s'attaque à notre "temps de cerveau disponible" pour nous pousser à consommer, créer de nouvelles envies, à nous conformer à un pseudo-idéal publicitaire, à influer nos comportements, etc.

    Malheureusement, la publicité s'est imposée comme "le pêché originel d'Internet" et demeure le principal mode de financement de nombreux services et productions de contenus en ligne. Le seul affichage publicitaire "classique" a posé problème et n'a pas suffit au système publicitaire. Des sociétés, notamment Google, Facebook ou encore Criteo, ont développées des outils de surveillance très poussés pour traquer et profiler les personnes dans tous les recoins de leurs pratiques numériques  pour leur afficher des publicités toujours plus "ciblées" pour quelles soient le plus efficaces possibles en clair quelles manipulent au mieux les personnes.

    Il existe par ailleurs des pratiques et une volonté non dissimulée pour importer cette surveillance et ces publicités ciblées dans l'espace public par le biais des panneaux numériques et autres outils similaires.

    Ces outils de surveillance sont, de plus, dévoyés de leurs premières fins lucratives et sont convoités par les gouvernements, comme ont pu en témoigner les révélations Snowden, mais aussi par les acteurs politiques qui les utilisent à des fins de propagande électorale.

    Les enjeux sont conséquents en termes de libertés et il est plus que temps de résister à ces agressions. Cette intervention de La Quadrature du Net et de Résistance à l'Agression Publicitaire permettra d'éclairer le fonctionnement des mécanismes publicitaires en ligne et d'expliquer comment y résister à l'échelle individuelle, collective et politique. Une mise en pratique directe sera même proposée l'intervention étant suivie d'un petit atelier.

    [FR Grenoble] Meetup Python et C++ - Le mardi 11 décembre 2018 de 19h00 à 21h00.

    Le groupe d’utilisateurs de Python de Grenoble se réunit mardi 11 décembre, à 19h à La Coop pour discuter de technologie développeurs.

    Ce meetup est ouvert à tous et gratuit

     Je m’inscris

    Ce mardi, Gilles Chaley, Architecte informatique chez Atos, expliquera le fonctionnement de pybind11, un framework pour exposer des types C++ en Python, une alternative à Boost.

    [FR Paris] Résister à la publicité et à la surveillance publicitaire sur Internet - Le mardi 11 décembre 2018 de 19h15 à 22h00.

    Mardi 11 Décembre 19h15  Débat et discussion avec La Quadrature du Net et Résistance à l'Agression Publicitaire : Résister à la publicité et à la surveillance publicitaire sur Internet

    La publicité finance de nombreux services en ligne donnant l'apparence du "gratuit", mais est en fait un coût indirect et s'attaque à notre "temps de cerveau disponible" pour influer sur nos comportements.

    Elle s'allie à des outils de surveillance de masse qui nous traquent, nous profilent pour mieux nous "cibler". Développés par Google, Facebook, Criteo… ces outils ont aussi bien des visées économiques que politiques.
    Les enjeux sont conséquents en termes de libertés il est plus que temps de résister à ces agressions.

    Un débat pour éclairer les mécanismes publicitaires en ligne et y résister à l'échelle individuelle, collective et politique.

    21h Repas.

    Café La Commune 3 rue d'Aligre Paris 12 ème

    [FR Quetigny] Permanence logiciels libres - Le mardi 11 décembre 2018 de 20h30 à 23h30.

    COAGUL est une association d'utilisateurs de logiciels libres et de GNU Linux en particulier.

    Nous utilisons toutes sortes de distributions GNU / Linux (Ubuntu, CentOs, Fedora, Debian, Arch…) et toutes sortes de logiciels pourvu qu'ils soient libres (VLC, LibreOffice, Firefox, Thunderbird, GPG, Tor, OpenNebula, LXC, Apache…).

    Les permanences servent à se rencontrer et à partager nos expériences et notre savoir sur des logiciels libres.

    Vous pouvez venir sans contrepartie pour découvrir, tester, installer Linux et d'autres logiciels libre.

    Nous offrons également de l'assistance pour des difficultés sur l'usage d'un logiciel libre en particulier.

    Venez nombreuses et nombreux

    [FR Le Mans] Permanence du mercredi - Le mercredi 12 décembre 2018 de 12h00 à 17h00.

    Assistance technique et démonstration concernant les logiciels libres.

    [FR Caen] Permanence artifaille - Le mercredi 12 décembre 2018 de 16h00 à 19h00.

    Permanence et animation au local Artifaille pour les membres de l'association.

    Entraide informatique pour réparer, reconfigurer, conseiller, échanger à propos des moyens de communication électronique

    mise à disposition de moyens et outils spécifiques,
    conseils d'un professionnel expert en logiciels libres

    Vérifier le maintien de la permanence et inscription (10 places) :
    https://artifaille.fr/attendee/

    [FR Beauvais] Atelier hebdomadaire de partage de connaissances autour des logiciels libres - Le mercredi 12 décembre 2018 de 18h00 à 20h00.

    Chaque mercredi soir, l'association propose une rencontre pour partager des connaissances, des savoir-faire, des questions autour de l'utilisation des logiciels libres, que ce soit à propos du système d'exploitation Linux, des applications libres ou des services en ligne libres.

    C'est l'occasion aussi de mettre en avant l'action des associations fédératrices telles que l'April ou Framasoft, dont nous sommes adhérents et dont nous soutenons les initiatives avec grande reconnaissance.

    L'atelier a lieu dans la salle informatique du Centre Georges Desmarquet géré par l'association Voisinlieu-pour-tous.

    [FR Lille] Cours Linux - Le mercredi 12 décembre 2018 de 18h00 à 20h00.

    Découvrez LINUX

    Une solution économique et écologique

    Un système puissant, stable, léger, sans virus et totalement gratuit.

    Accédez à des milliers de logiciels libres (Firefox, Thunderbird, LibreOffice, Gimp, 7Zip, VLC, Sunbird, Apache, etc).

    Il permet également de récupérer d'anciennes machines.

    Découvrir les logiciels libres, cours ou installations niveau débutant tous les mercredis de 18h à 20h à partir du début octobre jusqu’a fin juin dans les locaux de l'association UFJ rue du Mal Assis à Lille (03 20 57 27 11)

    [FR Paris] Soirée littéraire le futur d'Internet - Le mercredi 12 décembre 2018 de 19h30 à 22h00.

    Dans le cadre de la campagne annuelle de soutien de La Quadrature du Net, venez discuter du futur d'Internet avec les Editions La Volte et les autrices de science-fiction Sabrina Calvo et Ketty Steward.

    [FR Toulouse] Rencontres Tetalab - Le mercredi 12 décembre 2018 de 20h30 à 23h30.

    Rencontre hebdomadaire des hackers et artistes libristes Toulousains.

    Ouvert au public tous les mercredi soir.

    Venez nombreux.

    [FR Mauguio] Les jeudis du Libre à la CCI - Le jeudi 13 décembre 2018 de 14h00 à 17h00.

    Tous les deuxièmes jeudis de chaque mois, Montpel’libre tiendra une permanence à la CCI Hérault pour fournir un appui au libre à toutes les entreprises et indépendants désireux en savoir plus sur les Logiciels Libres, répertorier avec des rendez-vous, un prestataire local sur le sujet, enfin, utiliser aussi ce créneau pour des ateliers thématiques sur lesquels nous communiquerons.

    Entrée libre et gratuite sur inscription. Une simple adhésion à l’association est possible.

    Cet événement vous est proposé dans le cadre du partenariat qui lie la CCI Hérault et Montpel’libre.

    Tramway lignes 1 et 4, arrêt Place de l’Europe puis Bus Hérault Transport Navette aéroport Ligne 120 Navette Aéroport arrêt ESMA - CCI
    GPS Latitude 43.57869 | Longitude 3.95097
    Carte OpenStreetMap

    [FR Nîmes] Rencontre Gnu/Linux et les Logiciels libres - Le jeudi 13 décembre 2018 de 18h00 à 22h00.

    C'est une soirée rencontre autour de GNU/Linux et des Logiciels Libres.

    Nous sommes le 2° jeudi du mois, donc nous nous réunissons à Nîmes. Le 4° c'est à Vergèze.

    Gard-Linux, groupe d'utilisateurs de GNU/Linux et des logiciels libres est là pour vous accompagner

    Il y aura sans-doute de la "mécanique", genre robotique ou réparation de PC…

    Il y aura trois Ateliers spécifiques

    "Mon serveur Web sur un Raspberry Pi"
    "Installation d'Ubuntu Studio 18.04"
    Découverte des possibilités d'Ubuntu Studio 18.04"

    Nous comptons sur vous

    Allez voir notre site www.gard-linux.fr

    Ce jour atelier non renseigné pour le moment.

    PS Êtes-vous intéressé par UNE REUNION SUR ALES, SUR UZES Vous pouvez mettre vos commentaires ou nous contacter par courriel.

    [FR Bordeaux] Jeudi Giroll - Le jeudi 13 décembre 2018 de 18h30 à 20h30.

    Les membres du collectif Giroll, GIROnde Logiciels Libres, se retrouvent une fois par semaine, pour partager leurs  savoir-faire et expériences autour des logiciels libres.

    Le collectif réalise aussi une webradio mensuelle, tous les second jeudis du mois, à retrouver en direct sur le site de Giroll.

    Ces rencontres sont ouvertes à tous.

    Attention pour la radio, le second jeudi du mois nous sommes désormais à la Mezzanine le local de nos amis d'Aquilenet

    [FR Brest] Mapathon OpenStreetMap - Le jeudi 13 décembre 2018 de 18h30 à 21h30.

    Venez nous aider à cartographier les espaces de Madagascar sur OpenStreetMap, la carte du monde collaborative et libre Inscriptions souhaitables https://www.eventbrite.ca/e/billets-mapathon-a-brest-ubo-open-factory-52931082292CartONG organise un mapathon centré sur Madagascar avec l'UBO Open Factory et Tiriad et les groupes locaux.

    Vous pourrez découvrir la cartographie participative et humanitaire dans OpenStreetMap pas besoin d'être un expert, c'est accessible à tout le monde

    Comme nous aimons lier l'utile à l'agréable, nous vous proposons de partager un repas commun qui sera lui aussi contributif et collaboratif l'idée étant que chacun ramène un plat à partager avec tout le monde

    Le programme de la soirée

    Nous vous proposons de découvrir comment contribuer à OpenStreetMap durant un mapathon et cartographier des espaces de Madagascar qui ne le sont pas encore.

    Cet événement a pour but d’ajouter des informations comme des bâtiments, et les routes, des cours d'eau.

    Les cartes qui seront produites grâce à vos contributions permettrons de soutenir divers projets de prévention des risques d'inondations, mais aussi de promouvoir le tourisme et le développement économique de ces régions

    Au programme

    • 18h30 accueil des participants
    • 18h40 Mots de bienvenue, présentation du projet Missing Maps et du déroulement de la soirée
    • 18h50 Présentation de la contribution dans OpenStreetMap
    • 19h00 Cartographions
    • 20h00 Dégustation de nos bons petits plats (miam)
    • 21h30 - 22h Fin du mapathon, conclusion sur les contributions de la soirée

    Où ?

    UBO OpenFactory Faculté des sciences et techniques Bat D, salle D133, 6 avenue Le Gorgeu 29238 Brest

    Un grand merci à l'UBO Open Factory pour l'accueil et leur soutien

    Entrée gratuite sur inscription.

    Venez nombreux, et n'oubliez pas d'apporter votre ordinateur portable, et souri(re)s

    [FR Lyon] Jeudi jeux vidéo - Le jeudi 13 décembre 2018 de 19h00 à 21h00.

    Initiez-vous au 10ème art la création de jeux vidéo.

    – de 19h à 21h  –

    À partir de 16 ans

    Attention la présence à l'ensemble des dates du cycle est requise.

    Jeudi 18 octobre 2018 AnimationAvec l’association Game Dev Party, découverte des bases de la création de jeux vidéo avec Unity3D game design, intégration de graphismes et de sons, animations, interactions. Une forte motivation à créer des jeux vidéo est requise.

    Venez nombreux

    [FR Paris] Soirée de Contribution au Libre, invité Wikimedia France - Le jeudi 13 décembre 2018 de 19h30 à 22h00.

    Parinux propose aux utilisateurs de logiciels libres de se réunir régulièrement afin de contribuer à des projets libres. En effet, un logiciel libre est souvent porté par une communauté de bénévoles et dépend d'eux pour que le logiciel évolue.

    Nous nous réunissons donc tous les dans un environnement propice au travail (pas de facebook, pas de télé, pas de jeux vidéos, pas de zombies).

    Vous aurez très probablement besoin d'un ordinateur portable, mais électricité et réseau fournis.

    En cas de difficulté, vous pouvez joindre un des responsables de la soirée, Emmanuel Seyman (emmanuel (at) seyman.fr), Paul Marques Mota mota (at) parinux.org, ou Magali Garnero (Bookynette) tresorier (at) parinux.org.

    Pour obtenir le code d'entrée de la porte cochère, envoyez un mail au responsable.

    On peut amener de quoi se restaurer (Franprix, 8 rue du Chemin Vert, ferme à 22h)

    Regazouillez sur Twitter - Wiki des soirées

    Programme non exhaustif

    • Fedora (sa traduction)
    • Parinux, ses bugs et son infrastructure
    • April, … y a toujours quelque chose à faire
    • Open Food Facts/ Open Beauty Facts, sa base de données, ses contributeurs, sa roadmap
    • Schema racktables, son code
    • Agenda du Libre, mise à jour et amélioration du code
    • Ubuntu-Fr, son orga, ses événements
    • En vente libre, maintenance et commandes
    • Open street map, une fois par mois
    • Linux-Fr sait faire
    • en vente libre

    tout nouveau projet est le bienvenu.

    Tous les 1ers jeudis => Les associations Ubuntu-fr  et ouvre-boite organisent une réunion pour leurs membres.

    Tous les 2è jeudis du mois, l'association Wikimedia France propose de contribuer à ses multiples projets

    Tous les jeudis, dès 18h45, le groupe de travail Sensibilisation de l'April se réunit pour réfléchir à mieux communiquer vers le grand public et à 20h30, le groupe transcriptions prend le relais et transcrit ou relit des transcriptions.

    Tous les jeudis, des membres de Framasoft organisent des contrib'atliers et vous invitent à venir participer, tester ou améliorer des logiciels libres

    [FR Jupilles] Atelier échange de savoirs autour de Mageia (linux local) - Le jeudi 13 décembre 2018 de 19h30 à 23h45.

    Echange de savoir sur tous les sujets tournants autour du système d'exploitation Mageia support , version ß test, contribution, traduction…

    Ouvert à tous, curieux, débutants, utilisateurs.

    Installation possible du système sur votre ordinateur portable ou fixe. Pour un ordinateur fixe, classique n'apportez que la tour.

    [CA-QC Coteau du Lac] Émission #163 de bloguelinux - Le jeudi 13 décembre 2018 de 20h00 à 21h00.

    bloguelinux.ca est un blogue québécois offrant la diffusion d'un podcast qui traite des logiciels libres, du système d'exploitation Linux et de la technologie en général il y a un processeur, il y a un système d'exploitation, c'est certain que ça nous intéresse

    bloguelinux.ca est enregistré le jeudi à 20h00 toutes les deux semaines.

    Vous pouvez nous écouter en direct lors des enregistrements à l'adresse http://live.bloguelinux.ca ou directement sur notre site à http://www.bloguelinux.ca en cliquant sur la radio dans le panneau de gauche du site.

    Vous pouvez rejoindre nos conversations avec Telegram en vous abonnant au groupe BlogueLinux en suivant le lien suivant https://t.me/joinchat/ArPfnFAOS1OB0u7pwZFQHA et dans notre salle de chat en vous connectant sur les serveurs de freenode.net dans la salle #bloguelinux.

    Si vous n'avez pas de client IRC, vous pouvez utiliser l'adresse http://webchat.freenode.net

    AVERTISSEMENT Ce podcast peut contenir du langage inapproprié ou vulgaire et peut ne pas convenir à tout le monde.

    Animateurs Patrick et Sandrine

    [FR Montpellier] Inclusion Numérique - Le vendredi 14 décembre 2018 de 14h00 à 20h00.

    Nous initions et formons aux outils et usages numériques tous les publics qui s’en sentent éloignés, voire exclus.

    Dans les années à venir le tout numérique va s’accélérer dans nos démarches quotidiennes accès aux soins, à l’emploi, à l’énergie, au services bancaires, caisses de retraite, loisirs, etc.
    Une grande partie de la population n’a pas jugé utile ou eut l’opportunité d’utiliser des outils numériques, ordinateurs fixes, portables, les smartphones ou les tablettes.

    Nous considérons que l’inclusion numérique est fondamentale pour réduire la fracture
    numérique, encore bien réelle, entre les générations et réduire les inégalités sociales, culturelles, d’accès à l’emploi.
    Dans un monde ultra-connecté avoir des connaissances numériques de base est devenu indispensable quelque soit son âge.

    Nous animons avec bienveillance des ateliers collectifs d’initiation et de pratique des logiciels et des outils numériques libres, en fonction de la demande des utilisateurs.

    Les thématiques que nous vous proposerons

    • Ranger et m’organiser
    • Entretenir son ordinateur
    • Utiliser une clé USB, un disque dur externe
    • Insérer une image
    • Mettre en page un courrier
    • Créer un tableau simple
    • Débuter sur la mise en forme
    • Progresser sur la mise en forme de textes
    • Classer ses recherches
    • Protéger son identité sur l’Internet
    • Tchatter avec une webcam
    • Utiliser les services administratifs en ligne
    • Débuter sur Internet et la messagerie
    • Le podcasting
    • Transférer et enregistrer sa musique
    • Remplir sa déclaration d’impôts
    • Faire des rencontres
    • Stockez ses données en ligne
    • Vendre, acheter, donner ses objets
    • Préparer ses vacances
    • Débuter sur la messagerie
    • Découvrir les réseaux sociaux
    • Faire des économies grâce à Internet
    • Utiliser les sites / applications pour communiquer
    • Débuter avec son téléphone portable
    • Transférer les photos de son téléphone
    • Utiliser les applications de sa tablette, son téléphone
    • Débuter sur sa tablette, son téléphone
    • Transférer et classer ses photos
    • Créer son livre photo
    • Réaliser un diaporama de photos
    • Le photomontage

    • Mpt Albert Camus, avenue de Villeneuve Angoulême, Montpellier, Occitanie, France

    • Adresse web http://montpel-libre.fr

    • Tags
      formation, logiciels-libres, atellibre, montpel-libre

    [FR Caen] Permanence artifaille - Le vendredi 14 décembre 2018 de 16h00 à 19h00.

    Permanence et animation au local Artifaille pour les membres de l'association.

    Entraide informatique pour réparer, reconfigurer, conseiller, échanger à propos des moyens de communication électronique

    mise à disposition de moyens et outils spécifiques,
    conseils d'un professionnel expert en logiciels libres

    Vérifier le maintien de la permanence et inscription (10 places) :
    https://artifaille.fr/attendee/

    [FR Strasbourg] Apéro Accueil ARN - Le vendredi 14 décembre 2018 de 18h00 à 22h00.

    Rencontrez l’association Alsace Réseau Neutre et participez à la construction d’un Internet éthique

    ARN est un Fournisseur d’Accès à Internet associatif proposant diverses façons d’utiliser et de construire Internet autrement.

    Lors de ces réunions

    • nous évoquons les sujets actuels relatifs à l’association et au numérique en Alsace
    • nous faisons le point tous.tes ensemble sur l’avancée des projets de l’association et des projets associatifs environnants
    • nous profitons de ces instants pour faire avancer les projets de l’association sous forme de groupes de travail ouverts.

    Venez échanger avec nous

    Merci de vous inscrire (sous pseudo) ici (non-obligatoire) :
    https://framaforms.org/participer-a-un-evenement-coanime-par-arn-1529493317

    [FR Vandœuvre-lès-Nancy] La Fabrique Collective de la Culture du Libre - Le vendredi 14 décembre 2018 de 18h00 à 19h00.

    La Fabrique Collective de la Culture du Libre (FCCL) c’est

    • Une philosophie qui défend l’idée que le savoir, les œuvres de l’esprit sont un bien commun qui doit être partagé librement sous la forme de savoir-faire, savoir-être, savoir-vivre, savoir théorique.
    • Une mise en pratique ouverte à tous publics, espace de formation à la création et l’utilisation d’outils liés aux médias numériques.
    • La FCCL prône l’usage des logiciels libres dont les valeurs sont communes.

    Ses objectifs se déclinent en cinq grands thèmes

    • TECHNIQUE

      • Mise à disposition des moyens et des lieux de connaissances pour s’approprier les outils numériques et se former à l’utilisation de systèmes et de logiciels libres.
      • Mise en place des bonnes méthodes et attitudes afin de garantir la vie privée et d’empêcher l’appropriation des données personnelles par des tiers non autorisés.
    • CITOYENNETÉ

      • Proposer des outils pour s’approprier les données publiques, permettre à chacun de participer à la création de nouvelles données (open data).
      • Devenir force de proposition pour l’amélioration de la e-administration locale.
    • CULTURE

      • Favoriser la consultation, la diffusion, la création d’œuvres dans tout l’espace urbain.
    • ÉCONOMIE

      • Contribuer à la création d’opportunités professionnelles.
      • Rapprocher les acteurs de l’économie locale grâce à la formation et l’attractivité d’une ville tournée vers le numérique.
    • RECHERCHE

      • Ouvrir les ateliers à la création, la recherche et l’innovation dans les domaines de la culture, du numérique et de la pédagogie.
      • Être vecteur de réussite dans les projets scolaires.

    Rendez-vous à 18 h à la Médiathèque Jules Verne

    La commune vous propose de devenir partenaire de la FCCL en participant à L’ASSEMBLÉE CONVIVIALE DE LA FABRIQUE à 19 h, carrefour où seront abordés les orientations, les projets et leurs évolutions

    [FR Saint-Nazaire] Apéro Monnaie Libre - Le vendredi 14 décembre 2018 de 19h30 à 22h30.

    Dernier Apéro Monnaie Libre de l'année

    Mais c’est quoi les Apéro Monnaie Libre

    Les Apéros Monnaie Libre sont l’occasion de nous rencontrer entre membres et futurs membres de la monnaie libre Ğ1. Que vous soyez totalement débutant ou utilisateur confirmé, tout le monde est bienvenue aux apéros monnaie libre

    • Question/Réponse, de ce qu’est la Monnaie Libre Ḡ1.
    • Assistance création/utilisation de porte-feuille Ğ1 sous Césium.

    Mais c’est quoi la Ğ1

    C’est le nom de la 1ère et seule monnaie libre existante à ce jour, une monnaie co-créée par tous les humains qui l’utilisent, c’est un revenu de base par création monétaire.

    Plus de détail en suivant le "Guide du débutant" :

    https://forum.monnaie-libre.fr/t/intro-guide-du-debutant-en-monnaie-libre-gi-june/2777/

    Si vous souhaitez de l’assistance pour créer ou utiliser votre compte Ğ1, nous vous recommandons d’apporter votre appareil (téléphone, tablette, pc portable).

    Ces apéros sont aussi un moment privilégié pour demander ou proposer des biens et services en Ğ1.

    [FR Orléans] Réunion mensuelle - Le vendredi 14 décembre 2018 de 20h30 à 23h00.

    La prochaine réunion de l'association aura lieu le vendredi 18 mai à partir de 20h30 à la salle des 

    (2 rue Edouard Branly à Orléans-la-Source)

    Au programme de ce vendredi

    • Les commandes Linux de base
    • Personnaliser son environnement de bureau

    Pour venir nous voir Plan d'accés

    Venez nombreux et parlez-en autour de vous car les réunions de l'association sont aussi ouvertes aux non adhérents.

    [FR Beauvais] Samedi du Libre sur la messagerie - Le samedi 15 décembre 2018 de 09h00 à 12h00.

    Formation et partage de connaissance sur les points suivants 

    • Paramètres de base destinataires, objet, corps du message, pièce jointe 
    • Préférences personnelles
    • Règles de tri
    • Import/export du carnet d'adresses
    • Chiffrement des messages

    • Espace Argentine, 11 rue du Morvan, Beauvais, Hauts-de-France, France

    • Adresse web https://oisux.org

    • Tags
      linux, logiciels-libres, messagerie, mails, thunderbird, oisux

    [FR Biot] JM2L ~ 0x0b *** Annulation *** - Le samedi 15 décembre 2018 de 10h00 à 19h00.

    *** Annulation *** JM2L 2018 édition 0x0b

    Merci aux personnes qui ont eu la gentillesse de répondre favorablement

    à notre invitation.

    Ce n'est pas de gaieté de cœur que nous devons annuler les Journées

    Méditerranéennes des Logiciels Libres [JM2L] du samedi 15 décembre 2018,

    faute d'intervenants en nombre suffisant (même pas 10 inscrits, tous

    publics confondus) pour justifier les dépenses et motiver les bénévoles.

    Oyez… oyez, c'est la fête

    Relayez l'invitation au luxe de découvrir les projets, de rencontrer les passionnés des logiciels libres sous le ciel azuréen des Journées Méditerranéennes des Logiciels Libres [JM2L].

    Qui

    Vous, nous, la foule des visiteurs geeks, barbus ou princesses "auxpetits pois", soyez les bienvenus \o/

    Quoi

    Ateliers, stands, conférences, tables rondes, débats dans les escaliers ou sur les pelouses, à vous de décider

    Quand

    Samedi 15 décembre 2018 de 10 à 19 heures.

    Combien

    Comme toujours, entrée libre et gratuite, cela ne coûte pas un sou.

    Où ?

    École Polytech’Nice-Sophia, 930, route des Colles (site des Templiers)
    Biot - Sophia Antipolis - GPS Lat.: 43°61'56.9"N - Lon.: 7°0'71.95"E.

    Qu'est-ce qu'on mange

    Sur place pour les déjeuners et dans les restaurants à 2 petits pas pour les dîners.

    Staff

    Plein de gentils bénévoles du jour, souriants, détendus et accueillants.

    Inscrivez-vous, invitez vos amis et relations, chassez les trésors de conférenciers, meneurs d'ateliers et d'install-parties, standistes, covoitureurs, hébergeurs…
    +33 (0) 6 52 42 31 37 (oui, avec un 42 très chic et un L33T en vrac dedans pour faire encore plus geek).

    Vraiment, Linux C'est le luxe

    Salutations ensoleillées,

    [BE Liege] Café Crypté - ateliers d'autodéfense numérique - Le samedi 15 décembre 2018 de 13h30 à 17h30.

    Le Café crypté est un moment qui existe dans le but de comprendre et d'analyser les dangers du profilage commercial et de la surveillance généralisée sur internet et donc le droit à la vie privée.

    Mais aussi, le café crypté existe afin de partager, utiliser et créer collectivement des moyens de préserver nos libertés.

    Le Café crypté est ouvert à toutes et tous, militant.e.s ou non militant.e.s, quelles que soient les compétences informatiques de chacune et chacun. Il est, par contre, préférable de venir avec son ordinateur portable, smartphone ou tablette.

    Cet espace peut aussi servir pour vous installer un linux ou tester des OS libres.

    Les ateliers commencent à 13h30 et se terminent à 17h30, une discussion collective autour d'une thématique en particulier alimentera le début de l'atelier.

    Ateliers limités à 20 personnes, venez quand vous voulez, l'espace est ouvert.

    Informations alexandre@barricade.be

    [FR Marseille] Install Party GNU/Linux - Le samedi 15 décembre 2018 de 14h00 à 19h00.

    L’association CercLL (CercLL d’Entraide et Réseau Coopératif autour des Logiciels Libres) vous invite à une install party GNU/Linux, le samedi 15 décembre 2018 de 14h00 à 19h00, dans la salle du Foyer du Peuple 50 rue Brandis 13005 Marseille.

    Vous avez envie de découvrir un système d’exploitation libre, simple d’utilisation, stable, rapide et sécurisé. Une nouvelle façon d’utiliser votre ordinateur.

    Vous vous sentez une affection naissante pour le Gnou et le, les mascottes de GNU/ Linux.

    Au programme

    DÉCOUVERTE de l’univers des logiciels libres.

    INSTALLATION d’un environnement GNU/ Linux, ainsi que le meilleur des logiciels libres.

    Venez avec votre ordinateur, nous installerons ensemble une distribution GNU/Linux avec un ensemble de logiciels libres et gratuits pour une utilisation quotidienne.

    Ouvert à tous – accessible aux débutant-e-s

    Une participation de 2 euros est demandée.

    L’adhésion à l’association est de 20 euros annuelle.(L’adhésion n’est pas obligatoire).

    Plan d’accés

    [FR Saint-Cyr-l'École] Permanence Root66 - Le samedi 15 décembre 2018 de 14h00 à 17h00.

    Root66 vous propose une permanence Logiciels Libres le samedi 26 janvier

    La permanence se tiendra au Centre Pierre Semard à Saint-Cyr-l'École (à deux pas de la gare RER C)

    Dans cette permanence nous discuterons des logiciels libres, nous vous proposerons un accompagnement technique aux systèmes d’exploitation libres GNU/Linux, et cela afin de vous aider à vous familiariser avec.

    Le contenu s’adapte aux problèmes des personnes présentes et permet ainsi l’acquisition de nouvelles compétences au rythme de chacun.

    Programme:

    Vous pourrez y aborder plusieurs thèmes

    • Discussions conviviales entre utilisateurs autour de Linux en général
    • Premières explorations du système
    • Installations et configurations complémentaires
    • Mise à jour et installation de nouveaux logiciels
    • Prise en main, découverte et approfondissement du système

    Entrée libre et gratuite

    Sur place, l'adhésion à l’association est possible mais non obligatoire.

    Prochaine permanence

    [FR Rouen] Journée Mensuelle du Logiciel Libre - Le samedi 15 décembre 2018 de 14h00 à 18h00.

    Le samedi 15 décembre 2018, nous organisons notre Journée Mensuelle du Logiciel Libre à la Maison St Sever à Rouen. (Centre Commercial St Sever, 10-12 rue Saint-Julien 76100 Rouen) de 14h00 à 18h00.

    On fera connaissance avec la toute dernière version de openSUSE, la openSUSE Leap 15, Gnome 3.26, LibreOffice 6.1 et beaucoup d’autres distributions Linux.****

    SUSE Linux Enterprise 12 SP4 (beta) sera aussi de la partie et comme vous le savez est la pièce maitresse de openSUSE Leap 15 et qui est maintenue par des ingénieurs SUSE.

    Nous distribuerons gracieusement des DVDs openSUSE 15 de 64 Bits à nos visiteurs dans la limite du stock disponible.

    Le Raspberry Pi 3 ainsi que les Raspberry Pi 2 seront aussi à votre disposition pour votre plaisir de coder

    On pourra discuter du Noyau 4.17.9, si le temps le permet.

    Voici aussi une liste des démonstrations de logiciels libres (FOSS) que nous vous proposerons
    https://nui.fr/blog/logiciels-libres-a-vous-proposer-comme-installation/

    Si vous voulez présenter une distribution Linux ou un logiciel libre, contactez-moi assez rapidement pour la logistique.

    Nous allons axer des sessions sur l’interopérabilité, de sorte de vous orienter vers une migration en douceur vers le logiciel libre. L'interopérabilité a toujours été notre fer de lance.

    STOP PRESSE Nous aurions des magazines à distribuer et couvrant openSUSE Leap 15 Linux si on nous livre à temps.

    [FR Ramonville-Saint-Agne] Faire son site associatif avec WORDPRESS - Le samedi 15 décembre 2018 de 14h00 à 18h00.

    Avec 29 de sites qui l’utilisent (chiffres de 2017), WordPress est l’un des CMS (Content Management System ou Système de gestion de contenu) les plus utilisés au monde. Logiciel libre, modulaire, mené par une vaste communauté, WordPress est maintenant devenu un outil incontournable qui a largement fait ses preuves.

    Nous allons vous montrer qu’avec cet outil, créer votre site web associatif, n’a rien de bien compliqué …

    Objectif: Détailler la rédaction d’articles et organiser le contenu de votre site
    Pré-requis: Posséder les notions de fichiers et de répertoires, savoir utiliser un navigateur Internet.

    : Apporter si possible sa machine personnelle, équipée d’une carte réseau filaire ou WiFi, et en état de marche. Nous pouvons vous prêter une machine, merci de nous le demander lors de l'inscription

    Inscriptions: L’atelier est gratuit comme d’habitude, mais nous vous demandons de vous inscrire au préalable https://le-pic.org/contact

    [FR Vandœuvre-lès-Nancy] Gérer ses photos - Le samedi 15 décembre 2018 de 15h00 à 17h00.

    Votre appareil photo est plein à craquer de clichés, vous ne savez pas comment les extraire judicieusement dans votre ordinateur

    Vous désirez pouvoir les retrouver facilement et profiter de quelques options d’améliorations basique tel que le recadrage ou la suppression des yeux rouges ****

    Alors n’attendez plus pour vous inscrire à cet atelier

    Inscription gratuite aux ateliers

    La participation aux animations repose sur un système d’inscriptions préalables qui permet de répondre de façon plus ciblée aux attentes des usagers et de les associer au projet.

    L'inscription est obligatoire au plus tard 30 min avant l’atelier.

    [FR Palaiseau] Apéro-rencontre Ğ1 (monnaie libre) - Le samedi 15 décembre 2018 de 15h00 à 19h00.

    Bonjour,

    Nous lançons une première rencontre pour les franciliens du sud de Paris (et les parisiens courageux) !) pour discuter de la monnaie libre Ğ1.

    Ce sera l’occasion de répondre aux questions de nouvelles personnes intéressées, d’échanger et de discuter de prochaines actions / rencontres / événements.

    N'hésitez pas à apporter vos produits à vendre en Ğ1, ou à présenter les services que vous offrez ou connaissez l'idée est de faire utiliser la monnaie en pratique, même aux nouveaux

    En espérant vous voir ce 15 décembre.

    [FR Vire] Atelier libre - Le samedi 15 décembre 2018 de 16h00 à 19h00.

    Atelier libre ouvert à tous. Venez découvrir, échanger et poser vos questions sur des logiciels ou services libres lors de cet atelier.

    Un focus rapide sera présenté à 17h sur un thème spécifique préparé par un bénévole de l’association.

    [FR Montpellier] Bricolotech Grappe de bureau / Desktop Cluster - Le dimanche 16 décembre 2018 de 18h30 à 20h00.

    Ce projet consiste a créer un cluster à partir de dev board. Rien de nouveau, c’est vrai, encore que… La nouveauté est dans l’utilisation.

    Nous allons partir de matériel et logiciels entièrement libres afin de créer un PC entièrement libre.

    Définition du projet
    L’idée est de dénicher un PC entièrement libre. Peu importe la puissance de l’engin, il faut qu’il soit libre, c’est à dire qu’il n’ai aucun secret.

    Qu’aucun binaire ne soit indispensable à son fonctionnement, pas d’IME, pas d’AMT, pas de BIOS complexe et fermé.

    Un PC simple qui permet de naviguer sur le web, faire des travaux multimédia, interfacer avec des périphériques externes et autres composants type microcontrôleurs par exemple.

    Avec un peu de puissance de calcul pour la compilation.

    Si nous ne voulons pas de binaire, il nous faut de la puissance nécessaire pour compiler les sources.

    Il existe des boards de dev plus ou moins chères et plus ou moins libres en assemblant ces dernières nous pourrons ainsi obtenir mon PC suffisamment puissant et entièrement libre.

    Quel matériel nous pouvons utiliser :

    1. L’Orange Pi PC (v1) semble un bon candidat pour du lowcost
    2. La libre computer board, avec 1GB ou 2GB de ram
    3. L’humming board, parfait pour ceux qui ont les moyens, la board est libre sans bidouille.

    Pourquoi les Logiciels Libres :
    Pourquoi s’obstiner avec les sources et le logiciel libre Pour

    1. Refuser l’obsolescence programmée
    2. Pouvoir mettre fin au chantage lié aux données personnelles
    3. Être capable de s’assurer que le matériels et les logiciels que nous utilisons font bien ce qu’ils sont sensés faire.
    4. Réduire la fracture technologique en permettant à chacun de s’intéresser au fonctionnement de ce qui inonde notre quotidien.
    5. Faciliter l’amélioration continue, chacun peut apporter selon son envie, son internet, ses possibilités.

    Vendredis 9, 16, 23 et 30 novembre 2018 de 18h30 à 20h00 (tous les vendredis)
    Do Tank au 2, rue du Pavillon, 34000 Montpellier

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Systèmes d’exploitation pour téléphones — partie 1 : premières initiatives ☎

    7 décembre, 2018 - 22:43

    Voici la première dépêche d’une série sur les systèmes d’exploitation (plus ou moins) libres pour téléphones. Dans les années 90, nos téléphones n’étaient pas libres. Mais, au début des années 2000, des libristes s’organisent et une multitude d’initiatives apparaissent. Remémorons‐nous ces bons vieux projets des débuts. C’était aussi la mode des GIF animés

    Les journaux LinuxFr.org les mieux notés de novembre 2018

    7 décembre, 2018 - 22:38

    LinuxFr.org propose des dépêches et articles, soumis par tout un chacun, puis revus et corrigés par l’équipe de modération avant publication. C’est la partie la plus visible de LinuxFr.org, ce sont les dépêches qui sont le plus lues et suivies, sur le site, via Atom/RSS, ou bien via partage par messagerie instantanée, par courriel, ou encore via médias sociaux.

    Ce que l’on sait moins, c’est que LinuxFr.org vous propose également à tous de tenir vos propres articles directement publiables, sans validation a priori des modérateurs. Ceux‐ci s’appellent des journaux. Voici un florilège d’une dizaine de ces journaux parmi les mieux notés par les utilisateurs… qui notent. Lumière sur ceux du mois de novembre passé :

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Émission « Libre à vous ! » du 4 décembre 2018 — Podcast et références

    7 décembre, 2018 - 18:23

    La septième émission Libre à vous ! de l’April a été diffusée sur la radio Cause commune, mardi 4 décembre 2018. Au programme : logiciels libres et monde associatif, Libre en Fête 2019, Paris Open Source Summit et diverses annonces.

    Le podcast est disponible, ainsi qu’une page qui liste toutes les références citées pendant l’émission (vous trouverez également sur cette page les podcasts par sujet traité). L’émission dispose d’un flux RSS compatible avec la baladodiffusion auquel vous pouvez vous abonner, ainsi qu’un salon dédié à l’émission sur le messagerie instantanée Web de la radio.

    L’ambition de Libre à vous ! est d’être une émission d’explications, d’échanges et d’actions concernant les dossiers politiques et juridiques que l’April traite et les actions qu’elle mène. Une partie de l’émission sera également consacrée aux actualités et actions de type sensibilisation.

    Libre à vous ! est actuellement une émission mensuelle. Pour pouvoir traiter encore plus de sujets, être réactif par rapport à l’actualité, j’ai le plaisir de vous annoncer que l’émission deviendra hebdomadaire à partir du 8 janvier 2019. Elle sera diffusée chaque mardi de 15 h 30 à 17 h.

    La prochaine émission sera diffusée en direct sur la bande FM en Île‐de‐France (93,1 MHz) et sur le site Web de la radio le mardi 8 janvier 2019, de 15 h 30 à 17 h.

    La radio a besoin de soutien financier pour notamment payer les frais matériels (loyer du studio, diffusion sur la bande FM, serveurs…). Nous vous encourageons à aider la radio en faisant un don.

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    git-bug: un bug tracker distribué intégré dans git

    6 décembre, 2018 - 11:51

    À l'occasion de la sortie de la version 0.4 de git-bug, je me suis dit que je pourrai te raconter un peu de quoi il retourne. git-bug est un gestionnaire de bugs distribué intégré dans git.

    git-bug est un bug tracker distribué intégré dans git, c'est-à-dire que l'ensemble des données des bugs est stocké sous forme d'objet git, sans polluer les branches et fichiers normaux. Mais pour quoi faire ? Et bien par rapport à un bug tracker classique, il y a plusieurs avantages :

    • pas de dépendance à un service en particulier (par exemple si ton bugtracker préféré se fait racheter par tousse Microsoft tousse) ;
    • pas besoin d'infrastructure particulière : si tu utilises déjà un remote git pour collaborer, tu as un bugtracker ;
    • tu peux consulter et éditer les bugs hors-ligne, avec l'interface que tu préfères, sans latence.

    Mais alors, comment on fait un bug tracker distribué ? Le plus gros problème c'est la gestion des conflits. Comment faire si Alice et Bob modifient le même bug et s'échangent les données ensuite ?

    La solution choisie, plutôt que de stocker simplement l'état d'un bug, est de stocker chaque opération d'édition individuellement.

    +-------------+ +-----------+ +-------------+ +--------+ * --->| ADD_COMMENT |--->| SET_TITLE |--->| ADD_COMMENT |-->| CREATE | +-------------+ +-----------+ +-------------+ +--------+

    Quand une fusion doit avoir lieu, l'une des deux versions voit ses nouvelles opérations placées à la fin de la chaine, à la manière d'un rebase. On a donc la garantie d'avoir un état final cohérent puisque c'est git-bug qui dérive l'état final de la chaîne d'opérations. Mais que se passe-t-il si deux personnes suppriment la même étiquette ? Elle sera simplement supprimée une fois et l'action des deux personnes sera visible dans l'historique.

    Voilà à quoi pourrait ressembler une opération :

    { "type": "SET_TITLE", "author": { "name": "René Descartes", "email": "rene.descartes@example.com" }, "timestamp": 1533640589, "title": "This title is better" }

    Ces opérations sont ensuite sérialisées et stockées dans des blob git et reliées dans une chaîne de commits. Chaque bug a sa propre chaîne de commits, accessible via une référence git. À chaque fois que le bug est modifié, une nouvelle série d'opérations est ajoutée à la chaîne et la référence est mise à jour.

    refs/bugs/<bug-id> | | v +-----------+ +-----------+ "ops" +-----------+ | Commit |--->| Tree |---------+----------->| Blob | (OperationPack) +-----------+ +-----------+ | +-----------+ | | | | v | "root" +-----------+ +-----------+ +-----------+ +----------->| Blob | (OperationPack) | Commit |--->| Tree |-- ... | +-----------+ +-----------+ +-----------+ | | | | | "media" +-----------+ +-----------+ v +----------->| Tree |---+--->| Blob | bug.jpg +-----------+ +-----------+ +-----------+ | +-----------+ | Commit |--->| Tree |-- ... | +-----------+ +-----------+ | +-----------+ +--->| Blob | demo.mp4 +-----------+

    Comme tout est stocké sous forme d'objet git, on peut pousser tout ça vers un remote et collaborer, comme si on s'échangeait du code source.

    Une autre propriété intéressante de la méthode, c'est qu'on peut stocker et lier les médias (typiquement, une capture d'écran) à un bug et les diffuser de la même façon.

    Alors, à quoi ça ressemble tout ça ? Et bien ça dépend des goûts. Si tu préfères la ligne de commande, le scripting ou intégrer ça dans ton Vim, c'est possible. Voilà un aperçu:

    # Ajouter un nouveau bug git bug add # Liste les bugs ouverts, trié par dernière édition git bug ls "status:open sort:edit" # Affiche l'état du bug f3781aee git bug show f3 # Selectionne le bug f3781aee parce que je sais bien que tu es un peu flemmard git bug select f3 # Ajoute un nouveau commentaire git bug comment add # Pousse les modifications vers le remote par défaut git bug push

    Pour un usage plus efficace, il y a aussi l'interface interactive en terminal :

    Ou sinon, pour les amateurs de vrai pixels et de clic-clic, git-bug embarque une interface web, mais il faut avouer qu'il y a encore du boulot :


    Techniquement, le binaire de git-bug lance un serveur web local qui sert les fichiers d'une application REACT (JavaScript) qui ont été compilés et inclus dans ce même binaire. L'application web s'interface avec le binaire grâce à une API GraphQL. Le déploiement reste donc extrêmement simple avec un unique binaire à copier, sans configuration.

    La nouvelle version 0.4 apporte une fonctionalité qui a été beaucoup demandée, un importeur incrémental pour Github ! Après avoir utilisé git bug bridge configure pour saisir ses identifiants, un token d'API est généré automatiquement et git-bug devient capable d'aspirer les issues en local dans son modèle de données.

    Et le futur ? Une de mes priorités est d'implémenter un exporteur vers Github. Quand ça sera fait, il sera possible d'utiliser git-bug comme un Github déporté, qui fonctionne en local et offline.

    Une autre idée qui me trotte dans la tête est d'avoir une véritable gestion d'identité en embarquant les données publiques dans des objets git, clé de chiffrement incluse. De cette façon, il devient possible de les distribuer facilement, avec les données des bugs, de signer ses éditions, les vérifier, et même pourquoi pas ? de vérifier les commits git normaux sans avoir à chercher et importer les clés GPG.

    Mais tout ça, c'est quand même beaucoup pour, en gros, un seul bonhomme. Mais peut-être, mon cher journal, que je trouverai des âmes vaillantes pour m'accompagner dans cette aventure…

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Sortie de LemonLDAP::NG 2.0

    6 décembre, 2018 - 04:55

    LemonLDAP::NG est un logiciel libre d’authentification unique pour applications Web (WebSSO), de contrôle d’accès et de fédération d’identités, écrit en Perl et publié sous licence GPL. Cette nouvelle version majeure apporte de grands changements au logiciel comme le prise en charge de Node.js, des seconds facteurs d’authentification (OTP, U2F, Yubikey…), un mécanisme de greffons, la protection de micro‐services et bien d’autres qui seront développés dans la suite de cet article.

    Sommaire

    Le projet LemonLDAP::NG a été publié pour la première fois en 2005 par la Gendarmerie nationale. Il est aujourd’hui très largement déployé en France, notamment dans les administrations et collectivités territoriales. Ses grands principes sont :

    • le SSO doit être faiblement intrusif dans les applications : pas d’obligation d’utiliser une bibliothèque ou un langage spécifique, prise en charge d’un maximum de protocoles, etc. ;
    • le SSO ne doit pas pénaliser les performances des applications (architecture extensible, faible surcharge…) ;
    • pont protocolaire : LemonLDAP::NG permet de connecter une application utilisant le protocole standard X sur une infrastructure basée sur le protocole Y ;
    • et, bien sûr, la sécurité et le confort des utilisateurs.

    Principales nouveautés de la version 2.0

    Voici les principales nouveautés de cette nouvelle version majeure :

    • meilleur fonctionnement du pont protocolaire : de nombreux tests unitaires valident le fonctionnement du SSO lors du passage d’un protocole à un autre ; par exemple, une application qui s’authentifie en SAML sur le portail WebSSO, qui lui‐même redirige en OpenID Connect sur un fournisseur d’identité externe (France Connect, Google, etc.) ;
    • authentification multi‐facteur ;
    • SSOaaS (SSO as a Service) ;
    • un moteur de greffons permettant de créer des composants d’authentification ou toutes sortes d’applications s’intégrant au portail sans avoir à modifier le code source et ainsi mieux gérer les montées de version.

    Vous pouvez consulter la liste complète des nouveautés.

    Handler Node.js

    Node.js est une plate‐forme très populaire pour le développement d’applications Web. La version 2.0 inclut un handler node.js en version bêta, qui permet de protéger une application Node.js par LemonLDAP, directement dans le code de l’application.
    Cela permet également de rendre facilement une application compatible avec des protocoles de SSO comme SAML ou OpenID Connect. Ce handler ne gère pas encore toutes les fonctionnalités de LL::NG.

    Le handler Node.js fournit également un moteur alternatif pour le SSO en tant que service.

    Seconds facteurs d’authentification

    LemonLDAP::NG gère désormais directement les seconds facteurs d’authentification (2FA), en particulier :

    • les périphériques U2F ;
    • TOTP (FreeOTP, Authy, GoogleAuthenticator…) ;
    • les clefs Yubikey ;
    • les appels REST à un service Web externe ;
    • n’importe quelle autre commande via le module External 2F.
    Greffons

    LemonLDAP::NG est désormais capable de gérer des développements spécifiques sans pour autant risquer de les casser en cas de mise à jour, via un système de greffons. Quelques exemples déjà disponibles :

    • Auto Signin : permet de s’authentifier automatiquement en fonction d’une règle, par exemple une adresse IP ;
    • Brute Force Protection : permet de gérer la protection contre les attaques en force brute directement dans LemonLDAP::NG ;
    • Check State : permet de générer une page de statut pour une meilleure intégration avec des outils de supervision ;
    • etc.
    SSO as a Service (SSOaaS)

    Le contrôle d’accès SSO fournit trois services :

    • authentification globale ;
    • gestion des autorisations : authentifier n’est pas suffisant, les droits d’accès doivent être examinés ;
    • traçabilité :
      • traces d’accès issues du SSO,
      • traces des actions de l’utilisateur.

    LemonLDAP::NG fournit tous ces services (à l’exception des traces des actions des utilisateurs qui doivent être générées par l’application, mais LemonLDAP::NG fournit les identifiants à enregistrer via les en‐têtes HTTP).

    Les acronymes « *aaS » signifient que l’application peut piloter la couche sous‐jacente (IaaS, pour l’infrastructure ; PaaS, pour la plate‐forme…). Pour nous, le SSOaaS doit fournir la possibilité pour une application de gérer ses droits et choisir les attributs à transmettre : un fichier JSON est présent à la racine de l’application et permet de définir ces paramètres, sans avoir à manipuler la configuration centrale du WebSSO.
    L’authentification SSO ne peut être réellement « *aaS » : l’application l’utilise sans la gérer, bien sûr.

    LemonLDAP::NG fournit donc les fonctionnalités permettant de mettre en œuvre le SSOaaS dans ces conditions. Encore un peu rustique, cette prise en charge sera améliorée dans les prochaines mises à jour de la branche 2.0.

    Serveur à Serveur

    Les applications modernes utilisent des micro‐services Web. LemonLDAP::NG fournit un dispositif permettant de donner à une application un ticket qu’elle peut utiliser sur d’autres micro‐services protégés par le WebSSO pour :

    • propager l’identité de l’utilisateur final ;
    • permettre aux micro‐services de vérifier les droits de l’utilisateur final ;
    • limiter l’accès de cette application aux seuls micro‐services autorisés dans la console d’administration LemonLDAP::NG ;
    • limiter l’usage dans le temps de ce ticket (30 secondes).

    L’alternative consistant à donner à l’application le ticket SSO de l’utilisateur est nettement moins sécurisée : l’application obtiendrait ainsi tous les droits de l’utilisateur pendant tout le temps de sa session.

    La solution apportée par LemonLDAP::NG est une alternative à OAuth2, moins intrusive : le micro‐service n’a pas besoin de valider le jeton d’accès, ce jeton est consommé directement par un handler qui retransmet ensuite l’identité de l’utilisateur via des en‐têtes HTTP.

    Fédération Renater

    LemonLDAP::NG est désormais compatible nativement avec le système de fédération de Renater, permettant de rendre son déploiement plus facile dans l’éducation, les universités, les laboratoires et le secteur public utilisant la fédération de Renater.

    Manager Différentiel des configurations

    Cette nouvelle fonctionnalité permet d’afficher directement dans le Manager la différence entre deux versions de la configuration et donc d’identifier plus facilement les paramètres qui ont été modifiés.

    Gestion des ACL pour les protocoles CAS, SAML et OpenID Connect

    Il est désormais possible de définir des listes de contrôle d’accès (ACL) pour des applications reliées par CAS, SAML et OpenID Connect. Ces règles peuvent être également utilisées pour afficher ou non l’icône des applications dans le menu.

    Autres
    • explorateur de sessions : possibilité de trier les sessions par date de création et de modification ;
    • journaux : possibilité de gérer les journaux séparément (traces techniques et traces des utilisateurs) :
      • journaux du serveur (Apache uniquement) ;
      • journal système (syslog) ;
      • Log4Perl (compatible Log4J) ;
      • Sentry (à utiliser de préférence avec Dispatch) ;
      • Dispatch : permet de tracer séparément en fonction du niveau d’alerte.
    Portail Rafraîchissement de la session

    Il est à présent possible pour l’utilisateur de rafraîchir sa session sans avoir besoin de se déconnecter, utile dans le cas de l’ajout à un nouveau groupe apportant de nouvelles applications sur le portail.

    Autres
    • sélection de la langue avant la connexion ;
    • nouvelles langues : vietnamien, arabe et italien, en plus de l’anglais et du français ;
    • gestion du changement de logo du portail sans modifier le thème ;
    • passage du portail sur Bootstrap 4.
    Contributeurs

    Les contributeurs suivants ont participé à cette nouvelle version :

    • développeurs principaux : Xavier Guimard, Christophe Maudoux et Clément Oudot ;
    • organisations (sponsors et bêta‐testeurs) : la Gendarmerie nationale, Worteks, Orange, Huma Num, Campus Condorcet, Agirc‐Arrco et Urgences Santé Québec ;
    • communauté (ouvertures de tickets, tests et correctifs) : Valérie Bauche, David Coutadeur, Frédéric Massot, Mathieu Lecompte‐Melançon, Nicolas Chauvet, Mathieu Parent, Rick Jongbloed, Jérémy Kespite, Philippe Baye, Pasi Karkkainen, Julian Layen, Quentin Jabœuf, Stéphane Liabat, Emmanuel Lesouef, François‐Xavier Deltombe, Iheb Khemissi, Jean‐Charles Rogez, Nicolas Dutertre, Maxime de Roucy, pit pit, Carl R., Dave Conroy, Paul Curie, Dejan Sanader, Jean‐François Vincent, Anthony Roussel, Xavier Bachelot, Lulandco, Cédric Liard, Frédéric Pégé, Jonathan Swaelens et Michael Goldfinger.
    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    En Vente Libre : de nouvelles associations et quelques idées cadeaux pour les fêtes

    5 décembre, 2018 - 14:45

    Les associations du Libre proposent divers produits à la vente, elles ont aussi besoin de récupérer des dons. L’association En Vente Libre a été créée en 2009 pour les soutenir en mettant un site à disposition de celles qui le souhaitent, ce qui leur permet de mutualiser les coûts (bancaires, postaux et autres).

    En Vente Libre se développe : initialement, six associations participaient à la plate‐forme enventelibre.org : April, Debian, Framasoft, La Mouette, Multisystème et Ubuntu-Fr. Nous en accueillons maintenant d’autres : Alionet, Borsalinux-fr, Khaganat, LILA, Mageia et La Quadrature du Net. Elles ont décidé de rejoindre En Vente Libre et de participer à l’aventure, merci à elles !

    Bientôt les fêtes de fin d’année ; pour vos cadeaux, le site vous propose de nombreuses idées. N’hésitez plus, venez visiter notre site et vous ferez d’une pierre deux coups : satisfaire vos proches tout en soutenant le Libre.

    Adhérer, participer, contribuer
    • si vous faites partie d’une association et que vous voulez vendre vos produits ou obtenir des dons sur la plate‐forme En Vente Libre, n’hésitez pas à demander notre convention par courriel à bureau [AT] enventelibre.org ;
    • si vous voulez participer au projet et devenir bénévoles, contactez‐nous par courriel à association [AT] enventelibre.org, vous serez les bienvenus ;
    • si vous avez des compétences sur PrestaShop, faites‐vous connaître, votre aide et vos conseils nous permettront d’améliorer notre service !
    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Conférences « Libertés et vie privée » — Capitole du Libre, le 17 et 18 novembre 2018 à Toulouse

    5 décembre, 2018 - 11:43

    La septième édition du Capitole du Libre, l’événement du logiciel libre en Occitanie, s’est déroulée du 17 au 18 novembre 2018 à l’ENSEEIHT, en centre‐ville de Toulouse. Organisée par l’association Toulibre avec l’aide des clubs étudiants de l’ENSEEIHT (Net7, TVn7 et CAn7), cette rencontre concernait le grand public et les spécialistes.

    Je vous propose une synthèse des conférences, que vous pouvez également suivre en intégralité à l’aide des vidéos.

    Les conférences

    Chaque année, cent conférences sont proposées dans quinze salles en parallèles durant le week‐end. En 2017, les thèmes concernaient la découverte du logiciel libre, l’IoT et l’embarqué, le DevOps, la sécurité, les libertés et la vie privée, communauté du logiciel libre, la 3D et la création graphique, ainsi que les jeux libres.
    En 2018, les thèmes concernaient : les enjeux du Libre, l’Open Data, l’IoT et l’embarqué, le Libre, la Technique, le C++, Les libertés et la vie privée, la 3D, le Web, le DevOps, le financement du logiciel libre et, enfin, les jeux libres (voir le programme 2018).

    Les animations et ateliers

    Durant le week‐end, le village associatif accueille et échange avec le public et entre exposants du Libre ; des espaces accueillent les plus jeunes pour tester l’impression 3D (avec l’association Combustible), la robotique et les jeux vidéos.
    Parmi les ateliers, David Revoy présentait une création de BD (avec, entre autres, le logiciel libre de retouche d’image Krita) et, avec Elzen, la création de campagnes pour le jeu de stratégie The Battle for Wesnoth. Des membres de Framasoft et de l’April étaient présents.

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    FLOSSCon 2019 à Grenoble, appel à conférences et bénévoles

    4 décembre, 2018 - 15:10

    En janvier dernier est née la FLOSSCon, la conférence alpine du logiciel libre. La prochaine édition est sur les rails, elle aura lieu du dimanche 27 au mardi 29 janvier. Au programme : des conférences, des ateliers, et — nous l’espérons — un village associatif.

    Le format de l’évènement

    L’édition 2019 se déroulera sur trois jours :

    • le dimanche 27 janvier : une journée grand public et aspects sociétaux du Libre ;
    • les lundi 28 et mardi 29 : deux journées techniques de présentations d’outils et ateliers de pratique.
     Appel à conférences

    L’appel à conférences est ouvert. Les sujets peuvent être techniques, philosophiques, juridiques, etc. Peu importe, du moment qu’ils concernent les logiciels libres ou les données ouvertes. Pour vous faire une idée, vous pouvez jeter un coup d’œil à la variété des sujets abordés en janvier 2018.

    Le format de vos propositions devrait dans la mesure du possible entrer dans l’un des quatre formats suivants :

    • exposer une idée, un projet en 15 minutes ;
    • animer une conférence de 30 minutes ;
    • animer un atelier d’une heure ;
    • proposer une table ronde d’une durée de 1 h 30.

    Bien évidemment, si vous souhaitez proposer un sujet sous un autre format vous avez toujours la possibilité de nous contacter pour que l’on en discute.

    Appel à bénévoles

    L’organisation d’une telle conférence ne peut pas se faire sans moyens humains, alors on recrute ! Communication autour de l’évènement, organisation, recherche de sponsors, installation informatique… Toutes les bonnes volontés sont les bienvenues !

     Chacun de vous peut nous aider, même sans s’impliquer (alors on compte sur vous) !

    L’évènement est peu connu, donc peu visible. Si on veut que FLOSSCon 2019 soit une réussite, on a besoin de monde. Des orateurs et animateurs d’atelier, bien sûr, mais aussi du public. Et des bénévoles pour organiser l’évènement avec nous. Avec l’aide de chacun d’entre vous, on peut obtenir la visibilité qu’on aurait en étant un évènement déjà réputé.

    Sans vous c’est impossible.

    C’est pour cette raison que votre aide est importante et d’autant plus qu’elle ne vous coûtera quasiment rien : on a juste besoin que vous relayez l’existence de l’évènement et l’appel à conférences autour de vous et sur les réseaux sociaux. Pour que le public soit nombreux et que les sujets abordés soient de qualité.

    Si vous allez au Paris Open Source Summit cette semaine, parlez de FLOSSCon. Si vous travaillez dans un domaine où le logiciel libre et la libération des données sont importants, parlez de FLOSSCon. Si vous êtes dans une association, parlez de FLOSSCon. Si vous allez à SnowCamp, parlez de FLOSSCon (FLOSSCon est juste après). Si vous avez un compte Mastodon, Twitter, LinkedIn ou autre, parlez de FLOSSCon. Si vous êtes grenoblois, parlez de FLOSSCon.

    En bref, parlez de FLOSSCon : ça nous aidera énormément.

    Prochaine étape Pour les Grenoblois

    La prochaine réunion d’organisation est programmée lundi 10 décembre — dans moins d’une semaine. Que vous souhaitiez participer à l’organisation, donner un coup de main ou juste rencontrer l’équipe, venez. On n’est jamais trop de bénévoles. Et puis rencontrer les gens en vrai, c’est bien.

     Pour les autres

    Parlez de l’évènement, soumettez vos sujets de conférence ou atelier, et réservez la date : dimanche 27 à mardi 29 janvier 2019.

    On va faire en sorte que l’évènement soit une réussite. On compte sur vous pour nous y aider.

    Bonne journée à toutes et tous et merci d’avoir lu jusqu’au bout :)

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Revue de presse de l’April pour la semaine 48 de l’année 2018

    4 décembre, 2018 - 11:58

    La revue de presse de l’April est régulièrement éditée par les membres de l’association. Elle couvre l’actualité de la presse en ligne, liée au logiciel libre. Il s’agit donc d’une sélection d’articles de presse et non de prises de position de l’Association de promotion et de défense du logiciel libre.

    Sommaire

    [The Conversation] Pour lutter contre le changement climatique, inspirons-nous de Linux !
    Par Antoine Godin_, le dimanche 2 décembre 2018. Extrait :

    « Les dispositifs intergouvernementaux comme la COP 24 ne pourront à eux seuls résoudre la crise climatique. La protection du climat est plus que jamais l’affaire de tous. »

    [Le Temps] Vers la fin des blockchains et de l’open source ?
    Par Olivier Depierre, le vendredi 30 novembre 2018. Extrait :

    « Après avoir vu d’innombrables réécritures et améliorations des blockchains existantes, certaines nouveautés technologiques se cloîtrent et se protègent, impassibles face à la critique extérieure. Qui a dit trumpisme ? »

    [newsmonkey] Reddit entre dans la guerre contre les articles 11 et 13 sur le droit d’auteur
    Par Gauvain Dossantos, le jeudi 29 novembre 2018. Extrait :

    « Après YouTube, c’est au tour de Reddit d’inciter ses utilisateurs à s’exprimer à l’encontre de la directive européenne sur le droit d’auteur et le copyright. Plus précisément contre l’article 11 et l’article 13 de ce texte de loi. »

    Voir aussi : SaveYourInternet.

    [Developpez.com] Il y a presque 6 années, la NASA a migré tous les ordinateurs portables à bord de l’ISS de Windows vers Linux
    Par Coriolan, le jeudi 29 novembre 2018. Extrait :

    Il y a presque 6 années, la United Space Alliance, l’entreprise menant des activités spatiales pour le compte de la National Aeronautics and Space Administration (NASA), a entrepris de migrer les ordinateurs au sein de la station spatiale internationale (ISS) vers [GNU/]Linux. »

    [cio-online.com] Stéphane Rousseau (Eiffage) : « l’Open CIO Summit est organisé par les décideurs IT pour les décideurs IT »
    Par Bertrand Lemaire, le mardi 27 novembre 2018. Extrait :

    « DSI groupe de Eiffage, Stéphane Rousseau explique pourquoi il a accepté d’être le parrain de l’Open CIO Summit 2018. Cette manifestation se tiendra le 4 décembre 2018 à Paris. Il détaille également la place actuelle de l’Open Source en entreprise. Il a piloté les travaux du groupe de travail du Cigref “Open-source : alternatives aux grands fournisseurs” ».

    [ouest-france.fr] Quimperlé. L’Install party a battu son plein à la médiathèque
    Par la rédaction, le lundi 26 novembre 2018. Extrait :

    « “C’est depuis 2013 que nous accueillons des install parties”, explique Pascal Thibaut, directeur de la médiathèque de Quimperlé. Samedi 24 novembre, un après‐midi d’animations était organisé. »

    [La gazette.fr] Numérique et territoires : une transition au service des citoyens
    Par Baptiste Cessieux, le lundi 26 novembre 2018. Extrait :

    « Quel est le degré de maturité des collectivités dans l’appropriation des outils numériques et le déploiement de politiques publiques dématérialisées ? Pour quels services aux citoyens ? Résultats de l’étude “La Gazette” — Orange : des services aux citoyens sur les rails mais des interactions entre administrations qui restent à prouver. »

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur