Syndiquer le contenu
Mis à jour : il y a 5 heures 53 min

EclipseCon à Toulouse les 21 et 22 juin 2017

10 juin, 2017 - 21:41

L’EclipseCon France 2017 arrive à grands pas. C’est un des événements majeurs de la communauté Eclipse. Pour ceux qui en seraient restés à l’environnement de développement intégré (EDI), sachez que la fondation éponyme, c’est aussi des projets (plus de 330) et groupes de travail autour des objets connectés, de l’embarqué, le big data, la recherche scientifique, etc.

Le programme des deux jours de conférences a été publié et il est plutôt dense et éclectique : du test, de la donnée, des objets connectés, de l’éthique, de l’analyse, du devops, du cadriciel et plein d’autres trucs cools. La « keynote » parlera robotique !

Cela se tient les 21 et 22 juin 2017 au Centre de congrès Pierre Baudis de Toulouse. L’entrée est payante, mais si vous avez raté la période d’inscription précoce, pas de souci, utilisez le code SPEC-LINXFR pour obtenir 50 € de réduction sur le prix pour les deux jours. C’est limité à dix, mais s’ils partent tous, prévenez‐nous dans les commentaires et on ira vous en récupérer d’autres !

La communauté française du Libre sera bien sûr présente sur place avec notamment :

Télécharger ce contenu au format Epub

Lire les commentaires

Lancement d’un groupe téléphonie et télécom libre

10 juin, 2017 - 17:57

La téléphonie a toujours été un peu mise de côté dans le monde l’informatique car c’est un sujet bien particulier qui, il n’y a pas si longtemps, était bien séparé dans les entreprises : d’un côté les téléphonistes, de l’autre les informaticiens. Depuis quelques années la téléphonie a été reprise par les équipes informatique. Elle s’est orientée vers les logiciels, mais est aussi interconnectée avec les autres logiciels dans l’entreprise.

Cet univers est vaste et très intéressant car il mélange beaucoup de concepts partant du réseau téléphonique et informatique jusqu’à l’interface utilisateur. Il en existe beaucoup et pour tous les goûts. De plus, il doit être capable de s’adapter à l’ancienne génération de téléphonie, par exemple connecter un système entièrement logiciel sur un réseau téléphonique public physique ou interconnecter un système téléphonique existant d’ancienne génération sans utiliser de VoIP… La liste est longue et on en découvre tout le temps et tous les jours.

Le monde du Libre est aussi présent avec de nombreuses solutions alternatives. Elles font tourner la majorité des fournisseurs téléphoniques alternatifs. Les grands opérateurs téléphoniques les utilisent sur des besoins complémentaires et spécifiques. Au quotidien, des développeurs les utilisent pour créer des nouveaux logiciels.

L’objectif de ce groupe est évidemment de se rassembler pour échanger, partager et découvrir ce qui est possible dans cet univers. Aujourd’hui, la téléphonie prend un virage important, tant d’un point de vue utilisateur, que pour les personnes dont le travail est d’intégrer ces systèmes.

À titre d’exemple nous pouvons parler de logiciels qui vont permettre de travailler sur les couches plus basses de la téléphonie comme :

Des téléphones logiciels (softphones) comme :

Des logiciels collaboratifs :

Des autocommutateur comme :

Je ne parle pas de toutes les bibliothèques existantes pour les développeurs, ni même du matériel nécessaire.

La liste est longue et tout comme les logiciels traditionnels (tel que les PGI/ERP, GRC/CRM) l’arrivée du cloud est aussi un changement important dans le monde de la téléphonie. La possibilité de connecter et d’intégrer la téléphonie avec les logiciels existants pour avoir des fonctionnalités comme le click to call, la remontée de fiche, les statistiques, etc, font partie de ces changements importants.

Comme vous pouvez le constater, c’est riche. Il y a plein de technos, plein de concepts et c’est vraiment passionnant d’en apprendre et d’en découvrir chaque jour. :)

Je vous invite donc à venir vous inscrire dans ces rencontres, nous avons utilisé la plate‐forme meetup.com pour en simplifier la gestion. C’est ouvert à tous, tout le monde peut en organiser et participer.

Les deux premières auront lieu à Lyon le 19 juin et Paris le 20 juin. Si vous voulez faire une présentation, vous êtes les bienvenus ! N’hésitez pas à me contacter via meetup.com.

Télécharger ce contenu au format Epub

Lire les commentaires

Vers une norme AFNOR pour le clavier français

10 juin, 2017 - 17:57

Suite à la 1re publication de l’AFNOR le 15 janvier 2016, annonçant son intention de travailler sur une norme pour le clavier informatique français, appuyée le 27 novembre 2016 dernier par un appel à rejoindre la commission de travail sur le projet (évoqué ici lors d’un journal), l’AFNOR invite aujourd’hui et jusqu’au 9 juillet prochain à commenter son projet de norme.

L’AFNOR, ou Association française de normalisation (abrégée AFNOR), est l’organisation française qui représente la France auprès de l’Organisation internationale de normalisation (ISO) et du Comité européen de normalisation (CEN).

Sommaire Contextualisation et présentation du projet

Partant du constat, d’une part de l’absence d’une norme française décrivant le clavier utilisé sur les différents matériels informatiques traditionnels, à la différence de la plupart de ses voisins européens, et d’autre part des difficultés dactylographiques dues à la trop grande diversité de clavier AZERTY proposés par les fabricants sur le marché français, l’AFNOR, sur l’impulsion du ministère de la Culture et de la Communication (par l’intermédiaire de la délégation générale à la Langue française et aux Langues de France) et en lien avec les industriels et les représentants des utilisateurs du secteur, présente un projet normatif pour élaborer une norme française de clavier.

En effet, la publication Vers une norme française pour les claviers informatiques de l’AFNOR introduit les problèmes les plus courants dans la plupart des variations de la disposition commune de clavier français dite AZERTY dérivée de la disposition QWERTY : diversité de placement de symboles courant comme « € » ou encore « @ », difficultés ou absence d’accès aux majuscules accentuées, absence du « Ç ». La publication signale également qu’un travail pourrait être mené pour ajouter certains symboles absents mais pouvant s’avérer utiles comme le « [[pour mille]] » (‰) ou les symboles « supérieur ou égal » (≥) et « inférieur ou égal » (≤). L’organisme évoque également la grande variété des claviers virtuels proposés sur les tablettes et téléphone intelligents, introduisant par la saisie prédictive une plus grande facilité d’utilisation des mots employant des caractères spéciaux, bien que cette compensation reste insuffisante à ses yeux. Un autre objectif est également d’homogénéiser à terme le parc de claviers informatiques en France.

Malheureusement en mentionnant les dispositions de claviers utilisées sous certains systèmes d’exploitation, la publication n’évoque que les systèmes Windows et Apple, ou Android pour les tablettes tactiles ou téléphones intelligents.

Deux configurations de clavier proposées

Là où les dispositions envisageables devraient selon l’AFNOR permettre l’utilisation aisée des différentes langues présentes sur le territoire français, l’organisme donne à titre d’exemple le clavier breton, dit C’HWERTY, ou les exigences de l’occitan.

Plus globalement, cette disposition serait envisagée pour rendre plus facile en premier lieu l’écriture des langues européennes utilisant les caractères latins, ainsi que l’écriture des caractères spécifiques des langues de nos pays voisins non basées sur le latin, comme par exemple l’eszett en allemand (ß) ou le O barré (Ø) utilisé dans certaines langues nordiques, et en second lieu rendre accessibles les caractères diacritiques spécifiques à certaines langues d’Europe centrale et de l’Est telle que la brève (Ă) ou encore la virgule souscrite (Ț).

À ce titre, deux dispositions pour les claviers bureautiques (105 ou 72 touches) utilisés en France sont proposées par la Commission de normalisation dédiée aux « interfaces utilisateur » : l’une très proche de la disposition AZERTY (jusqu’alors jamais normalisée en France) et l’autre s’appuyant sur la disposition ergonomique et libre BÉPO (CC-BY-SA).

La disposition adaptée de l’AZERTY vise à minimiser l’effort d’adaptation des utilisateurs du clavier AZERTY actuel (meilleure rétrocompatibilité avec les logiciels et notamment les pilotes de claviers existants) mais conserve les risques de troubles musculo‐squelettiques associés à cette disposition.

La disposition BÉPO a été conçue pour réduire ces risques de troubles musculo‐squelettiques associés à la disposition AZERTY et obtenir une disposition la plus ergonomique et efficace possible pour la saisie du français et d’autres langues à alphabet latin, mais elle nécessite un effort d’adaptation plus important pour les utilisateurs de l’actuel clavier AZERTY.

Carte complète de la disposition AZERTY :

Carte complète de la disposition BÉPO :

Je vous renvoie à la norme en cours de travail pour plus de précisions sur les combinaisons et utilisations de touches mortes possibles, les cartes de disposition ne permettent pas de juger de toutes les utilisations. Le document présenté permet également de suivre la démarche de l‘AFNOR dans son choix de conception d’une disposition de clavier AZERTY adaptée.

Appel à commentaires

La Commission de normalisation dédiée aux « interfaces utilisateur » lance une enquête publique visant à recueillir un maximum d’avis sur le projet. La norme elle‐même est envisagée sans aucun caractère obligatoire, mais la conformité des matériels à cette norme pourrait être exigée dans le cadre des marchés publics de l’administration et cette future norme pourrait ainsi avoir un impact non négligeable.

L’appel à commentaires concerne les points suivants :

  • les principes du clavier ;
  • l’inventaire des signes qui peuvent être saisis ;
  • le détail des dispositions.

La Commission indique que les commentaires seront traités de façon anonyme lors d’une réunion de dépouillement à laquelle tous les répondants à l’enquête pourront participer.

L’AFNOR demande spécifiquement de faire des propositions de modification. Le commentaires prend la forme d’un tableau normalisé ISO au format Office Open XML .docx (malheureusement).

Accéder aux documents et donner son avis nécessitent la création d’un compte sur le site de l’AFNOR (attention, formulaire de création non sécurisé).

Télécharger ce contenu au format Epub

Lire les commentaires

OpenRouteService : routage en ligne basé sur OpenStreetMap

9 juin, 2017 - 17:43

OpenRouteService est un service de routage basé sur les données OpenStreetMap développé par l’université de Heidelberg en Allemagne.

NdM : le logiciel est sous licence MIT.

Routage

Il est possible de demander son chemin avec un nombre assez important de moyens :

  • voiture ;
  • véhicule lourd (normal, transports de bien, bus, agricole, engin forestier ou livraison) ;
  • cycle (normal, le plus sûr, pour le paysage, c’est‐à‐dire passant proche de points d’intérêts, VTT, course ou électrique) ;
  • piéton (normal ou randonnée) ;
  • chaise roulante.

Le service de routage essaie d’utiliser une bonne partie des informations d’OSM et propose ainsi de catégoriser plusieurs éléments au sein d’un trajet :

  • la surface rencontrée ;
  • le type de voies empruntées ;
  • la pente ;
  • la pertinence des tronçons par rapport au moyen de locomotion demandé.

La pertinence peut s’avérer importante (si les données sont présentes dans OSM) lors d’un routage en chaise roulante ou en vélo, par exemple.

Isochrones

Le service vous permet de voir une estimation des isochrones à partir d’un lieu donné et avec un moyen de locomotion donné. Une isochrone est une ligne à une distance ou un temps donné du point d’origine.

Par défaut, il est possible de voir l’isochrone de 30 et 60 minutes, mais il est possible de changer cela assez facilement.

API développeurs

Tout ce service est accessible via des API en libre accès, mais avec un nombre de transactions limités pour éviter la surcharge du service. Pour cela, n’oubliez‐pas de demander une clef.

Conclusion

OpenRouteService est un service de routage qui fonctionne plutôt bien et basé sur les données d’OSM. Je suis ce service depuis quelques années et il devient meilleur de jour en jour.

Si vous ne l’avez pas essayé, jetez‐y un coup d’œil et dites ce que vous en pensez !

Télécharger ce contenu au format Epub

Lire les commentaires

Prédire la note d’un journal sur LinuxFr.org

9 juin, 2017 - 09:30

Cette dépêche traite de l’exploration de données sur des données issues de LinuxFr.org.

Ayant découvert récemment scikit-learn, une bibliothèque Python d’apprentissage statistique (machine learning). Je voulais partager ici un début d’analyse sur des contenus issus de LinuxFr.org.

Avertissement : je ne suis pas programmeur, ni statisticien. Je ne maîtrise pas encore tous les arcanes de scikit-learn et de nombreux éléments théoriques m’échappent encore. Je pense néanmoins que les éléments présentés ici pourront en intéresser plus d’un(e).

Tous les scripts sont codés en Python et l’analyse à proprement parler a été réalisée à l’aide d’un notebook Jupyter. Un dépôt contenant les données et les scripts est disponible sur GitLab.

Sommaire Prédire la note d’un journal

Il y a eu récemment une vague de journaux politiques sur DLFP. La note de la plupart de ces journaux était assez basse. Par ailleurs, on lit régulièrement ici des personnes qui se plaignent de la note de leurs articles. Bien souvent, des gens postent des contenus incendiaires, parfois en rafale. Je me suis demandé si cela est évitable.

Est-il possible de prédire la note d'un journal en fonction de son contenu? Le problème est ambitieux mais il permettrait aux auteurs d'avoir une idée de l’accueil qui sera réservé à leur prose.

Prédire un score me paraît hasardeux, c'est pourquoi j'ai préféré classer les journaux dans 4 catégories en fonction de leur note, n (en english car il est bien connu que ça improve la productivitaÿ) :

  • n < -20 : Magnificent Troll ;
  • -20 < n < 0 : Great Troll ;
  • 0 < n < 20 : Average Troll ;
  • 20 < n : Qualitaÿ Troll.

Vous l'aurez compris, tout contenu est un Troll, car je pense que nous sommes tous le troll d'un autre.

Obtenir les données

Il n'existe pas à ma connaissance de base de données de DLFP disponible pour tests. Après avoir lu deux journaux précédents, j'ai décidé de construire une moulinette afin d'aspirer une partie du contenu.

Approche 1: le flux atom

Dans un premier temps, j'ai utilisé le flux atom des journaux à l'aide de la bibliothèque feedparser. Le script fonctionne et l'approche est très simple mais malheureusement, la quantité de données est trop limitées. Par ailleurs, le score d'un contenu n'est pas disponible dans les flux. J'ai donc changé mon fusil d'épaule.

Approche 2: l'heure de la soupe

Afin d'augmenter le volume de données, il faut parcourir la page https://linuxfr.org/journaux?page=x et collecter tous les liens vers les différents journaux. Chaque journal est ensuite analysé. Dans un premier temps, les informations suivantes sont utilisées : le nom de l'auteur, le titre du journal, l'URL, le contenu du journal, sa note.

La moulinette s'appuie sur la bibliothèque Beautiful Soup4. Les données sont enregistrées dans un fichier CSV. Étant donné que le contenu des journaux est très varié, j'ai choisi les caractères µ et £ en tant que délimiteur et séparateur, respectivement.

Analyse des données

L'analyse suivante est réalisée à l'aide du fichier diaries_classification.ipynb. La lecture du fichier CSV linuxfr.csv montre qu'il contient 5921 journaux. 302 Magnificents Trolls, 460 Great Trolls, 2545 Quality Trolls et 2614 Average Trolls. Étant donné que les données sont déséquilibrées, il faudra en tenir compte dans les travaux car ces chiffres influencent les probabilités.

import matplotlib.pyplot as plt import pandas as pd import numpy as np import sys import matplotlib # Enable inline plotting %matplotlib inline filename = r'linuxfr.csv' lf_data = pd.read_csv(filename, encoding="UTF-8", sep='£', engine='python', quotechar='µ') len(lf_data) 5921 lf_data.quality_content.value_counts() Average Troll 2614 Quality Troll 2545 Great Troll 460 Magnificent Troll 302 Name: quality_content, dtype: int64 lf_data.quality_content.value_counts().plot(kind='bar') plt.ylabel('Occurences', fontsize='xx-large') plt.yticks(fontsize='xx-large') plt.xlabel('Trolls', fontsize='xx-large') plt.xticks(fontsize='xx-large')

Au passage, on observe qu'il y a beaucoup plus de contenu de qualité (pertinent), dont le score est positif que de négatif. Ou encore, qu'il y a beaucoup plus de contenu avec lequel les votants sont d'accord.

L’affaire est dans le sac (de mots)

À ce stade, j'ai suivi la documentation officielle de scikit-learn. L'analyse de texte est le plus souvent basée sur un algorithme de type "Bag of words". Chaque mot est compté dans le texte. On est alors en mesure de tracer un histogramme du nombre d’occurrence des mots en fonction de la liste des mots du dictionnaire. Dans scikit-learn, l'utilisation d'un sac de mots est très simple. Il faut faire appel à la classe CountVectorizer. Ma base de 5921 journaux contient 78879 mots différents.

import numpy as np from sklearn.feature_extraction.text import CountVectorizer count_vect = CountVectorizer() X_train_counts = count_vect.fit_transform(lf_data['content'].values) X_train_counts.shape (5921, 78879) Utiliser les fréquences d'apparition des mots

L'inconvénient du comptage de mots est qu'il entraîne un déséquilibre entre les textes de longueur différente. Il est possible de calculer les fréquences (tf) et éventuellement diminuer l'impact des mots qui apparaissent dans beaucoup de documents tels que les pronoms (tf-idf). L'utilisation de ces algorithmes est tout aussi simple :

from sklearn.feature_extraction.text import TfidfTransformer tf_transformer = TfidfTransformer(use_idf=False).fit(X_train_counts) X_train_tf = tf_transformer.transform(X_train_counts) Classifier les articles Approche naïve : filtrage bayésien

La manière la plus simple d'analyser les articles est d'utiliser la classification naïve bayésienne. Wikipedia éclaire un peu plus les concepts sous-jacents :

En termes simples, un classificateur bayésien naïf suppose que l'existence d'une caractéristique pour une classe, est indépendante de l'existence d'autres caractéristiques. Un fruit peut être considéré comme une pomme s'il est rouge, arrondi, et fait une dizaine de centimètres. Même si ces caractéristiques sont liées dans la réalité, un classificateur bayésien naïf déterminera que le fruit est une pomme en considérant indépendamment ces caractéristiques de couleur, de forme et de taille.

Une fois le modèle entraîné (fonction fit, d'adéquation en français), il est possible de prédire à quelle catégorie des articles appartiennent.

from sklearn.naive_bayes import MultinomialNB classifier = MultinomialNB() classifier.fit(X_train_tfidf, targets) training_journals = ['Sécuriser son serveur avec la commande sudo rm -rf /*', 'Debian is dying', 'Windows Millenium est meilleur que Linux sur calculatrice graphique', "MultiDeskOS est 42% plus performant que Redhat 3.0.3 (Picasso)", "Pierre Tramo président !", "Des chocolatines au menu des cantines situées dans les DOM-TOM", "1515, l’année du Desktop Linux!"] X_new_counts = count_vect.transform(training_journals) X_new_tfidf = tfidf_transformer.transform(X_new_counts) predicted = classifier.predict(X_new_tfidf) for doc, category in zip(training_journals, predicted): print('%r => %s' % (doc, category)) 'Sécuriser son serveur avec la commande sudo rm -rf /*' => Quality Troll 'Debian is dying' => Quality Troll 'Windows Millenium est meilleur que Linux sur calculatrice graphique' => Quality Troll 'MultiDeskOS est 42% plus performant que Redhat 3.0.3 (Picasso)' => Average Troll 'Pierre Tramo président !' => Average Troll 'Des chocolatines au menu des cantines situées dans les DOM-TOM' => Quality Troll '1515, l’année du Desktop Linux!' => Average Troll

La commande predict_proba permet d'afficher les probabilités. Il en ressort que la marge d'erreur est énorme.

predicted_proba = classifier.predict_proba(X_new_tfidf) print(targets_names) predicted_proba ['Average Troll', 'Great Troll', 'Magnificent Troll', 'Quality Troll'] array([[ 0.38146407, 0.01242555, 0.00699732, 0.59911306], [ 0.45180296, 0.03300345, 0.01880854, 0.49638505], [ 0.37809693, 0.0190014 , 0.00917897, 0.5937227 ], [ 0.47083803, 0.0629247 , 0.02837355, 0.43786371], [ 0.54130358, 0.04642992, 0.03861831, 0.37364818], [ 0.45172753, 0.03297976, 0.01805764, 0.49723507], [ 0.59237292, 0.01164186, 0.00420374, 0.39178148]])

Mes "journaux" sont beaucoup trop courts pour être représentatifs, enfin cela dépend de la définition de "contenu de qualité". Par conséquent, il faut tester le modèle sur l'archive des contenus, dans un premier temps. Pour y arriver, je définis un pipeline qui consiste à assembler les étapes décrites précédemment dans un objet qui se comporte comme un classificateur.

from sklearn.pipeline import Pipeline text_clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()), ('clf', MultinomialNB()),]) Tester le modèle avec les journaux connus

Je commence par échantillonner 20 % des journaux de la base de données et je teste le modèle sur cet ensemble, afin de voir s'il est capable de retrouver la bonne catégorie.

diaries_test = lf_data.sample(frac=0.2) predicted = text_clf.predict(diaries_test['quality_content']) from sklearn.metrics import confusion_matrix, f1_score score = f1_score(diaries_test['quality_content'], predicted, average='weighted') print('Diaries:', len(diaries_test)) print('Score:', score) Diaries: 5921 Score: 0.269979533821 /usr/lib/python3.6/site-packages/sklearn/metrics/classification.py:1113: UndefinedMetricWarning: F-score is ill-defined and being set to 0.0 in labels with no predicted samples. 'precision', 'predicted', average, warn_for)

Ça ne marche pas du tout. La raison pour laquelle ce message est affiché est que le paramètre F (score F1) est indéterminé. Ce paramètre est un estimateur de la qualité d'une classification. Il dépend de la précision et du rappel. Une image vaut mieux qu'un long discours, le dessin sur la page wikipedia :

La matrice de confusion permet de comprendre pourquoi le score F est si mauvais : mis à part pour les trolls de qualité, je n'ai pas de vrai positif !

Pour lire le graphique : la prédiction parfaite aurait 100 % sur chaque case de la diagonale. C'est le cas ici des qualitaÿ trolls qui sont tous bien identifiés. Mais il y a un biais vers les qualitaÿ trolls. L'algorithme interprète ainsi erronément 100 % des average trolls comme des qualitaÿ trolls par exemple.


Au passage, j'affiche la matrice de confusion à l'aide du code de la documentation officielle.

Mon classificateur est mauvais. Il est probablement possible d'en améliorer les performances mais j'ai préféré changer d’algorithme.

Support vector machine (SVM)

D'après la documentation officielle, il s'agit de l’algorithme de classification de texte le plus performant pour le texte. SGDClassifier est basé sur un classificateur linéaire et un algorithme du gradient stochastique (abréviation SGD). Je vous avoue ne pas encore maîtriser ces subtilités. Si quelqu'un à l'aise avec ces notions veut participer à la discussion, il est le bienvenu.

from sklearn.linear_model import SGDClassifier text_clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()), ('clf', SGDClassifier()),]) _ = text_clf.fit(lf_data.content, lf_data.quality_content) predicted = text_clf.predict(diaries_test.content) np.mean(predicted == diaries_test.quality_content) 0.95

Le score est très bon. Il est possible d'afficher plus d'informations à propos des prédictions :

from sklearn import metrics print(metrics.classification_report(diaries_test.quality_content, predicted, target_names=targets_names)) precision recall f1-score support Average Troll 0.99 0.93 0.96 523 Great Troll 1.00 0.94 0.97 80 Magnificent Troll 1.00 0.94 0.97 72 Quality Troll 0.92 0.99 0.96 509 avg / total 0.96 0.96 0.96 1184 # Affichage de la matrice de confusion metrics.confusion_matrix(diaries_test.quality_content, predicted) # Compute confusion matrix import itertools cnf_matrix = confusion_matrix(diaries_test['quality_content'], predicted) np.set_printoptions(precision=2) # Plot non-normalized confusion matrix plt.figure() plot_confusion_matrix(cnf_matrix, classes=targets_names, title='Confusion matrix, without normalization') # Plot normalized confusion matrix plt.figure() plot_confusion_matrix(cnf_matrix, classes=targets_names, normalize=True, title='Normalized confusion matrix') plt.show() Confusion matrix, without normalization Confusion matrix, without normalization [[489 0 0 34] [ 2 75 0 3] [ 0 0 68 4] [ 5 0 0 504]] Normalized confusion matrix [[ 0.93 0. 0. 0.07] [ 0.03 0.94 0. 0.04] [ 0. 0. 0.94 0.06] [ 0.01 0. 0. 0.99]]


Validation croisée

Ces résultats sont très intéressants mais il est important de tester la solidité du modèle. Cette étape est appelée validation croisée. scikit-learn permet de réaliser ces tests de manière automatisée. L'idée est d’échantillonner une partie des journaux (10 % dans notre cas), d'entraîner le modèle sur les 90 % restant et de tester le modèle sur ces 10 % "caché". On affiche ensuite les scores pondérés en fonction du nombre d’occurrence de journaux dans chaque catégorie.

from sklearn.model_selection import cross_val_score scores = cross_val_score(text_clf, # steps to convert raw messages into models lf_data.content, # training data lf_data.quality_content, # training labels cv=10, # split data randomly into 10 parts: 9 for training, 1 for scoring scoring='accuracy', # which scoring metric? n_jobs=-1, # -1 = use all cores = faster ) print(scores) print('Total diaries classified:', len(lf_data)) print('Score:', sum(scores)/len(scores)) [ 0.54 0.53 0.55 0.55 0.56 0.57 0.54 0.52 0.56 0.56] Total diaries classified: 5921 Score: 0.548226957256

Le score est égal à 0.55. Ce n'est pas terrible. Si on préfère afficher la matrice de confusion, il faut utiliser les Kfold qui reposent sur le même principe que cross_val_score et implémenter une boucle.

from sklearn.model_selection import KFold from sklearn.metrics import confusion_matrix, f1_score,precision_score k_fold = KFold(n_splits=10) scores = [] confusion = np.array([[0, 0,0,0], [0, 0,0,0], [0, 0,0,0], [0, 0,0,0]]) for train_indices, test_indices in k_fold.split(lf_data): train_text = lf_data.iloc[train_indices]['content'].values train_y = lf_data.iloc[train_indices]['quality_content'].values test_text = lf_data.iloc[test_indices]['content'].values test_y = lf_data.iloc[test_indices]['quality_content'].values text_clf.fit(train_text, train_y) predictions = text_clf.predict(test_text) confusion += confusion_matrix(test_y, predictions) score = f1_score(test_y, predictions, average='weighted') ps = precision_score(test_y, predictions, average='weighted') scores.append(score) print('Total diaries classified:', len(lf_data)) print('Score:', sum(scores)/len(scores)) print('Confusion matrix:') print(confusion) Total diaries classified: 5921 Score: 0.519244446873 Confusion matrix: [[1475 22 13 1104] [ 253 11 16 180] [ 164 15 26 97] [ 794 7 8 1736]] scores [0.48812704076867125, 0.50096444244611738, 0.53296513209879548, 0.50865953156976373, 0.53358760110311787, 0.52464153844229733, 0.53897239391380014, 0.5090212038928732, 0.5340084448235829, 0.5214971396677468]


Comme on le voit, les résultats sont très mauvais. Environ 44 % des journaux "Average Troll" sont attribués à la classe "Quality Troll" ! Si les auteurs suivent la même logique que cet algorithme, ils ont tendance à sur-estimer fortement leurs écrits. De même, 30 % des "Quality Troll" sont attribués à la classe "Average Troll". En suivant cette logique, les auteurs de contenu de qualité auraient tendance à se sous-estimer. Par ailleurs, il faut noter que ces classes sont voisines : score de 0 à 20 et de 20 à l'infini (et au delà).

Plus inquiétant : les contenus avec un score négatif sont attribués majoritairement aux classes à score positif. Un auteur de contenu moinsé qui penserait comme la machine serait persuadé que son texte est de qualité. Il ne comprendrait pas le score négatif qui en résulte.

Optimisation des paramètres

Et si nos mauvais résultats étaient dus au choix d'un mauvais jeu de paramètres de départ ? Le pipeline choisi dépend de nombreux paramètres ajustables. Scikit-learn permet d'optimiser ces paramètres facilement afin de trouver le meilleur compromis.

from sklearn.linear_model import SGDClassifier text_clf = Pipeline([('vect', CountVectorizer()), ('tfidf', TfidfTransformer()), ('clf', SGDClassifier()),])

Les paramètres ajustables sont précédés du nom de l'étape correspondante. Les explications concernant ces paramètres sont disponibles dans la documentation officielle :

sorted(text_clf.get_params().keys()) ['clf', 'clf__alpha', 'clf__average', 'clf__class_weight', 'clf__epsilon', 'clf__eta0', 'clf__fit_intercept', 'clf__l1_ratio', 'clf__learning_rate', 'clf__loss', 'clf__n_iter', 'clf__n_jobs', 'clf__penalty', 'clf__power_t', 'clf__random_state', 'clf__shuffle', 'clf__verbose', 'clf__warm_start', 'steps', 'tfidf', 'tfidf__norm', 'tfidf__smooth_idf', 'tfidf__sublinear_tf', 'tfidf__use_idf', 'vect', 'vect__analyzer', 'vect__binary', 'vect__decode_error', 'vect__dtype', 'vect__encoding', 'vect__input', 'vect__lowercase', 'vect__max_df', 'vect__max_features', 'vect__min_df', 'vect__ngram_range', 'vect__preprocessor', 'vect__stop_words', 'vect__strip_accents', 'vect__token_pattern', 'vect__tokenizer', 'vect__vocabulary']

Le code ci-dessous permet d'ajuster les paramètres suivants :

Évidemment, le temps de calcul dépend du nombre de paramètres à ajuster. Les autres paramètres sont laissés à leur valeur par défaut.

params = { 'tfidf__use_idf': (True, False), 'clf__loss':('huber', 'modified_huber', 'epsilon_insensitive', 'hinge', 'log'), 'clf__alpha':(1,0.001, 0.00001),} gs_clf = GridSearchCV(text_clf, params, n_jobs=-1, verbose=0, refit=True,scoring='accuracy',) print("Performing grid search...") print("pipeline:", [name for name, _ in text_clf.steps]) print("parameters:") print(params) t0 = time() gs_clf = gs_clf.fit(lf_data.content, targets) print("done in %0.3fs" % (time() - t0)) print() print("Best score: %0.3f" % gs_clf.best_score_) print("Best parameters set:") best_parameters = gs_clf.best_estimator_.get_params() for param_name in sorted(params.keys()): print("\t%s: %r" % (param_name, best_parameters[param_name]))

Ce qui donne :

Performing grid search... pipeline: ['vect', 'tfidf', 'clf'] parameters: {'tfidf__use_idf': (True, False), 'clf__loss': ('huber', 'modified_huber', 'epsilon_insensitive', 'hinge', 'log'), 'clf__alpha': (1, 0.001, 1e-05)} done in 108.027s Best score: 0.547 Best parameters set: clf__alpha: 0.001 clf__loss: 'modified_huber' tfidf__use_idf: True

Malheureusement, le score semble encore assez bas. Par ailleurs, le meilleur estimateur est également disponible pour utilisation future :

gs_clf.best_estimator_ Pipeline(steps=[('vect', CountVectorizer(analyzer='word', binary=False, decode_error='strict', dtype=<class 'numpy.int64'>, encoding='utf-8', input='content', lowercase=True, max_df=1.0, max_features=None, min_df=1, ngram_range=(1, 1), preprocessor=None, stop_words=None, strip... penalty='l2', power_t=0.5, random_state=None, shuffle=True, verbose=0, warm_start=False))]) Test sur un échantillon de données connues

Comme précédemment, il est possible de tester le modèle sur un échantillon de données connues. L'ajustement a été réalisé avec le meilleur jeu de paramètres grâce à l'option refit=True passée à GridSearchCV. Les résultats du score F1 sont encore une fois très bons mais l'amélioration du score est nulle : il plafonne entre 0.95 et 0.96.

print(metrics.classification_report(diaries_test.quality_content, predicted, target_names=targets_names)) precision recall f1-score support Average Troll 0.99 0.93 0.96 523 Great Troll 1.00 0.94 0.97 80 Magnificent Troll 1.00 0.94 0.97 72 Quality Troll 0.92 0.99 0.96 509 avg / total 0.96 0.96 0.96 1184

De même, la matrice de confusion est excellente :

Test sur un échantillon de données inconnues

Pour aller plus loin, j'ai testé le modèle sur de nouvelles données (des journaux plus anciens). Ces données ne font pas partie de mes journaux de base. En principe, le résultat sera similaire à ce qu'on obtient par validation croisée mais cette technique a pour avantage d'augmenter la taille de la base de journaux disponibles. Une autre possibilité consiste à relancer la validation croisée après avoir fusionné ces nouvelles données aux anciennes.

filename = r'out_of_sample.csv' lf_out = pd.read_csv(filename, encoding="UTF-8", sep='£', engine='python', quotechar='µ') lf_out = lf_out.reindex(np.random.permutation(lf_out.index)) lf_out.quality_content.value_counts().plot(kind='bar') plt.ylabel('Occurences', fontsize='xx-large') plt.yticks(fontsize='xx-large') plt.xlabel('Trolls', fontsize='xx-large') plt.xticks(fontsize='xx-large')

Ces nouvelles données sont similaires aux journaux déjà disponibles.

predicted_out = text_clf.predict(lf_out.content) np.mean(predicted_out == lf_out.quality_content) score_out = f1_score(lf_out['quality_content'], predicted_out, average='weighted') print('Diaries:', len(lf_out)) print('Score:', score_out) cnf_matrix_out = confusion_matrix(lf_out['quality_content'], predicted_out) np.set_printoptions(precision=2) # Plot non-normalized confusion matrix plt.figure() plot_confusion_matrix(cnf_matrix_out, classes=targets_names, title='Confusion matrix, without normalization') # Plot normalized confusion matrix plt.figure() plot_confusion_matrix(cnf_matrix_out, classes=targets_names, normalize=True, title='Normalized confusion matrix') plt.show() print(metrics.classification_report(lf_out.quality_content, predicted_out, target_names=targets_names)) Diaries: 1500 Score: 0.444809984556 Confusion matrix, without normalization [[452 9 10 457] [ 90 4 0 52] [ 42 5 6 26] [126 2 0 219]] Normalized confusion matrix [[ 0.49 0.01 0.01 0.49] [ 0.62 0.03 0. 0.36] [ 0.53 0.06 0.08 0.33] [ 0.36 0.01 0. 0.63]]


precision recall f1-score support Average Troll 0.64 0.49 0.55 928 Great Troll 0.20 0.03 0.05 146 Magnificent Troll 0.38 0.08 0.13 79 Quality Troll 0.29 0.63 0.40 347 avg / total 0.50 0.45 0.44 1500

Malheureusement, le résultat n'est pas bon. Encore une fois, le modèle ne peut pas s'adapter à des données inconnues. Il s'agit d'un cas assez probant de surapprentissage. L'image suivante illustre bien le problème. En cherchant à classer correctement les éléments dans la bonne catégorie, le modèle se contorsionne et ne tient pas compte de la tendance "globale".

Utiliser des propriétés multiples

Bien qu'elle soit informative, l'analyse ne permet pas de prédire la catégorie avec un score supérieur à 0,5. Pour l'instant, le classificateur se comporte comme un mauvais élève pressé d'aller jouer un match de tennis après son examen Q.C.M. : il répond la même chose (la réponse D) à toutes les questions en se disant qu'il obtiendra bien la moitié. Évidemment, cela ne fonctionne pas. L'approche "bag of words" seule ne suffit pas pour classer des journaux. Les bons journaux ne sont pas tous techniques, de même que les mauvais ne sont pas tous "politiques" (quoiqu'un journal sur l'avortement part en général très mal). Le sujet d'un journal n'est pas corrélé avec sa note finale. D'autres indicateurs doivent être pris en compte : ancienneté du compte au moment de la soumission, taille du texte (les journaux trop courts sont parfois descendu, tout comme les 'journaux fleuve parfois hallucinés' dixit oumph). scikit-learn permet de combiner plusieurs propriétés (appelées "features"), de déterminer celles qui ont le plus gros impact sur les résultats et d'ajuster un modèle en tenant compte des propriétés sélectionnées.

Extraction et préparation des données

L'analyse suivante repose sur l'utilisation des données présentes dans le fichier linuxfr_complete.csv. Elle correspond au notebook diaries_classification_2.ipynb. En plus des données présentes dans le fichier linuxfr.csv, ce document comporte les champs suivant :

  • la date de création du journal ;
  • la date de création du compte ;
  • les scores précédents de l'auteur (première page des anciennes publications) ;
  • la longueur du document.
import matplotlib.pyplot as plt import pandas as pd import numpy as np import sys import matplotlib # Enable inline plotting %matplotlib inline filename = r'linuxfr_complete.csv' lf_data = pd.read_csv(filename, encoding="UTF-8", sep='£', engine='python', quotechar='µ') Conversion des dates

Panda permet très facilement de convertir une chaîne de caractère correspondant à une date au format datetime.

lf_data['birthday'] = pd.to_datetime(lf_data['birthday']) lf_data['birthday'].head() 0 2004-08-28 1 2003-04-22 2 2004-02-14 3 2012-10-22 4 2009-10-05 Name: birthday, dtype: datetime64[ns] lf_data['datetime'] = pd.to_datetime(lf_data['datetime']) lf_data['datetime'].head() 0 2017-05-28 12:59:46 1 2017-05-28 09:57:04 2 2017-05-28 08:24:57 3 2017-05-27 14:18:10 4 2017-05-26 20:12:47 Name: datetime, dtype: datetime64[ns] Évolution du score des journaux au fil du temps score_df = lf_data[['datetime', 'score']].copy() score_df.index = score_df['datetime'] del score_df['datetime']

L'évolution des scores au fil du temps est alors facilement affichable. Je trouve personnellement qu'on n'a pas trop à se plaindre : la qualité générale des journaux est plutôt bonne.

score_df.plot(marker='o', grid=True, figsize=(15,9)) plt.ylabel('Score', fontsize='xx-large') plt.yticks(fontsize='xx-large') plt.xlabel('Date', fontsize='xx-large') plt.xticks(fontsize='xx-large')

Calcul de l’âge d’un compte

L'âge d'un compte peut facilement être calculé en soustrayant la date de création du compte à la date de création du journal. Pour une raison inconnue, cet âge est parfois négatif. Le code suivant tient compte de ce souci. Un compte qui a moins d'un jour se voit affublé de la propriété "Newbie".

lf_data['age'] = lf_data['datetime']-lf_data['birthday'] lf_data['newbie'] = False for index, line in lf_data.iterrows(): # Problem: sometimes, age << 0 if line['age'] < pd.Timedelta("0 day"): line['age'] = - line['age'] if line['age'] < pd.Timedelta("1 day"): lf_data.set_value(index, 'newbie', True) Qualité des posts des nouveaux

Il est à présent possible d'extraire les informations relatives aux nouveaux comptes (à la date de publication). Ces comptes sont à l'origine de contenu de qualité étonnante. On retrouve une grande quantité de très mauvais contenu ("magnificent troll") mais également de bons et très bons contenus ("quality troll" et "average troll").

noob = lf_data.loc[lf_data['newbie'] == True] noob.quality_content.value_counts().plot(kind='bar') plt.ylabel('Occurences', fontsize='xx-large') plt.yticks(fontsize='xx-large') plt.xlabel('Trolls', fontsize='xx-large') plt.xticks(fontsize='xx-large')

Calcul de la moyenne des scores précédents

Afin de tenir compte de l'historique d'un compte, deux colonnes sont ajoutées : la médiane et la moyenne. Les scores précédents sont conservés dans la colonne author_previous_scores. L'information, une chaîne de caractère sous la forme "[1,15,42,-12]", doit être extraite.

lf_data['median_score'] = 0 lf_data['average_score'] = 0 import statistics for index, line in lf_data.iterrows(): ps = line['author_previous_scores'] #print(ps) ps = ps.replace("[",'') ps = ps.replace("]",'') ps = ps.replace(",",'') ps = ps.split() ps = [float(x) for x in ps] median = statistics.median(ps) try: avg = statistics.mean(ps) except TypeError: avg = np.NaN lf_data.set_value(index, 'median_score', median) lf_data.set_value(index, 'average_score', avg)

La plupart du temps, la médiane et la moyenne sont très proches. Dans de rares cas, elles diffèrent beaucoup mais la moyenne est plus sévère que la médiane.

Garder l’essentiel

Les informations nécessaires pour réaliser une analyse plus complète sont à présent disponibles. Pour plus de facilité, de nouveaux dataframes sont créés en éliminant les colonnes inutiles.

lf = lf_data[['content','newbie','average_score', 'quality_content', 'score', 'count', 'author']].copy() target = lf_data[['quality_content']].copy() L’union fait la force

Maintenant que je dispose d'un dataframe contenant mes variables (lf) et un autre contenant mes catégories attendues (target), il faut que je crée une procédure permettant d'effectuer les bonnes tâches avec le bon jeu de données :

  1. Les données numériques sont utilisées telles quelles.
  2. Le corps de l'article est vectorisé et la fréquence des mots est calculée.
  3. Le nom de l'auteur est vectorisé également.

Ces trois étapes sont unies dans un object FeatureUnion dans un pipeline dont la dernière étape est un classificateur de type linéaire (SVC(kernel='linear')). Encore une fois, les fonctions .fit et .predict sont accessibles depuis le pipeline pour faciliter son utilisation.

La classe MultipleItemSelector permet d'extraire les données nécessaires à chaque étape.

Enfin, un poids est appliqué à chaque étape. Pour l'instant, il est égal sur les trois étapes mais des valeurs différentes ont donné des résultats similaires :

  • 'author': 0.8 ;
  • 'content': 0.5 ;
  • 'num_values': 1.0.
# From http://scikit-learn.org/stable/auto_examples/hetero_feature_union.html import numpy as np from sklearn.base import BaseEstimator, TransformerMixin from sklearn.datasets import fetch_20newsgroups from sklearn.datasets.twenty_newsgroups import strip_newsgroup_footer from sklearn.datasets.twenty_newsgroups import strip_newsgroup_quoting from sklearn.decomposition import TruncatedSVD from sklearn.feature_extraction import DictVectorizer from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.metrics import classification_report from sklearn.pipeline import FeatureUnion from sklearn.pipeline import Pipeline from sklearn.svm import SVC class MultipleItemSelector(BaseEstimator, TransformerMixin): def __init__(self, keys): self.keys = keys def fit(self, x, y=None): return self def transform(self, data_dict): return data_dict[self.keys] pipeline = Pipeline([ # Extract the subject & body #('subjectbody', DataExtractor()), # Use FeatureUnion to combine the features from subject and body ('union', FeatureUnion( transformer_list=[ # Pipeline for pulling features from the post's subject line ('author', Pipeline([ ('selector', MultipleItemSelector(keys='author')), ('tfidf', TfidfVectorizer(min_df=50)), ])), # Pipeline for standard bag-of-words model for body ('content', Pipeline([ ('selector', MultipleItemSelector(keys='content')), ('tfidf', TfidfVectorizer()), ('best', TruncatedSVD(n_components=50)), ])), # Pipeline dealing with numerical values stored in a dict ('num_values', Pipeline([ ('selector', MultipleItemSelector(keys=['score', 'newbie', 'average_score', 'count'])) , # list of dicts -> feature matrix ])), ], # weight components in FeatureUnion transformer_weights={ 'author': 1.0, # 0.8 'content': 1.0, # 0.5 'num_values': 1.0, # 1.0 }, )), # Use a SVC classifier on the combined features ('svc', SVC(kernel='linear')), ]) #pipeline.fit(lf, target.values.ravel()) Validation croisée

Afin de valider le comportement du classificateur, la validation croisée est effectuée avec 10 échantillons. Cette fois, les résultats sont vraiment très bons.

from sklearn.model_selection import cross_val_score scores = cross_val_score(pipeline, # steps to convert raw messages into models lf, # training data target.values.ravel(), # training labels cv=10, # split data randomly into 10 parts: 9 for training, 1 for scoring #scoring='accuracy', # which scoring metric? scoring='f1_weighted', n_jobs=-1, # -1 = use all cores = faster ) print(scores) print('Total diaries classified:', len(lf_data)) print('Score:', sum(scores)/len(scores)) [ 1. 1. 1. 1. 1. 1. 1. 0.99831646 0.99831646 1. ] Total diaries classified: 5955 Score: 0.999663292104

Afin de valider le comportement exceptionnel de ce classificateur, un test est réalisé avec des données qu'il ne connaît pas du tout : des journaux plus anciens.

Données hors échantillon.

La prédiction à l'aide de journaux anciens permet de vérifier que le modèle se comporte bien. Si c'est le cas, cela permet également d'affirmer que le type de contenu pertinent/inutile n'a pas radicalement changé ces dernières années.

Les données analysées dans cette section correspondent au fichier out_of_sample_complete.csv. La liste des journaux est sensiblement la même que celle utilisée dans le paragraphe Test sur un échantillon de données inconnues.

Les images ci-dessous montrent que la distribution temporelle de scores est similaire aux données plus récentes. La matrice de confusion et le score confirment les résultats obtenus à l'aide de la validation croisée. Le but est atteint. Il est possible de prédire la catégorie dans laquelle se trouve un journal à partir de son contenu et du nom de l'auteur. 1




Diaries: 1485 Score: 1.0 from sklearn import metrics print(metrics.classification_report(Y_out, predicted_out, target_names=targets_names)) precision recall f1-score support Average Troll 1.00 1.00 1.00 917 Great Troll 1.00 1.00 1.00 145 Magnificent Troll 1.00 1.00 1.00 77 Quality Troll 1.00 1.00 1.00 346 avg / total 1.00 1.00 1.00 1485 Pour aller plus loin

Scikit-learn dispose de nombreuses autres possibilités pour traiter des données de tout type. Je citerai la sélection des propriétés (feature selection) qui permet d’éliminer les propriétés dont la variance est inférieure à un seuil donné. Dans ce cas, la propriété est considérée comme une constante. L'intérêt est de diminuer le temps de calcul et le risque de sur-apprentissage. Un test rapide sur les données issues des journaux a montré que toutes les données sont utiles pour déterminer la catégorie d'un journal.

Choisir le bon algorithme peut être très difficile selon les informations désirées et le type de données. L'aide-mémoire suivant permet de faciliter ce choix. Une version interactive est également disponible.

Enfin, je terminerai en mentionnant la possibilité de sauver un modèle entraîné. Cela permet d'éviter de devoir repasser par l'opération d'apprentissage qui peut être consommatrice de ressources. Le fichier généré pour le modèle le plus efficace de cette dépêche fait 46 Mo.

from sklearn.externals import joblib joblib.dump(pipeline, 'linuxfr_pipeline.pkl')

Plus tard ou sur une autre machine:

from sklearn.externals import joblib pipeline = joblib.load('linuxfr_pipeline.pkl')

La documentation mentionne des considérations à prendre en compte.

  • Il existe un risque de sécurité dans le cas où on charge des données car cela pourrait mener à l'exécution de code malicieux ;
  • la comptabilité entre versions n'est pas prise en compte ;
  • il est important de laisser à disposition un jeu de données types, le score de validation du modèle associé et le code afin que la personne qui reçoit le modèle puisse vérifier les résultats obtenus.
Conclusions

Au cours de cette expérience, une moulinette a été codée afin d'aspirer le contenu des journaux.

Les données ont été analysées en deux temps. Dans la première phase, la vectorisation du contenu des journaux a été réalisée. Il a été montré que cette étape ne suffit pas à pouvoir classer correctement du contenu inconnu. Dans une seconde phase, le nom de l'auteur, la date de publication, la date de création du compte, l'historique récente des scores des publications de l'auteur ont été pris en compte et assemblés dans un pipeline d'analyse. Les résultats ont montré qu'il est possible de prédire la catégorie dans laquelle se trouve un journal à partir de son contenu et du nom de l'auteur. Le taux d'erreur est inférieur à 1/1000. Par ailleurs, l'optimisation des paramètres des classificateurs ainsi que la validation croisées ont été présentées.

L'analyse prédictive des scores permettra plusieurs grandes avancées sur le site. La première et la plus évidente sera la possibilité de renvoyer un lien vers cette dépêche chaque fois qu'un contributeur se plaindra de la note réservée à sa prose. Il s'agit là de l'argument ultime qui ne manquera pas de faire taire les trolls devant tant d'autorité. La seconde avancée sera la possibilité pour un contributeur d'améliorer ses journaux afin d'atteindre à chaque fois la catégorie visée. Provoquer un séisme de moinsage ou atteindre le summum de l'excellence ne s'improvise pas et scikit-learn permettra à chacun d'évaluer différentes variantes de ses journaux afin de poster la "meilleure". La troisième avancée concerne les journaux qui ne peuvent pas avoir été élaboré par un esprit humain. Ils sont probablement générés par une machine. Les plaisantins pourront améliorer les textes de leur programme en utilisant le modèle présenté afin de rendre la lecture du contenu plus agréable. La note finale s'en ressentira.

Pour terminer, je dirai qu'il est possible de rapidement effectuer des analyses de données avec scikit-learn. La syntaxe est très simple pour les personnes connaissant Python. Les concepts sont assez compliqués, mais la mise en œuvre est très bien faite et la documentation officielle est complète. Mais, tous ces éléments positifs ne garantissent pas des résultats probants et immédiats. Comme dans toute matière complexe, il faut comprendre ce qu'on fait pour obtenir des résultats qui ont du sens (et être en mesure de les analyser).

Perspectives

Plusieurs pistes de réflexion pourront permettre de poursuivre l'analyse :

  • Le découpage des catégories est arbitraire (bornes -20 et + 20) ; en modifiant la répartition des données, les résultats seront probablement différents (exemples : répartitions en quartiles, score strictement positifs ou négatifs, etc.) ;
  • au vu des résultats obtenus, la prédiction du score (valeur numérique) est envisageable ;
  • les catégories ne sont pas équitablement peuplées, le nombre de journaux à score négatif est beaucoup plus faible dans ce cas ; pour y remédier, nous avons besoin de plus de journaux de mauvaise qualité abondamment moinssés. À vos claviers !
  • La classification par un système d'arbre en limitant leur profondeur n'a pas été testée ;
  • les paramètres du meilleur pipeline n'ont pas été optimisés.
Rêvons un peu

Un éventail se possibilités s'ouvre à la communauté LinuxFR.org. La liste ci-dessous reprend les éléments qui me viennent en premier à l'esprit.

  • Réaliser une analyse temporelle des scores pour prédire la note d'un journal à venir en tenant compte de l'historique de publication général (comme la bourse) ;
  • prédire la note d'un commentaire (après avoir modifié la moulinette) ;
  • modifier le modèle afin de prédire le nombre de commentaires. Les contributeurs pourraient alors toucher du clavier la recette permettant de créer les trolls ultimes qui permettraient d'atteindre des sommets d'excellence, de courtoisie et de bienveillance dans une avalanche de remarques plus palpitantes les unes que les autres ;

N'hésitez pas à partager dans les commentaires vos suggestions, vos impressions et vos idées innovantes ! De même, le dépôt gitlab est accessible. Je vous invite à tester vos recettes sur les données présentes et à les exposer dans un journal ou une dépêche. Les différences entre les modèles peuvent être difficiles à appréhender. Toute explication complémentaire sera la bienvenue.

Note
  1. Les scores précédents et la date de création du score peuvent facilement être déduite à l'aide du nom de l'auteur. 

Télécharger ce contenu au format Epub

Lire les commentaires

Optimisations et corrections pour Fim 1.2.3

8 juin, 2017 - 22:41

Fim (File Integrity Manager) sort dans sa version 1.2.3 avec diverses corrections.

Fim est un gestionnaire de fichiers libre (licence GPL v3) qui permet de gérer de nombreux fichiers de n’importe quelle taille. Il peut, par exemple, gérer des musiques, des photos ou des vidéos. Il est capable de gérer des centaines de milliers de fichiers occupant une taille totale de plusieurs téraoctets. Il peut détecter les fichiers dupliqués et les effacer.

Les nouveautés de la version 1.2.3 Général
  • passage de Gson à Jackson pour avoir un sérialiseur plus efficace  ;
  • réduction de la quantité de mémoire nécessaire pour charger un State.
Corrections de bogues
  • correction du problème no 9 : Exception dans le fil d’exécution « principal » java.lang.IllegalStateException ;
  • correction de l’algorithme de comparaison d’état ;
  • lorsque la taille dépasse 1 Go, Fim n’arrondit plus au Go le plus proche ;
  • utilisation du système international d’unités (SI) pour calculer la taille d’un fichier (1 000 — kilo — au lieu de 1 024 — kibi).
Télécharger ce contenu au format Epub

Lire les commentaires

Grammalecte, correcteur grammatical [2]

8 juin, 2017 - 10:07

Grammalecte est un correcteur grammatical écrit en Python et en JavaScript, dédié à la langue française, disponible pour LibreOffice, Firefox, Thunderbird, ainsi que comme programme autonome, via une interface en ligne de commande ou un serveur. Par ailleurs, d’aimables contributeurs ont apporté leur pierre à l’édifice en concevant des greffons pour Vim et Emacs.

Grammalecte lance une deuxième campagne de financement pour améliorer la correction grammaticale et faire évoluer les intégrations aux navigateurs Web.

Cet article est très long. Plutôt que répéter ce qui a déjà été dit, je vais présumer que vous avez un souvenir à peu près clair du billet précédent sur ce sujet. Cela dit, même sans ça, ce que je vais dire devrait être intelligible.

Sommaire Ce qui a été fait Séparation du correcteur d’avec Hunspell et LibreOffice

C’était le prérequis à l’indépendance du logiciel, et c’est la première chose qui a été faite. Au lieu de consulter Hunspell, le correcteur orthographique, pour connaître l’étiquetage grammatical des mots, Grammalecte interroge dorénavant son propre dictionnaire indexable. Il s’agit d’un graphe de mots contenant toutes les formes graphiques que peuvent avoir les mots français : les pluriels, les formes féminines et masculines, et les conjugaisons.

Le graphe contient 500 966 entrées, avec 140 caractères différents, 901 codes de suffixation, 6 066 étiquettes grammaticales, et est composé de 110 796 nœuds et 236 744 arcs (liens qui vont d’un nœud à un autre). Tout ça est compressé sous forme d’un dictionnaire binaire indexable pesant environ 1,25 Mio (le fichier texte non compressé pèse environ 18,6 Mio). Mais le principal avantage de ce dernier n’est pas sa petite taille, c’est qu’on peut le parcourir très rapidement et l’interroger sans avoir à le décompresser. Il peut fournir deux sortes d’informations : un mot est‐il présent dans le dictionnaire et, si oui, quelle est sa nature grammaticale.

Grâce à cela, Grammalecte peut fonctionner de manière autonome.

Extension pour Firefox & Thunderbird

Le correcteur a été entièrement réécrit en JavaScript avec une interface pour Firefox, qui s’appuie principalement sur l’API SDK de haut niveau et quelques fonctionnalités de bas niveau. L’interface est faite en HTML/CSS.

L’API de Thunderbird étant complètement différente de celle de Firefox, cette extension est une autre réécriture en JavaScript de l’extension, hormis le cœur du moteur grammatical, bien sûr. L’interface est bâtie avec l’ancienne technologie XUL encore en vigueur sur Thunderbird. La documentation concernant Thunderbird étant en partie tombée en déshérence (liens cassés, pages manquantes, sections disparues, sites Web à l’abandon ou évaporés), j’ai parfois fait emploi de techniques trouvées dans d’autres extensions, mais ça ne concerne qu’une minorité de problèmes, et je me suis contenté autant que possible de suivre ce qui était documenté. Le fonctionnement de l’extension est assez similaire à celle pour Firefox. Votre texte est analysé dans un panneau annexe. En revanche, contrairement à Firefox, les erreurs sont listées en dessous du paragraphe analysé. Hormis cela, tout est relativement semblable, sauf l’allure générale de l’extension, qui fait plus vieux jeu, parce que XUL est d’une conception plus ancienne.

La mauvaise nouvelle, pour Firefox, c’est qu’il faudrait déjà refaire l’interface. Quand j’ai commencé le codage de l’extension, Mozilla préparait une nouvelle API pour les extensions, appelée WebExtension, qui était alors en version alpha. C’est la quatrième API pour Firefox, les trois autres étant XUL, Bootstrapped et le SDK (haut niveau et bas niveau). Il était dit que ces trois API deviendraient obsolètes d’ici quelques années, sauf le SDK de haut niveau, et qu’il fallait utiliser ça en attendant que l’API WebExtension fût finalisée. C’est donc ce que j’ai fait. Grammalecte pour Firefox est sorti à peu près au même moment que WebExtension. Quelques mois plus tard, les trois autres API ont été déclarées obsolètes, y compris le SDK de haut niveau, contrairement à ce qui avait été annoncé, et toutes les trois seront supprimées en novembre prochain avec Firefox 57.

C’est vraiment très irritant, mais l’on n’y peut pas grand‐chose. Ceci découle probablement de la volonté de Mozilla de réécrire tout le cœur de Firefox. Ce qui n’apporte pas que de mauvaises choses, puisque, par exemple, j’ai constaté que le correcteur grammatical fonctionnait plus de deux fois plus vite à partir de Firefox 55…

Le cœur de l’extension, le moteur grammatical, n’est pas à reprogrammer, il ne s’agit « que » de l’enrobage, l’interfaçage… J’ignore si ça réclamera beaucoup de travail, je ne m’y suis pas encore intéressé. L’un des autres soucis, c’est que même si WebExtension est dorénavant le modèle d’extensions conseillé, il semble qu’il ne permette pas encore autant de choses que les API précédentes. Cette API est toujours en développement, Mozilla travaillant encore à étendre les possibilités offertes.

En ce qui concerne Thunderbird, je n’ai rien vu passer… et j’ignore si nous sommes à la veille d’une révolution surprise qui va tout casser.

Mozilla n’a pas encore vérifié le code de l’extension pour Thunderbird : la liste d’attente est très longue. Heureusement, contrairement à Firefox il est possible d’installer une extension non vérifiée et non signée. Il n’y a aucun risque de confidentialité. Le correcteur n’envoie aucune donnée en ligne, absolument rien. Ce que vous écrivez n’est pas transmis, tout se passe sur votre ordinateur.

Pour ceux que ça intéresse de tester, je viens de publier la version 0.5.17 :

  • pour Firefox (il faut un Firefox capable d’installer les extensions non signées) ;
  • pour Thunderbird (Thunderbird peut installer les extensions non signées).
Captures d’écran

Boîtes de dialogue « À propos » :

Correcteur grammatical :

Conjugueur :

Formateur de texte :

Options grammaticales et orthographiques :

Interface en ligne de commande :

Révision du moteur interne du correcteur Désambiguïsation

Dans la précédente dépêche, je vous avais expliqué que Grammalecte ne possédait pas de processus de désambiguïsation permettant d’étiqueter les mots en fonction du contexte. Par exemple, un mot comme « porte » peut être un verbe ou un nom féminin, et il est utile, lors de l’analyse d’une phrase, d’avoir procédé si possible à la désambiguïsation de sa nature grammaticale, afin que les règles de contrôle n’aient pas à se poser la question à chaque fois.

Comme expliqué lors de la campagne de financement précédente, Grammalecte intègre désormais des fonctions de désambiguïsation capables d’étiqueter et baliser le texte. Ce désambiguïsateur fonctionne d’une manière similaire aux règles de contrôle et au processeur de texte. Une expression rationnelle déclenche une action de désambiguïsation si elle remplit la condition requise, de sorte que toutes les règles suivantes bénéficient d’un étiquetage plus précis. Il y a trois types d’actions de désambiguïsation : la sélection (qui ne retient que les étiquettes conformes à une expression rationnelle), le filtre (qui supprime les étiquettes grammaticales non conformes), l’étiquetage (qui impose une ou plusieurs étiquettes, quelles que soient celles que le mot possède alors).

Règles multi‐actions

Dans le précédent billet, je vous avais expliqué que Grammalecte fonctionnait selon une succession de passes, dont chacune était précédée d’une transformation du texte par ce que j’appelais le « préprocesseur de texte ». Ce qui permettait de simplifier peu à peu le texte pour faciliter le contrôle des règles grammaticales qui suivaient.

Pour simplifier, cela fonctionnait ainsi :

  1. Passe 1 (paragraphe par paragraphe) :
    • règles du préprocesseur de texte ;
    • règles de contrôle.
  2. Passe 2 (phrase par phrase) :
    • règles du préprocesseur de texte ;
    • règles de contrôle.
  3. Passe 3 (phrase par phrase) :
    • règles du préprocesseur de texte ;
    • règles de contrôle.
  4. etc.

Dans ce système, chaque règle ne pouvait faire qu’une seule chose (comme dans LanguageTool), et seulement si la condition qui contrôlait sa mise en œuvre était remplie.

Peu de temps après le début de la campagne de financement, il m’est apparu qu’il serait souhaitable de rendre plus souple ce fonctionnement. Il n’était pas prévu au programme de toucher à cela, mais j’ai préféré m’atteler tout de suite à cette tâche plutôt que de regretter plus tard de ne pas l’avoir fait. Donc, à présent, au lieu d’une succession de passes alternant transformation du texte et contrôle de la grammaire, nous sommes revenus à simplement deux passes (une pour le contrôle du paragraphe, une pour le contrôle des phrases), mais chaque règle peut dorénavant tout faire et peut accomplir autant d’actions qu’on le souhaite, chaque action se déclenchant si la condition qui y est attachée est remplie.

Donc, une règle peut dorénavant opérer plusieurs actions de contrôle, plusieurs actions de réécriture et plusieurs actions de désambiguïsation.
Au commencement, je pensais que cette modification du fonctionnement n’aurait que peu de conséquences, car elle n’était pensée que pour me faciliter la tâche dans certains cas épineux, puis il m’est apparu que ça changeait en fait de si nombreuses choses que la transition de l’ancien modèle vers le nouveau n’est toujours pas achevée à ce jour. Ça n’a pas d’importance puisque ça fonctionne aussi bien qu’auparavant, mais la souplesse de ce fonctionnement apporte tellement d’avantages que je suis loin d’en avoir profité encore pleinement.
Cela dit, depuis que Grammalecte fonctionne ainsi, des dizaines de règles complexes ont déjà été fusionnées, et cela a simplifié grandement le déroulement de nombreuses opérations.

Prenons un exemple simple. Auparavant, si vous écriviez « les ordinateur », il fallait deux règles de contrôle pour souligner « les » et suggérer « le », et souligner « ordinateur » et suggérer « ordinateurs ». À présent, une seule règle permet de faire les deux choses d’un coup.

Autre exemple. Mettons que nous rencontrons la graphie « militant(e)s ». Une même règle va permettre de faire trois choses :

  • suggérer d’écrire ceci autrement (« militants et militantes », « militantes et militants », « militant·e·s ») ;
  • étiqueter ce mot inexistant dans le dictionnaire comme « nom ou adjectif épicène pluriel » ;
  • réécrire le mot en interne pour ôter les parenthèses gênantes.
Détection des erreurs

De nombreuses règles de contrôle ont été ajoutées… notamment concernant la détection de confusions concernant les mots grammaticaux. La dernière version du correcteur (v0.5.17) contient 21 actions de désambiguïsation, 687 actions du processeur de texte, 1 437 actions de contrôle ; ces actions sont réparties dans 1 939 règles.

À titre de comparatif, la version 0.4.10, qui suivait l’ancienne logique, contenait 540 règles de transformation de texte et 933 règles de contrôle, chacune n’effectuant qu’une seule action.

Ces chiffres ne sont pas nécessairement très évocateurs, parce que rien ne comptabilise les modifications du fonctionnement des règles qui sont les plus nombreuses, ne serait‐ce, par exemple, que sur les méthodes pour faire des suggestions.

En fait, le potentiel du correcteur est encore sous‐exploité, malgré les innombrables améliorations apportées ici et là. Je n’avais pas assez insisté sur ce point lors du dernier journal, alors je vais le répéter encore une fois : les détails sont ce qui réclame le plus de temps, car il faut songer que les possibilités d’erreurs avoisinent l’infini et que les possibilités de faire des faux positifs sont aussi nombreuses. Dans les faits, améliorer le correcteur grammatical, c’est s’occuper sans cesse de micro‐problématiques. Je réécris ici ce que j’ai dit la dernière fois : « Écrire des règles, c’est assez rapide ; détecter les faux positifs, c’est beaucoup plus long ; ceux‐ci ont tendance à survenir là où l’on s’y attend le moins. C’est ce qui est le plus exigeant : maintenir un ensemble de règles, améliorer l’existant, tester, trouver de nouvelles possibilités. Lorsqu’on s’occupe d’un correcteur grammatical, on passe surtout son temps à peaufiner des détails, à ajuster le fonctionnement de l’existant, à arrondir les angles. Oubliez l’idée de concevoir l’algorithme ultime qui saura gérer tous les cas. Même quand on est à peu près sûr d’écrire une petite règle tranquille qui ne générera aucun faux positif, la réalité va très probablement nous rappeler à l’ordre et nous obliger à slalomer sur ce qui paraissait au commencement comme une belle ligne droite. S’occuper de correction grammaticale, c’est marcher sur un chemin pavé d’embûches subtiles. »

C’est pourquoi l’évolution du correcteur se fait pas à pas, en évitant autant que possible les modifications radicales.

Le correcteur fonctionne beaucoup mieux depuis que toutes ces améliorations ont été faites, et j’espère que c’est sensible pour vous, car il m’est difficile de juger si ces améliorations sont visibles pour les utilisateurs.

Parmi toutes les nouveautés apportées, il y a notamment :

  • beaucoup de règles pour détecter des confusions entre les mots homonymes (comme ce, se et ceux) ;
  • beaucoup d’améliorations pour gérer les cas particuliers, clarifier le texte interne et augmenter le taux de détection ;
  • toujours moins de faux positifs ;
  • une option pour détecter les erreurs de reconnaissance optique de caractères bien plus développée (désactivée par défaut) ;
  • beaucoup de règles de contrôle ont été améliorées.
Le moteur de suggestions

L’amélioration des suggestions est l’un des points qui ont le plus progressé depuis le précédent journal, grâce aux règles multi‐actions qui ont permis de rendre plus systématiques la possibilité de faire deux suggestions différentes lors de la constatation d’un désaccord de genre, de nombre ou de conjugaison ; mais aussi surtout grâce à la création d’une table de correspondance phonétique à partir de laquelle Grammalecte peut choisir des mots à suggérer en fonction de leur nature grammaticale.

La table de correspondance phonétique est un simple fichier qu’il est facile de compléter, c’est une succession de mots homonymes, comme :

  • appareil, appareils, appareille, appareilles, appareillent ;
  • mec, mecs, Mecque ;
  • pouce, pouces, pousse, pousses, poussent ;
  • tête, têtes, tète, tètes, tètent.

À partir de cette liste, Grammalecte construit un mini‐dictionnaire avec toutes les natures grammaticales possibles de chaque mot. Puis, au besoin, on peut demander, par exemple, de trouver un mot semblable à « tète » en spécifiant les natures grammaticales acceptables (via une expression rationnelle). Il y a aussi quelques propositions de substitutions automatisées, pas toujours opportunes, ce point reste à améliorer.

Si ça vous intéresse, cette table est consultable ici.

Cette table phonétique ne résout pas tous les problèmes, mais permet dans bien des cas de faire des suggestions de mots sans rapport grammatical avec le terme erroné. Avant cela, le correcteur se contentait de signaler l’erreur, mais ne pouvait rien suggérer. Quelques exemples :

  • « Il appareil demain. » → appareille ;
  • « La mec. » → Le | Mecque ;
  • « Une goulet » → Un | goulée ;
  • « Il pouce le bouchon trop loin. » → pousse ;
  • « J’en ai marre de ces tètes de nœud. → têtes ;
  • « Ils ne son pas idiot. » → sont.

Notez que le moteur de suggestions ne propose des mots ayant une autre racine que lorsqu’il constate une anomalie (si un verbe prend la place de ce qui devrait être un nom, par exemple) ou s’il constate une erreur de genre. S’il y a seulement une erreur de pluriel, il se contente de faire une correction de nombre. Mais il serait aussi possible dans ces cas‐là de suggérer des mots différents. Par exemple « Des homme » → hommes | ohms | heaumes.

Ça m’a semblé superflu de proposer de telles corrections, mais si vous jugez ça utile, dites‐le‐moi.

Modifications diverses
  • l’écriture des règles a été modifiée, il est plus aisé de gérer la casse et les marges des motifs des expressions rationnelles ;
  • les règles sont regroupées par option, afin de pouvoir ajouter des règles optionnelles sans gréver les performances (l’option de reconnaissance optique de caractères, par exemple) ;
  • il est possible d’utiliser pour chaque action des opérateurs logiques (__also__ et __else__) pour écrire des conditions tenant compte du résultat de la condition de l’action précédente ;
  • toutes les règles ont été nommées, afin de satisfaire aux nécessités du greffon pour Vim (désactivation paramétrable de règles spécifiques) ;
  • tout le processus de construction a été revu et des tests ont été intégrés pour éviter certaines erreurs d’écriture des règles ;
  • des marque‐pages pour s’y retrouver dans la liste des règles, qui commence à devenir très, très longue (fonctionnalité ajoutée hier).
Capture d’écran

Voici à quoi ressemble le fichier des règles (sous SublimeText) :

Tests unitaires

Auparavant, la situation sur ce point était très mauvaise, puisqu’il n’y avait aucun test unitaire sur le correcteur, seulement des tests « manuels », c’est‐à‐dire un fichier texte que j’ouvrais de temps en temps avec Writer pour vérifier que le moteur fonctionnait comme prévu. Mais c’était loin d’être exhaustif et facile à mettre en œuvre, puisque je vérifiais « à l’œil » si à chaque ligne le correcteur trouvait bien l’erreur qu’il était censé trouver. Pénible et lent au possible.

À présent, à chaque modification, il est possible lors de la construction de tester si rien n’est cassé. Plus de 6 200 tests sont lancés (dont 2 000 repris chez LanguageTool), et chaque règle de détection doit être testée au moins une fois.

Malgré cela, les tests ne sont pas encore exhaustifs (à bien y songer, il n’est sans doute pas possible d’être exhaustif), mais la situation s’améliore indubitablement, et peu à peu le socle du correcteur devient de plus en plus solide. Grâce à cela, de nombreuses erreurs dans le fonctionnement du correcteur ont été détectées et corrigées.

Beaucoup de ces tests sont là pour vérifier qu’une règle fonctionne correctement, mais une grande partie d’entre eux existent pour éviter les faux positifs constatés lors des versions précédentes. Ce sont les tests les plus nombreux, parce que les faux positifs sont légion et qu’il est très fréquent d’en provoquer de nouveaux, quelle que soit la prudence avec laquelle on écrit les règles. Pour les éviter autant que possible, quelques textes courts ont été inclus dans les tests de Grammalecte :

  • Le Horla, de Guy de Maupassant ;
  • Le double assassinat dans la rue Morgue, d’Edgar Poe ;
  • Les vers dorés, de Pythagore ;
  • L’épître du feu philosophique, de Jean Pontanus.

Avoir écrit l’extension pour Firefox présente par ailleurs un avantage considérable pour consolider la correction grammaticale : c’est beaucoup plus facile de mettre le correcteur à l’épreuve. Presque tous les jours, je lance des analyses grammaticales sur de nombreux articles de journaux et de blogs divers ; ça me permet de repérer et corriger des faux positifs, ainsi que de nouveaux mots à ajouter au dictionnaire. Auparavant, je faisais des copier‐coller dans Writer, ce qui était bien moins commode et bien plus long.

Ces tests sont faits en Python et en JavaScript. Les deux moteurs les passent tous et fonctionnent de la même manière. Cela dit, il n’est pas malgré cela pas possible de garantir (pour l’instant) que le moteur en JavaScript fonctionne aussi bien qu’en Python.

JavaScript, mon amour Hiroshima

Passer de Python à JavaScript n’a pas été de tout repos. Et si le projet a pris du retard, ce n’est pas tellement, comme je le craignais, à cause de la difficulté de concevoir une extension pour Firefox et Thunderbird. Ce point fut plus facile que je ne le pensais, tout simplement parce que la documentation de Firefox et celle Thunderbird, quoique cette dernière soit en déshérence, sont mieux tenues et plus complètes que celle pour LibreOffice… et surtout l’API est plus simple à utiliser… Quoique… l’API de bas niveau est tout aussi compliquée, de mon point de vue… Mais comme on peut s’en passer… Bref.

La syntaxe de JavaScript ne m’a pas posé de problème. J’ai utilisé toutes les nouvelles possibilités offertes par la norme ES6 : for … of, les générateurs, les paramètres par défaut, les paramètres du reste, la décomposition, les fonctions fléchées, Map, Set, les classes, let et const, et même depuis peu les nouvelles commandes async et await. Avec tout ça, JavaScript est un langage pas aussi horrible que je l’avais craint, même assez agréable parfois… En même temps, comme je démarrais un projet à zéro, je n’ai pas eu à me coltiner toutes les bizarreries possibles de ce langage. J’ai évité toute forme de syntaxe tord‐neurones.

Ce qui m’a compliqué la vie, c’est plutôt l’écosystème de JavaScript, sa difficulté à déboguer, son comportement étrange, les incohérences et sa bibliothèque standard pauvre.

Difficulté à déboguer

Ni Firefox, ni Thunderbird (ni LibreOffice d’ailleurs) ne signalent quoi que ce soit s’il y a une erreur de syntaxe dans le code. Ça ne fonctionne tout simplement pas, et c’est tout. C’est assez pénible en Python, mais c’est bien pire en JavaScript où il est fréquent d’oublier une virgule ou un point-virgule quelque part. En outre, les messages d’erreur de JavaScript sont longs et souvent abscons, sans compter que selon le contexte d’exécution dans Firefox/Thunderbird, les messages d’erreur sont parfois encore plus imprécis, voire inexistants (le module XYZ plante, mais débrouillez-vous pour le reste, car aucune info ne sera fournie, comme où et pourquoi). Je ne vais pas rentrer dans les détails, parce que j’ai maintenant oublié la plupart d’entre eux… mais à mon avis, Mozilla ferait des heureux en améliorant les rapports d’erreur.

Inutile de s’étendre sur le comportement erratique de JavaScript et son typage faible, cela a déjà été fait par tellement de monde… Quand on vient de Python, il est facile de tomber dans tous les pièges que ce langage tend, dans lesquels même les plus experts chutent encore de temps en temps, j’imagine. La traque aux “undefined” semblant sortir de nulle part m’a particulièrement marqué.

La bibliothèque standard

La bibliothèque standard est, en restant poli, très mauvaise, notamment parce qu’elle est très incomplète, mais aussi assez peu cohérente, me semble‐t‐il. Dans beaucoup de cas, ce n’est pas bien grave, il suffit d’ajouter les fonctions dont on a besoin et c’est ce que j’ai fait, mais on se demande quand même pourquoi cette bibliothèque standard est si pauvre ou si mal foutue. Avec toute la hype autour de ce langage, c’est vraiment très étonnant.

Prenons le cas des expressions rationnelles, parce que la nullité de l’objet Regexp est navrante… et parce que c’est ce qui est le plus utile à Grammalecte :

problème 1 : pas de lookbehind assertions

Les lookbehind assertions permettent de regarder ce qui précède un motif. OK, c’est pénible, mais on peut compenser avec quelques efforts.

problème 2 : les classes de métacaractères ne comprennent que l’ASCII.

Les classes de métacaractères comme \w et \b, ne comprennent que l’ASCII.
Oui, l’ASCII ! Ce qui donne (vous pouvez essayer dans l’ardoise de Firefox) :

/^\w+$/.test("étonnant") ==> false /\bvite\b/.test("évite") ==> true

Inutile de vous précipiter sur votre calendrier, nous sommes bien en 2017, et non en 1997. JavaScript est, paraît‐il, un langage moderne, mais seulement quand on n’y regarde pas de trop près.

Heureusement, il est facile de compenser l’absence d’un \w fonctionnel par [a-zA-Zà-öÀ-Ö0-9_ø-ÿØ-ßĀ-ʯ] (du moins, ce sont les plages de caractères que j’ai retenues, on pourrait en ajouter bien d’autres). Ce qui rend les expressions rationnelles un peu plus piquantes à lire…

Quant à \b, eh bien, on peut essayer de compenser avec des lookahead assertions et des lookbehind assertions. Seulement, voilà, ces dernières n’existent pas en JavaScript. Mais en magouillant, on peut simuler ça. Du moins dans presque tous les cas utiles. Tant pis pour les autres… on priera de ne pas tomber sur un caractère non ASCII.

Problème 3 : pas de position des groupes capturés

Les groupes capturés n’indiquent pas leur position. Ça, c’était vraiment la mauvaise surprise. Avant de proposer la campagne de financement, j’avais vérifié ce que JavaScript pouvait faire avec les expressions rationnelles, mais je n’avais pas vu que ce point manquait à l’appel, tout simplement parce que je n’avais pas imaginé que JavaScript serait incapable de fournir cette indication.

De quoi s’agit‐il au juste ? C’est très simple. Quand vous écrivez une expression rationnelle avec des groupes de capture, comme (\w+) (\w+) (\w+), Python vous renvoie les groupes capturés (ce qui est entre parenthèses) avec leur position dans le motif global. JavaScript ne renvoie que le contenu des groupes capturés, mais pas leur position. Débrouillez‐vous pour savoir où ça se trouve, et c’est bien plus épineux que vous pourriez le supposer, si, par exemple, vous capturez des mots comme « a », « le » ou « la », ou si vous capturez des groupes qui ne sont pas des mots entiers.

Ce point seul m’a fait perdre beaucoup de temps, sans compter que ce fut un cauchemar à déboguer. J’ai même cru pendant quelques jours que tout le projet allait tomber à l’eau à cause de ça.

Car, à ce moment du développement, alors même que je bataillais pour rendre le moteur fonctionnel, j’ai pris conscience que l’exécution du code en JavaScript était environ douze fois plus lente qu’en Python, au point que lorsqu’on lançait la correction grammaticale, Firefox se figeait pendant de longues secondes… C’était évidemment inacceptable.

Il était donc hors de question de ralentir encore l’exécution du code en essayant de calculer la bonne position des erreurs dans les motifs détectés (pour rappel, il y a des milliers d’expressions rationnelles dans Grammalecte). Du coup, j’ai oublié cette idée et procédé autrement : la position des groupes capturés est signalée dans le fichier des règles de grammaire. Cela rend le processus d’écriture des règles un peu plus brouillon, mais c’est assez simple pour être acceptable. Et ça ne ralentit pas le moteur outre mesure.

Ensuite, pour éviter que Firefox ne se fige, le cœur du correcteur grammatical, c’est‐à‐dire la vérification du texte, s’exécute dans un processus séparé… Et, bonne surprise, il s’avère que dans ce processus — inexplicablement, sans rien changer au code — le correcteur fonctionne vingt fois plus rapidement que dans le processus principal de Firefox, même quand ce dernier ne fait rien du tout !…

Un écosystème incohérent

Selon les contextes et l’application, les choses fonctionnent différemment et ça donne la désagréable impression de bâtir sur du sable. On ne sait pas toujours bien ce qui préexiste aux scripts qu’on conçoit. Notamment, il n’y a toujours pas de moyen conventionnel simple pour importer un module (ES6 en parle, mais aucun navigateur n’a encore implémenté ça).

Parfois, require existe par défaut. On peut faire :

const { Cu } = require("chrome"); const tabs = require("sdk/tabs");

Dans d’autres cas, require n’existe pas par défaut, donc :

importScripts("resource://gre/modules/workers/require.js"); const gce = require("resource://grammalecte/fr/gc_engine.js");

Ou bien encore dans un autre contexte, il faut faire :

const Cu = Components.utils; const { require } = Cu.import("resource://gre/modules/commonjs/toolkit/require.js", {});

Parfois, on importe Components.utils (Cu) grâce à require. Parfois, on importe require à partir de Components.utils (Cu) ou bien d’autre chose.
On peut aussi importer des modules via XUL ou le HTML, avec des espaces de noms partagés. Il y a aussi les déclarations de ressources dans un manifeste. Bref, tout ça est contre‐intuitif au possible.

Cela dit, alors que j’écrivais ce texte, je découvre que import et export arrivent enfin dans les navigateurs ! On va peut‐être en finir avec tout ça bientôt.

Mais, ça résoudra pas tout. Comme je l’ai dit, selon les applications et les contextes, certains objets ou fonctions existent ou n’existent pas. Dans Firefox, on peut appeler directement XMLHttpRequest(), mais pas dans Thunderbird. Pour ce dernier, il « suffit » donc de faire :

let { Cc, Ci } = require("chrome"); let xRequest = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(); xRequest.QueryInterface(Ci.nsIXMLHttpRequest);

Même pour faire un print, il n’y a pas de solution uniforme. Là encore, selon le contexte, il y a : console.log(), Service.console.logStringMessage() ou dump() ou que sais‐je encore. Il y a des contextes où rien de tout ça ne fonctionne.

Une dernière étrangeté : pour compenser la pauvreté des objets standard, j’ai ajouté des fonctions personnelles à String, Regexp et Map. Mais ce qui est curieux, c’est que dans Firefox, il faut que ces nouvelles fonctions soient déclarées dans le module où les objets sont instanciés… tandis que dans Thunderbird, il faut que ces nouvelles fonctions soient déclarées dans le module où ces fonctions sont utilisées. C’est pourtant le même moteur JavaScript.

J’arrête ici de lister les incohérences, on n’en finirait pas.

Chaque problème n’est pas dramatique en soi, mais l’accumulation de ces contretemps finit par rendre la programmation en JavaScript vraiment casse‐pieds par moments.

Et, là, on ne parle que de Mozilla. C’est encore différent ailleurs, puisque l’implémentation des nouvelles fonctionnalités du langage n’avance pas au même rythme selon les moteurs.

En résumé, JavaScript, c’est le bordel et on se demande pourquoi c’est si incohérent. À mon avis, ce qui manque particulièrement à ce langage, c’est une implémentation standard avec un comportement logique et uniforme, des rapports d’erreurs plus clairs et une bibliothèque par défaut mieux faite et plus complète. On perd un temps considérable avec ces histoires.

Je ne voulais pas particulièrement écrire un long chapitre sur ce langage, mais ça fait déjà pas mal…

De Writer à Firefox (ou de la littérature au Web) : le choc culturel

L’un des points auxquels je n’avais pas beaucoup réfléchi et qui m’a le plus surpris, bien que j’avais conscience que les textes du Web n’égalaient pas en qualité et normativité ceux sur lesquels j’avais travaillé sur LibreOffice, c’est combien l’écrit sur le Web est chaotique et exubérant, et foisonne de néologismes, d’anglicismes, de noms propres (compagnies, marques, produits, people), de sigles, de codes divers, de vocabulaire technique, de smileys, d’erreurs de syntaxe ou de formatage, sans compter les habituelles erreurs typographiques, orthographiques et grammaticales… Si bien que même lorsque Grammalecte commençait à fonctionner comme il le devait sur Firefox, il m’est vite apparu que c’était difficilement utilisable en l’état, et qu’il fallait revoir son fonctionnement pour éviter trop de signalements intempestifs, pour éviter que tous les textes soient barbouillés de toutes les couleurs. Pourtant, je n’avais pas fait faire les premières armes du correcteur sur les logorrhées de Facebook, mais sur des textes d’acteurs « sérieux », comme les journaux et les blogs grand public ou plus confidentiels, mais a priori bien tenus. Quelle déconvenue !… Entre le charabia, les hashtags et autres bidules, le formatage indigent et la novlangue du Web, Grammalecte tirait tout le temps la gueule, et il a fallu revoir beaucoup de choses pour que le correcteur se comporte moins comme un casse‐pieds permanent. J’ai passé un temps considérable à cette adaptation culturelle. J’ai fait passer au correcteur des centaines de textes tirés de blogs et de journaux. J’ai corrigé des tas de faux positifs et j’ai ajouté des centaines de mots dans le dictionnaire. Et beaucoup d’entre vous trouvent sans doute le correcteur encore trop rigide. À vous de me le dire, j’ai eu très peu de retour sur ce point…

Quoi qu’il en soit, pour s’acclimater à Internet, il a fallu assouplir grandement la politique d’intégration des néologismes, des anglicismes, des marques, améliorer l’analyseur lexical pour ignorer des tas de trucs. Par exemple, si l’on peut se passer du verbe « tweeter » quand on ne s’occupe que de LibreOffice, sur le Web, non, ce ne peut être compris des utilisateurs. Trop fréquent. Idem pour pas mal de marques et d’autres néologismes très courants.

Cela dit, je suis toujours réticent à ajouter trop de nouveautés et de bizarreries, les noms de produits sont toujours interdits (tant pis pour les Freebox, les iBidule, et autres gadgets dans l’air du temps…), et je me suis arrêté au moment où j’ai estimé que j’avais suffisamment assoupli les choses… Faites‐moi part de votre avis, en bien ou en mal. Il reste sans doute encore des rugosités à polir.

Lexique du correcteur

La graphie d’un mot français ne permet pas de déterminer sa nature. Un mot finissant par « -ent » peut être un nom, un adjectif, un adverbe ou la forme conjuguée d’un verbe. C’est pourquoi un correcteur grammatical ne peut souvent pas grand‐chose sans un lexique étiqueté référençant tous les mots d’une langue. Cet étiquetage, c’est la base de la connaissance du correcteur.

Ce lexique est généré à partir du dictionnaire orthographique pour Hunspell.

Quelques données sur le dictionnaire :

  • plus de 82 300 entrées (+ 5 300 depuis le précédent journal) ;
  • toutes les entrées sont grammaticalement étiquetées ;
  • environ 20 % d’entre elles sont sémantiquement étiquetées (médecine, informatique, botanique, etc.), mais cet étiquetage ne sert pas encore.

Améliorer la base lexicale et son étiquetage, c’est l’une des tâches les plus importantes de la conception d’un correcteur grammatical. Tout le travail sur le dictionnaire se fait sur Dicollecte, où sont collectées les propositions des utilisateurs.

C’est toujours perfectible

Beaucoup de choses ont été faites, parfois plus que ce qui était demandé, parfois le strict minimum. Évidemment, beaucoup de choses sont encore améliorables, c’est le propre des projets informatiques. Un correcteur grammatical, ce n’est jamais fini.

Si j’ai oublié de mentionner quelque chose d’important, n’hésitez pas à m’en faire part.

Malheureusement pour certains, je n’ai pas réécrit le correcteur en OCaml, Haskell, Lisp, Cobol… [insérez ici votre langage à la mode favori]. Firefox et Thunderbird s’obstinent à ne comprendre que le JavaScript, LibreOffice le Python, le Basic et le Java. C’est barbare ou vintage si on est indulgent, mais c’est ainsi. :-)

Pour l’instant, attendu que Mozilla n’a toujours pas implémenté l’interface de programmation qui permettra de souligner les erreurs directement dans les zones de texte, la correction se fait dans un panneau annexe. Mais, dès que cette interface sera disponible, c’est bien sûr ainsi que les corrections se feront. Au cas où ceci intéresserait quelqu’un parmi vous, sachez qu’il existe une prime pour la réalisation de cette tâche sur Bountysource.

Il existe également une prime pour apporter la colorisation des erreurs dans LibreOffice. Idéalement, j’aimerais qu’on passe des vaguelettes bleues à peine visibles à des traits pleins, épais et colorés. Par exemple :

L’un des problèmes qui m’ennuie assez en ce moment, c’est que la validation des extensions proposées sur le site de Mozilla est devenue vraiment longue depuis le début de l’année. Les contrôleurs sont probablement submergés de nouvelles extensions à cause du passage obligatoire à WebExtension. Du coup, la version 0.5.16 n’est pas encore validée. La version 0.5.17 n’a pas encore été proposée, attendu que toute nouvelle version nous ramène en fin de liste d’attente.

L’avenir Améliorer la correction grammaticale

Après le passage délicat que constituait la désimbrication de Grammalecte de LibreOffice, je vais dorénavant me concentrer sur l’amélioration du correcteur lui‐même. Avec toutes les nouvelles fonctionnalités apportées dernièrement, il est possible de faire bien mieux que ce qu’on a maintenant.

Pour l’instant, le désambiguïsateur, quoique déjà fort utile, est particulièrement sous‐utilisé, pas parce qu’il est difficile d’emploi, mais parce que cette affaire est vraiment plus délicate que je ne l’avais supposé de prime abord, et aussi parce que le processeur de texte fait en vérité déjà beaucoup de travail sur ce point (cf. le journal précédent)… Encore une fois, le diable est dans les détails, les détails, les détails…
En revanche, il m’apparaît de plus en plus évident qu’il serait utile d’adjoindre au désambiguïsateur un système d’annotation du texte, parce que tout ne dépend pas de la désambiguïsation grammaticale, et qu’il est souvent appréciable de connaître le contexte.

Le fait que les règles puissent lancer plusieurs actions va permettre de faire des examens plus complets sur des détails pour l’instant ignorés, notamment sur le contrôle des locutions adverbiales ou les syntagmes nominaux les plus fréquents. Rien de difficile à première vue. Juste un travail de tâcheron qui demande du temps.

L’autre point central à mettre en œuvre, c’est la fusion et le réajustement des règles existantes. Le fait que les règles peuvent dorénavant appliquer autant d’actions que voulu change grandement la donne. Par exemple, je vous avais expliqué dans le précédent journal que la vérification des verbes se faisait après avoir vérifié tout le reste. À présent, même s’il est encore utile de fonctionner ainsi dans bon nombre de cas, il serait appréciable de fusionner certaines de ces vérifications avec le désambiguïsateur qui, lui, est surtout utilisé dans les premières phases de traitement.
Ce travail de fusion et de réajustement des règles ne présente pas de difficultés particulières, c’est surtout une question de stratégie globale qui ne nécessite cependant qu’un travail minutieux et attentif, plutôt ennuyeux et probablement un peu répétitif. Une fois de plus, avec plusieurs centaines de règles concernées, ça ne peut pas se faire en un tour de main.

Autre objectif : bétonner les tests, bétonner les tests, bétonner les tests. Parce que c’est possible et que c’est indispensable pour éviter les bogues inattendus que la correction grammaticale peut susciter. Mais il faudra aussi consolider radicalement les tests par l’ajout systématique des erreurs les plus fréquentes.

Améliorer les suggestions… Un casse‐tête qui s’est beaucoup amélioré ces derniers temps, mais il faudrait quand même réussir à filtrer les absurdités que le correcteur sort parfois. Son défaut est d’être un peu trop ingénieux par moments… mais bon, ça peut faire rire. :-)

Parmi les suggestions, il y a particulièrement les suggestions orthographiques. Pour le moment, dans Firefox et Thunderbird, Grammalecte utilise Hunspell pour avoir des suggestions orthographiques, même s’il n’a plus besoin de lui pour savoir si un mot est présent dans le dictionnaire et récupérer les données grammaticales. Il serait utile d’adjoindre un module de suggestion orthographique en parcourant le graphe de mots à la recherche de possibles mots correspondant suffisamment à la graphie inconnue. Un domaine de recherche à part entière. À mon avis, il serait utile d’implémenter une suggestion basée sur des substitutions phonétiques.

Plus loin, plus fort ?

Ce n’est qu’une idée, pour l’instant mal formée et un peu extravagante, mais je réfléchis à la possibilité de bâtir un graphe de la grammaire française comme il a été possible de bâtir un graphe de l’ensemble des mots du français. La différence, c’est que la totalité des mots français recensés peuvent s’écrire selon un graphe acyclique, avec un début et une fin connus, tandis que si on schématise la grammaire française les boucles et les récurrences sont possibles, les embranchements innombrables, les fantaisies ne sont pas rares, la longueur de la chaîne de tokens est théoriquement sans limite… Et on ne parle là que de phrases faites avec une grammaire correcte. Comment gérer les erreurs rencontrées ? Faut‐il les intégrer dans ce même graphe en créant des branches d’erreur ?
C’est une pensée embryonnaire qui n’aboutira peut‐être à rien d’utile, mais si l’on trouve un moyen de bâtir ce graphe, il devrait être possible de gérer des cas très complexes. Ça nous permettrait de sortir du schéma [motif potentiel d’erreur → condition d’erreur → suggestions → message d’erreur] qu’on peut heureusement combiner avec diverses magouilles plus ou moins subtiles élaborées avec le processeur de texte et le désambiguïsateur.

Ce qui est sûr, c’est que le tokeniseur va prendre une place une place plus importante dans la nouvelle stratégie pour gérer la complexité.

Créer une extension pour Chrome

Pas grand‐chose de spécial à dire sur ce sujet. Il est à espérer que produire l’extension pour Chrome prenne un temps raisonnablement court, attendu que Mozilla a essayé de faire en sorte que la nouvelle API soit proche de celle de Chrome. Mais dans l’univers de JavaScript, y a‐t‐il quelque chose de stable et bien pensé ? Ce serait une bonne surprise. J’ironise et je médis, mais c’est un peu mérité, n’est‐ce pas ?
Quoi qu’il en soit, même si ça se fait plus rapidement qu’attendu – il n’est pas interdit de rêver –, le temps prévu à cette tâche sera utilisé pour renforcer le correcteur, ce ne sera donc pas perdu. En plus, moins je fais de JavaScript, plus je suis heureux… C’est donc avec bonheur que je me livrerai à une tâche plus essentielle que deviner ce que peut vouloir me dire le débogueur de Chrome.

Outils annexes

L’amélioration du lexicographe (qui donne des informations sur les mots) et l’assistant lexical (permettant l’ajout simplifié de mots au lexique) ont pour but de revisiter la manière d’améliorer la base lexicale, dont Dicollecte, le site Web existant pour cette tâche, commence à se faire vieux. J’espère inciter les utilisateurs à participer à la conception de la base en rendant l’interface plus simple et plus séduisante, et surtout directement accessible dans son logiciel. Ça a l’air insignifiant, mais c’est une question essentielle.

Le détecteur de répétitions est proposé parce que c’est un outil qui intéresse potentiellement beaucoup les écrivains soucieux de varier leur vocabulaire.

Le mot de la fin

Bon sang ! Difficile de rendre une campagne de financement attrayante quand on parle de grammaire. Au final, on veut juste de petits liserés sous les mots erronés et un menu contextuel qui explique pourquoi c’est faux et qui suggère quelque chose de crédible. Rien de palpitant à la réflexion. On peut espérer susciter l’intérêt des technophiles en parlant de l’arrière‐cuisine et du système de tuyauterie, mais j’avais déjà presque tout dit la première fois, je ne peux que rendre compte de ce qui a été fait et amélioré.

Si la première campagne vous a satisfait, si vous jugez que la correction grammaticale est trop importante pour être négligée et qu’il faut en finir avec la maltraitance de la langue française, si vous voulez peser sur les priorités du correcteur grammatical ou ajouter des mots spécifiques ordinairement interdits dans le dictionnaire, je vous invite à consulter la page de financement participatif sur Ulule.

Télécharger ce contenu au format Epub

Lire les commentaires

Les journaux LinuxFr.org les mieux notés du mois de mai 2017

7 juin, 2017 - 19:59

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 mai passé :

Télécharger ce contenu au format Epub

Lire les commentaires

Métriques libres et analyse des développements : rencontre de présentation des enjeux et outils

6 juin, 2017 - 15:04

L’analyse des développements libres basée sur des métriques intéresse à la fois les utilisateurs des projets et leurs mainteneurs, lorsqu’il s’agit d’évaluer la vitalité de ceux‐ci ou les détails de leur fonctionnement. Pour les entreprises ayant adopté des pratiques d’innersourcing, ces méthodes et outils fournissent des indicateurs précieux dans la conduite de leurs projets internes. Inno³ et Bitergia organisent le 14 juin 2017 à Paris une soirée sur le thème des métriques libres couvrant l’ensemble de ces aspects, illustrés avec les outils libres de Bitergia.

Depuis plus de dix ans, Bitergia développe des outils libres permettant de collecter, traiter et restituer une large variété de métriques sur les éléments générés par les projets libres : dépôts de code, système de suivi de bogues, listes de diffusion, etc. La nouvelle génération de ces outils est regroupée au sein du projet Grimoirelab. Le site Cauldron.io permet d’en tester le fonctionnement directement pour les projets GitHub qui vous intéressent.

  • adresse : Inno³, 137 boulevard de Magenta, 75010 Paris
  • métros : Gare du Nord, Barbès‐Rochechouart ou Poissonnière
  • date et heure : mercredi 14 juin 2017, à partir de 19 h
Télécharger ce contenu au format Epub

Lire les commentaires

Revue de presse de l’April pour la semaine 22 de l’année 2017

6 juin, 2017 - 10:04

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

[Nouvelle République] Les « Geek Faëries » reviennent en force
Par Laurence Texier, le dimanche 4 juin 2017. Extrait :

« Malgré la pluie, les geeks ont afflué au château de Selles‐sur‐Cher. Le festival enfile ses plus beaux costumes pour une dernière partie ce dimanche. »

Et aussi :

Voir aussi :

[Silicon] Les Gafam dans les écoles : une menace pour la filière française des ENT ?
Par Reynald Fléchaux_, le jeudi 1er juin 2017. Extrait :

« L’Éducation nationale ouvre ses portes aux solutions des Apple, Google et autre Microsoft. Une volte‐face qui fait bondir trois patrons d’éditeurs spécialisés, les ENT, qui critiquent une forme de deux poids, deux mesures. »

[ZDNet France] L’ARCEP publie son premier rapport sur l’état de l’Internet en France
Par Pierre Col, le mercredi 31 mai 2017. Extrait :

« Ce premier rapport de l’ARCEP fait un point exhaustif sur l’état de l’Internet en France, tant du point de vue du fonctionnement technique du réseau qu’en matière d’accessibilité pour la population et de neutralité des acteurs : un travail utile ! »

[Next INpact] Législatives 2017 : près de cent candidats ont déjà signé le Pacte du logiciel libre
Par Marc Rees, le mardi 30 mai 2017. Extrait :

« À l’occasion des législatives pour 2017, l’association pour la promotion du Libre, l’April, relance sa campagne autour du « Pacte du logiciel libre ». Une initiative qui fête cette année ses dix ans. »

Et aussi :

Voir aussi :

[Resources Solidaires] Les données des élèves et les « GAFAM » : si c’est gratuit, c’est toi le produit !
Par la FCPE, le mardi 30 mai 2017. Extrait :

« La FCPE a pris connaissance d’une communication de la direction nationale du numérique — DNE — indiquant qu’il était désormais possible de fournir aux « GAFAM », grands groupes fournisseurs de services Web, les annuaires des établissements, ceux‐ci ayant des conditions générales d’utilisation — CGU — « éducation » couvrant cette utilisation. »

Voir aussi :

Télécharger ce contenu au format Epub

Lire les commentaires

Outil d’évaluation des aptitudes au développement

6 juin, 2017 - 08:58

Afin d’évaluer les aptitudes à la programmation de candidats à une formation de développeur (déjà présentée sur LinuxFr.org), un langage de programmation très simple a été conçu, ainsi qu’une plate‐forme Web qui permet d’écrire des programmes et de visualiser leur exécution de la façon la plus claire et explicite possible.

Tous les éléments de la plate‐forme sont en anglais et elle comporte également un tutoriel, l’idée étant de la mettre à disposition d’un candidat une dizaine de jours avant le recrutement et de voir s’il sera capable d’auto‐apprentissage dans un environnement nouveau, documenté en anglais. Le jour du recrutement, un test sera effectué, dans lequel des exercices de complexité croissante seront proposés : simples enchaînements d’instructions, boucles basées sur des algorithmes élémentaires, manipulation de structures plus complexes en mémoire telles que des chaînes de caractères, etc.

La seconde partie décrit le système.

L’utilisateur dispose d’un ruban mémoire qui ne peut contenir que des nombres, entiers ou réels. Il dispose de huit instructions, qui peuvent comporter des expressions arithmétiques et qui vont lire et/ou écrire dans le ruban mémoire, ou effectuer des entrées‐sorties. À ce stade, le langage est proche d’un assembleur, mais avec un typage plus large (entier/réel) et des expressions arithmétiques dont la complexité n’est pas bornée. Ce niveau de langage assez bas permet d’enlever toute ambiguïté aux instructions, et de visualiser tous les effets de leur exécution. Pour rendre l’activité ludique, des instructions de dessin à la logo permettent de déplacer un stylo virtuel et de tracer des segments de droite comme on peut le voir sur l’image.

La plate‐forme est écrite en VueJS et s’exécute exclusivement sur le client sans aucune partie serveur. Son code est disponible sur GitHub et les contributions au langage et au développement sont les bienvenues.

Télécharger ce contenu au format Epub

Lire les commentaires

Nouvelles versions logicielles du projet GNU avril et mai 2017

5 juin, 2017 - 00:08

Le projet GNU publie tous les mois une liste de versions logicielles publiées. Jetons‐y un coup d’œil pour découvrir de nouveaux logiciels inconnus (de moi), des infâmes bogues disparus ou les promesses de solutions à tous nos besoins : soit 33 nouvelles versions annoncées allant de la corrective mineure à la version attendue depuis des années ; et l’on va donc parler de acct, artanis, bc, diffutils, emacs, emms, freedink-data, gcc, global, gnubik, gnupg, gnutls, grub, guile, guile-cv, guile-ncurses, icecat, kawa, less, libcdio-paranoia, libidn2, libmicrohttpd, linux-libre, nano, ocrad, orgadoc et parallel.

Sommaire acct-6.6.3 (avril)

Il s’agit d’une mise à jour mineure de cet outil d’enregistrement des actions sur le système (nom d’utilisateur et processus), pour incorporer des correctifs venant de SUSE et Red Hat.

artanis-0.2.1 (mai)

On y trouve quelques corrections de bogues et un peu plus de robustesse pour cette boîte à outils pour applications Web (WAF) en Guile Scheme.

bc-1.07.1 (avril)

La version apporte principalement des compléments documentaires et quelques corrections de bogues pour cette calculatrice à précision arbitraire.

diffutils-3.6 (mai)

Cet ensemble d’outils pour comparer des fichiers reçoit une nouvelle fonctionnalité (si un fichier comparé est le début de l’autre), des corrections de bogues et une amélioration de performance sur les gros fichiers.

emacs-25.2 (avril)

Cet éditeur polyvalent a connu une version mineure corrective.

emms-4.3 (mai)

Ce logiciel utilisé pour gérer les fichiers multimédia dans emacs reçoit quelques corrections, affiche plus de métadonnées à l’exécution et moins d’avertissements à la compilation.

freedink-data-1.08.20170409 (avril)

Les données de ce jeu d’aventure et de rôle à la Zelda sont complétées par deux nouveaux sons, une traduction en suédois et des mises à jour des traductions catalane, espagnole et allemande, ainsi qu’une construction reproductible.

gcc-7.1.0 (mai)

Cette suite de compilateurs a ou aura sa propre dépêche pour détailler les nouveautés.

global-6.5.7 (mai)

Cet outil pour étiqueter du code source reçoit une nouvelle option --nearness, des nouveaux alias GTAGSOBJDIR et GTAGSOBJDIRPREFIX, une nouvelle commande --print, la prise en charge des espaces de noms et traits de PHP 5 et supérieur, et des corrections de bogues.

gnubik-2.4.3 (avril)

Il s’agit d’une mise à jour des traductions et la correction de bogues mineurs pour ce jeu de puzzle de type Rubik’s cube.

gnupg-2.1.21 (mai)

Cette suite d’outils autour d’OpenPGP corrige principalement un bogue important introduit par la version précédente, la suppression du squelette de configuration par défaut (remplacé par celui du système), l’installation sans être administrateur sous Windows et divers bogues.

gnutls-3.5.12 (mai)

Cette bibliothèque pour gérer les protocoles SSL, TLS et DTLS connaît une version corrigeant divers bogues (sans changement d’API ou d’ABI).

grub-2.02 (avril)

La précédente version 2.00 de ce chargeur d’amorçage datait de 2012. Cette version apporte notamment des améliorations sur l’interface graphique et la prise en charge de nouvelles plates‐formes comme ARM, ARM64 et Xen, ainsi qu’une meilleure prise en charge de coreboot (en pratique les distributions GNU/Linux utilisaient déjà des pré‐versions de la 2.02 depuis longtemps).
(source de l’image)

guile-2.2.2 (et 2.2.1) (avril)

Ce langage de programmation reçoit deux versions correctives (la dernière corrigeant la précédente). Citons notamment l’ajout d’une fonction de bac à sable pour tester du code d’utilisateurs inconnus et l’interdiction sous peine d’exception de modifier des constantes à la compilation ou à l’exécution.

guile-cv-0.1.4 (mai)

Il s’agit de la première version publique de cette bibliothèque de vision par ordinateur pour Guile Scheme, et première version incluse dans le projet GNU.

guile-ncurses-2.2 (avril)

Cette bibliothèque ncurses (interfaces textuelles) pour Guile vise la prise en charge de Guile 2.2.

icecat-52.0.2-gnu1 (avril) et 52.1.0-gnu1 (mai)

Il s’agit d’une version démarquée de Firefox, sans greffon ou extension non libre, qui suit donc les versions produites chez Mozilla.

kawa-2.4 (mai)

kawa implémente du Scheme en Java, et cette version est une corrective mineure.

less-487 (avril)

less permet de visualiser un fichier texte page par page. Cette version apporte des nouvelles commandes ESC-{ et ESC-} pour aller au début et à la fin des lignes affichées, une mise en valeur des recherches qui gère l’option « sans tenir compte de la casse » -i, le passage à Unicode 9.0.0, une option -Da sous Windows pour le mode SGR et des corrections de bogues.

libcdio-paranoia-10.2+0.94+1 (avril)

Cette bibliothèque pour gérer les images CD (mais si, vous savez, les galettes en polycarbonate et alu) reçoit quelques corrections de bogues (la précédente version 10.2+0.93+1 datant de 2014).

libidn2-2.0.1 (avril) et 2.0.2 (mai)

Cette bibliothèque gère le codage et le décodage des noms de domaine internationalisés suivant les spécifications IDNA 2008 et TR 46 (RFC 5890, 5891, 5892, 5893 et TR 46). Ces versions amènent la prise en charge de IDNA 2008 et TR 46 par défaut, et des corrections de bogues.

libmicrohttpd-0.9.53 (avril) puis 0.9.54 et 0.9.55 (mai)

Cette bibliothèque qui évolue visiblement assez vite fournit un micro‐serveur Web en C. Ces versions amènent une meilleure prise en charge de l’en‐tête Upgrade, des options de compilation pour choisir la fonction de polling suivant la plate‐forme, et diverses corrections.

linux-libre-4.10.12-gnu (avril) et 4.11.2-gnu (mai)

Le projet vise à publier et maintenir le noyau Linux 100 % libre. Les principaux blocs binaires (blobs) sont présents dans les pilotes graphiques, mais aussi pour l’accélération cryptographique, l’Ethernet ou l’écran tactile, et chaque nouvelle version du noyau amène en général son lot de nouveaux blocs binaires.

nano-2.8.1 (avril) à 2.8.4 (mai)

L’éditeur de texte nano a connu quatre versions, notamment pour corriger des bogues, des plantages, améliorer les traductions, accélérer les recherches arrières, améliorer la coloration syntaxique en PHP, éviter d’introduire des blancs intempestifs, mieux gérer les caractères de largeur double, etc.

::: The iLE88Dj. :jD88888Dj: .LGitE888D.f8GjjjL8888E; .d8888b. 888b 888 888 888 iE :8888Et. .G8888. d88P Y88b 8888b 888 888 888 ;i E888, ,8888, 888 888 88888b 888 888 888 D888, :8888: 888 888Y88b 888 888 888 D888, :8888: 888 88888 888 Y88b888 888 888 D888, :8888: 888 888 888 Y88888 888 888 D888, :8888: Y88b d88P 888 Y8888 Y88b. .d88P 888W, :8888: "Y8888P88 888 Y888 "Y88888P" W88W, :8888: W88W: :8888: 88888b. 8888b. 88888b. .d88b. DGGD: :8888: 888 "88b "88b 888 "88b d88""88b :8888: 888 888 .d888888 888 888 888 888 :W888: 888 888 888 888 888 888 Y88..88P :8888: 888 888 "Y888888 888 888 "Y88P" E888i tW88D Text Editor Homepage ocrad-0.26 (avril)

Ce logiciel de reconnaissance optique de caractères (OCR) a connu une nouvelle version de pure maintenance (la dernière publication datant de 2015).

orgadoc-0.9 (mai)

Le logiciel permet de copier et gérer un ensemble de documents sur plusieurs ordinateurs. La précédente version datait de 2004, et il s’agit surtout de mettre à jour les scripts et la documentation pour l’utilisation et l’installation.

parallel-20170422 et 20170522

Cet outil shell permet d’exécuter des tâches en parallèle sur un ou plusieurs ordinateurs. Ces versions sont nommées respectivement Санкт-Петербу́рг (Saint‐Pétersbourg) et Macron (les précédentes étant baptisées TRAPPIST-1, 13769 et George Michael). Санкт‐Петербу́рг abandonne la prise en charge de Perl 5.6 sur IRIX, --halt prend désormais en charge done en plus de success et fail, et parset initialise les variables en Bash. Et Macron n’amène que peu de nouveautés (--timeout accepte s=second, m=minute, h=hour et d=day, tandis que l’alias --dr est ajouté pour --dry-run) et sert donc de version stable.

Conclusion

Y a‐t‐il un intérêt à écrire une telle dépêche ? Bonne question, je vous remercie de l’avoir posée.

Pour LinuxFr.org, ça fait une dépêche publiée de plus, ce qui est plutôt bien (mais ça fait encore une longue dépêche diront certains, j’aurais dû en faire 33. ;)

Pour moi, ça m’a fait découvrir divers logiciels, donc j’ai trouvé ça plutôt intéressant, même si j’ai un peu de mal avec l’hétérogénéité du projet GNU, avec des annonces par courriel ou non, sur le site du projet ou non, dans les fichiers Changelog ou NEWS de l’archive, etc. Et probablement pas au point de la refaire tous les mois tout seul, parce que ça reste un poil long à rédiger. Des volontaires ?

Pour vous, je ne sais pas, mais si déjà vous lisez ça, c’est que vous êtes allés beaucoup plus loin que la plupart. Bravo, vous gagnez un niveau !

Ah oui, toute bonne conclusion doit terminer sur une ouverture : à voir les écarts de publication entre les versions, on peut se dire que le projet GNU manque de contributeurs (sur le code ou sur les sites des projets visiblement), qu’il est plus facile de pondre un nouveau logiciel que de le maintenir sur des dizaines d’années, qu’il s’attaque à des chantiers immenses (virer les blobs, par exemple). Ou plus positivement, on peut rester admiratif devant ces projets maintenus sur des dizaines d’années, ces très ambitieux projets lancés pour garantir les quatre libertés, la diversité des projets existants, la variété des langues prises en charge et le fait que des gens lisent une telle dépêche.

Télécharger ce contenu au format Epub

Lire les commentaires

Agenda du Libre pour la semaine 23 de l’année 2017

4 juin, 2017 - 18:52

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 42 événements (0 en Belgique, 37 en France, 2 au Québec et 3 en Suisse) est en seconde partie de dépêche.

Sommaire [FR Montpellier] Framapermanence - Le lundi 5 juin 2017 de 18h00 à 21h00.

Réunion du framagroupe local. Ces réunions ont pour objective de monter des projets en droite ligne des activités de Framasoft : Dégooglisons Internet, les Chatons, framalibre, framakey, framapack…

Les thèmes qui seront abordés :

  • préparation de la conférence à connec’Sud
  • organiser des Framapermanences
  • des Framapéros
  • discussions libres
  • échanges d’idées
  • faire des perspectives pour les actions futures
  • tout simplement, passer un moment convivial

Ces dernières années ont vu se généraliser une concentration des acteurs d’Internet (Youtube appartient à Google, WhatsApp à Facebook, Skype à Microsoft, etc.). Cette centralisation est nuisible, non seulement parce qu’elle freine l’innovation, mais surtout parce qu’elle entraîne une perte de liberté pour les visiteurs. Les utilisateurs de ces derniers services ne contrôlent plus leur vie numérique : leurs comportements sont disséqués en permanence afin de mieux être ciblés par la publicité, et leurs données, pourtant privées (sites visités, mails échangés, vidéos regardées, etc.) peuvent être analysées par des services gouvernementaux.

La réponse que souhaite apporter Framasoft à cette problématique est simple : mettre en valeur, pour chacun de ces services privateurs de liberté, une alternative Libre, Éthique, Décentralisée et Solidaire.

Ainsi, nous vous invitons à venir participer aux Framapermanences qui auront lieu à la Maison des Adolescents de l’Hérault, le premier lundi de chaque mois, de 18h00 à 21h00 :

  • lundi 6 mars 2017 de 18h00 à 21h00
  • lundi 3 avril 2017 de 18h00 à 21h00
  • lundi 1 mai 2017 de 18h00 à 21h00
  • lundi 5 juin 2017 de 18h00 à 21h00

Entrée libre et gratuite sur inscription.

Cet événement est proposé par le partenariat qui lie la Maison des Adolescents de l’Hérault et Montpel’libre.

Lundi 5 jun 2017 de 18h00 à 21h00

Maison des Adolescents MDA34 - 9, rue de la République 34000 Montpellier

[FR Lyon] Atelier numérique - Le lundi 5 juin 2017 de 19h00 à 21h30.

Atelier de partage de connaissances

Tout public

Soirées numériques autour de GNU/Linux et des logiciels libres. Pas de thèmes précis. Venez avec vos questions, vos envies, vos machines à libérer, pour une aide à l'install…

[FR Montpellier] Points Libres - Le lundi 5 juin 2017 de 19h00 à 21h00.

L’équipe de Montpel’libre vous propose une permanence Logiciels Libres, discussions libres et accompagnements techniques aux systèmes d’exploitation libres.

Il est aussi possible, sur inscription, de présenter plusieurs logiciels libres (Blender, LibreOffice, Gimp…) selon la demande et la présence des intervenants spécialisés.

Notre bibliothèque de livres, documents, revues… GNU/Linux, systèmes et logiciels libres est disponible à la consultation dans la salle des partenaires, au premier étage.

Notre équipe vous attend pour répondre à vos questions et satisfaire votre curiosité.

L’inscription n’est pas obligatoire, mais fortement recommandée. Entrée libre et gratuite pour tout public.

La Maison des Adolescents (MDA34) est un lieu ressource pour les jeunes de 11 à 21 ans et leur famille. L’accueil y est immédiat, sans rendez-vous aux heures d’ouverture. C’est gratuit et anonyme. Il est possible d’y rencontrer différents professionnels à l’écoute des adolescents (et de leurs parents s’ils les accompagnent) : éducateurs, psychologues, assistantes sociale, infirmiers, médecins…

Accueillir, écouter, accompagner, informer, orienter sont les missions de la MDA 34.

Tramway lignes 1, 2, 3 et 4, Bus 6, 7, 8, 11, 12 et 16 arrêt Gare Saint-Roch

GPS : Latitude : 43.606131 | Longitude : 3.878294

Carte OpenStreetMap

Rendez-vous mensuel, tous les premiers lundis.

Espace d’accueil et cyberespace de la MDA

[FR Castelnau-le-Lez] Section GNU/Linux - Le mardi 6 juin 2017 de 10h00 à 12h00.

L’équipe de Montpel’libre vous propose une permanence de dépannages pour vous aider à vous familiariser avec votre système GNU/Linux au quotidien.

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

Vous pourrez y aborder plusieurs thèmes :

  • Présentation de Linux
  • Configuration matérielle nécessaire
  • Se procurer GNU/Linux
  • Installation de Linux
  • Mise à jour et installation de nouveaux logiciels
  • Premières explorations du système
  • Installations et configurations complémentaires
  • Forums pour les débutants

Notre équipe vous attend pour répondre à vos questions et satisfaire votre curiosité, pour ce rendez-vous hebdomadaire, tous les mardis de 10h00 à 12h00, salle 38 de la Mjc de Castelnau-le-Lez, hors vacances scolaires :

  • mardi 6 juin 2017 de 10h00 à 12h00

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

Cet événement est proposé par le partenariat qui lie la Mjc André Malraux de Castelnau-le-Lez et Montpel’libre.

Mardi 6 juin 2017 de 10h00 à 12h00

Mjc Centre André Malraux 10, avenue de la Moutte, 34170 Castelnau-le-Lez

[FR Bordeaux] Lan party 0 A.D. - Le mardi 6 juin 2017 de 18h00 à 20h00.

Venez découvrir en jouant, 0 A.D., un jeu vidéo de stratégie en temps réel, similaire à Age of Empires, sous licence libre.

*Il faut venir avec son ordinateur et la version de 0 A.D. alpha 21 Ulysses installée (la dernière version du jeu).*

Afin de nous permettre de préparer la salle, merci de vous inscrire ici sur le pad, si vous participez en indiquant si vous avez besoin d'aide pour l'installation du jeu.** **

Rendez-vous à partir de 17 h 30 pour l'installation du réseau, de sorte que l'on puisse commencer à jouer à 18h.

https://play0ad.com/

https://www.giroll.org/

https://www.aquilenet.fr/

[FR Reims] Atelier Vie-Privée - Le mardi 6 juin 2017 de 18h30 à 20h30.

Un mardi soir par mois, l'association LoLiCA anime un « Atelier vie Privée » sur un thème précis.

Le but de ce rendez vous est d'expliquer, de façon très accessible, les problématiques autour de la vie privée dans notre monde numérique et des solutions à apporter pour pouvoir la préserver.

Ce mardi 6 juin 2017, nous aborderons le thème « Open Street Map la cartographie communautaire respectueuse de notre vie privée. »

Découverte d'une carte libre facile à utiliser et ou tout le monde peut participer à son évolution. Cet atelier est un retour d'expérience et une approche pratique. Il sera suivi d'un débat.

Nous nous retrouverons à partir de 18h30 à la Maison de la vie associative à l'occasion des rendez-vous de la vie associative salle 107.

Consulter notre site pour plus d'informations.

[FR Paris] Les premiers mardi de la monnaie libre et équitable - Le mardi 6 juin 2017 de 19h00 à 21h00. Afin de faire vivre notre première monnaie libre, Gwan, mise en orbite depuis le 8 mars dernier, nous vous proposons des rencontres mensuelles tous les premiers mardis du mois à **PARIS** pour

1 - échanger nos clés publiques G1et/ou Gtest, en vue d'accorder nos certifications en toute sécurité

2 - échanger sur nos expériences, idées ou autres propositions sur l'usage de G1

3 - aborder le domaine de la technique noeuds Duniter, Césium, Sakia, Silkaj, Yunohost, etc.

Les 2 premières rencontres ont eu lieu les 4 avril et 2 mai derniers à partir de 18 Heures 30 au café Bert's situé au forum des Halles sous le cinéma, à quelques mètres de la Place carré.

La prochaine rencontre aura lieu le 6 juin prochain, même lieu à partir de 19 heures.

Afin de gérer au mieux les rencontres

l'une pour les inscriptions aux rencontres

S'abonnerhttps://framalistes.org/sympa/subscribe/inscriptions_reunions_gtest_g1

Se désabonnerhttps://framalistes.org/sympa/sigrequest/inscriptions_reunions_gtest_g1

et l'autre, pour les échanges et discussions

S'abonnerhttps://framalistes.org/sympa/subscribe/monnaies.gtest.g1

Se désabonnerhttps://framalistes.org/sympa/sigrequest/monnaies.gtest.g1

Précision ces rencontres sont LIBRES et donc largement ouvertes à tous quelque soit la géolocalisation de chacun

A bientôt.

site officiel : https://fr.duniter.org/

forum : https://forum.duniter.org/

[FR Saint Martin d'Hères] Conférence : Nix, NixOS, NixOps - Le mardi 6 juin 2017 de 19h00 à 22h00.

L'écosystème Nix

Une approche déclarative et programmatique de la gestion de build, de paquets, de services, de l'OS et du déploiement.

Conférence organisée par la Guilde et animée par Valentin Reis, Doctorant au LIG.

[FR Nanterre] Portes ouvertes de l'Electrolab - Le mardi 6 juin 2017 de 20h00 à 21h00.

Le mardi soir est le jour où nous invitons les nouveaux et les curieux à découvrir l'Electrolab de Nanterre lors d'une petite visite guidée.

Qui sommes nous ?

Laboratoire, makerspace, atelier, grand garage collectif, ces termes nous décrivent tous un peu sans toutefois parvenir à être exacts ou exhaustifs.

L’Electrolab, c’est avant tout une association à but non lucratif dont l’objet est le partage des connaissances dans le domaine des sciences et des techniques.

C’est une communauté de passionnés qui se sont retroussés les manches pour faire leur petit coin de paradis électrique, mécanique, chimique et biologique : enfin le terrain de jeu dont on rêvait tous ! Il fait 1500m² et vous y êtes conviés.

Et que puis-je faire au lab exactement ?

Tout et surtout n’importe quoi, mais pas n’importe comment.

De la machine à coudre en fonte au laser 1200 Watts en passant par les tours et fraiseuses à commande numérique (ou pas), la découpe plasma, la fonderie aluminium et bronze, la sérigraphieuse et le perchlorure de fer (ouf !), il y a de quoi expérimenter dans bien des domaines. Libre à chacun d’avancer à son propre rythme dans la direction où sa curiosité l'entraine. Les seules limites : votre imagination, et la sécurité. Le hackerspace se méthamorphose constamment selon les envies et les projets de la communauté : la Doocracy (celui qui fait décide).

Je n’ai pas de projet précis…

On a de quoi faire !

On a pour habitude de dire que le plus gros projet du lab, c'est le lab lui-même ! Toutes les bonnes volontés sont bienvenues pour construire nous-même notre espace et l'aménager selon nos envies. S’initier à un domaine ou un autre, notamment lors d'ateliers et de formations entretenir ou réparer, améliorer le matériel, participer aux récup’ du week-end : la liste des choses possibles est longue et il ne tient qu'à vous de l'allonger. Par ailleurs, les membres ont aussi des projets, aussi n’hésitez pas : échangez avec eux, observez leur travail et impliquez vous ! Les projets sont documentés sur le wiki sous license libre si vous cherchez l'inspiration ou par simple curiosité.

Mais euh… pourquoi un “hackerspace” ?

Parce que nous nous revendiquons de l’esprit "hacker", qui s'exprime par exemple dans le logiciel libre et le Do It Yourself.

Au coeur de celui-ci : le partage des savoirs, l'émulation, la liberté de faire et l'envie de comprendre. Que ce soit en créant de nouvelles choses et outils, ou en améliorant continuellement ceux qui existent, l’esprit de détournement de la culture du hack correspond à cette volonté d’indépendance et d’expérimentation qui anime tous les membres.

[CH Genève] Société numérique et données sur Internet : enjeux éthiques et solutions pratiques - Le mercredi 7 juin 2017 de 19h00 à 20h30.

Cette conférence porte sur les enjeux de la centralisation d’internet et des dangers qui en résultent, mais propose aussi des solutions pratiques à ces problématiques !

L’association Framasoft fait le déplacement en terre helvétique pour nous faire part de son expérience. À l’origine de la campagne «Degooglisons Internet», cette petite association fourni une alternative crédible aux produits des « géants du web », aka les GAFAM (Google Amazon Facebook Apple Microsoft). On parlera aussi du Collectif des Hébergeurs Alternatifs, Transparents, Ouverts, Neutres et Solidaires (CHATONS)… miaou !

C’est l’occasion parfaite pour venir avec les ami·e·s et la famille que vous n’arrivez pas à faire passer du côté lumineux de la Force ;)

Organisé par itopie informatique et Alternatiba Léman.

[FR Montpellier] Install Par Tous ! Install Party ! - Le mercredi 7 juin 2017 de 12h00 à 17h00.

Reprenez le contrôle de vos machines. Avec un Gnou et un Manchot

Communément appelées "Install Party" ces événements sont dédiés à l'installation, mais aussi et surtout au support, de systèmes GNU/Linux sur vos ordinateurs personnels (ou pro d'ailleurs), dans le but de se passer des méchants systèmes d'exploitation qui rament, espionnent, et vous ont été imposés.

Bref reprendre le contrôle de vos machines pour de vrai !

Déroulement typique de l’installation sur un ordi :

  • Discuter ! Savoir quel sont vos attentes pour ce nouveau système : faut-il des outils spécifiques, aurez-vous tout ce qu'il vous faut pour profiter de votre appareil, supportera-t-il telle ou telle techno, etc.
  • Déterminer la bonne distribution en fonction de l'appareil (capacité, mémoire, cpu, etc), mais aussi en fonction de vos attentes.
  • Essayer ! La plupart des distributions linux peuvent tourner sur votre appareil sans les installer (Live) en utilisant uniquement la mémoire vive, sans toucher au disque dur. Cela permet de vérifier qu'elle marche correctement, et qu'elle réponds aux attentes.
  • Backup ! Il est fortement recommandé de faire des sauvegardes de toutes vos données AVANT DE VENIR. Cette étape peut-être longue, fastidieuse, et surtout ne concerne personne d'autre que vous (aucune raison d'avoir vos données qui se baladent sur des disques ou clef USB dans le hackerspace). Mais le cas échéant nous nous doterons d'un moyen de sauvegarde, ou vous amenez le votre, et on sauve tout ce qui peux être sauvé.
  • INSTALL !!! Cette fois-ci c'est parti on installe le système sur le disque dur, en éliminant le précédent (recommandé ;) ), ou en le conservant sur le coté au cas où (but why ?).
  • On finalise enfin l'installation par l'ajout des logiciels dont vous avez besoin, et on en profite pour vous montrer comment le faire vous même, comment se gèrent les mises à jour, et toutes les astuces propre à GNU/linux pour que vous soyez à l'aise dans votre nouvel environnement.

Une fois rentré à la maison avec votre ordinateur tout propre, il se peut que vous rencontriez encore des difficultés (y'a pas de raisons mais ça arrive), pas de problèmes nous avons conçu cet atelier pour qu'il soit régulier et porté également sur le support, l'aide aux nouveaux utilisateurs. Donc notez vos questions, vos problèmes dans un coin, et repassez nous voir la semaine suivante ! (vous pourrez également nous poser des questions sur IRC (chat) ou sur la mailling liste, si vous ne pouvez pas attendre)

En espérant libérer un maximum de vos machines !

[FR Auch] Initiation à Linux - Le mercredi 7 juin 2017 de 14h00 à 17h00.

Cette découverte de Linux est proposée au Café associatif d'Auch, l'Abri des Possibles, tous les mercredi.

[FR Lablachère] Ateliers du Libre - Le mercredi 7 juin 2017 de 18h00 à 20h30.

Vous venez d'installer Linux sur votre ordinateur et ça comble votre soif de liberté ! Mais quels logiciels choisir, comment les installer, les configurer ? Comment paramétrer votre navigateur internet pour ne pas vous faire pister ? Lire vos mails, configurer le bureau ?

Autant de questions pour lesquelles vous trouverez les - bonnes - réponses auprès des animateurs de l'association "ardechelibre.org" aux Ateliers du Libre.

Bar ouvert pendant l'atelier

Participation libre aux frais

[FR Chambéry] Mapathon Missing Maps - Le mercredi 7 juin 2017 de 18h30 à 21h30.

Venez nous aider à cartographier sur OpenStreetMap, la carte du monde collaborative et libre !

CartONG et Le Mug vous invitent à un mapathon Missing Maps pour découvrir la cartographie participative et humanitaire dans OpenStreetMap : pas besoin d'être un expert, c'est accessible à tout le monde !

Pourquoi ?

L’objectif du projet Missing Maps est de créer des cartes pour les zones de crise des pays en voie de développement qui en ont le plus besoin.

En effet, on peut penser qu'aujourd'hui toutes les parties du monde sont cartographiées, mais en réalité nombreuses régions ne possèdent encore aucunes cartes. L'objectif de Missing Maps est donc de cartographier toutes ces zones encore invisibles sur les cartes, pour permettre par la suite aux collectivités locales et acteurs de l'humanitaire de pouvoir agir plus efficacement en cas de crise.

Comment ?

Avec la plateforme de cartographie libre et contributive OpenStreetMap (OSM, le « Wikipédia des cartes ») un outil formidable pour « remplir les blancs », n'importe qui peut participer à la cartographie de n'importe quelle zone de la planète : il suffit d'un ordinateur, d'une souris et d'une connexion internet ! Grâce à la couverture globale d'image satellites disponible aujourd'hui, il est possible de tracer facilement routes, bâtiments ou cours d'eau, autant d'informations très utiles pour les organisations humanitaires et de développement sur le terrain.

Le programme de la soirée

Nous vous proposons de découvrir comment contribuer à OpenStreetMap durant un « mapathon ». Cet événement s'inscrit dans le cadre de l'initiative globale Missing Maps, projet humanitaire qui vise à cartographier en amont les parties du mondes vulnérables aux catastrophes naturelles, crises sanitaires, environnementale, aux conflits et à la pauvreté.

Au programme :

  • 18h30 : accueil des participants
  • 18h40 : Mot de bienvenue, présentation du projet Missing Maps et du déroulement de la soirée
  • 18h50 : Présentation de la contribution dans OSM
  • 19h00 : Cartographions !

Lightning Talks

  • 21:30 Fin du mapathon

Où?

A l'espace de coworking Le Mug , 129 rue Sommeiller, 73000 Chambéry

Un grand merci au Mug pour l'accueil !

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

[FR Paris] Mapathon Missing Maps - Le mercredi 7 juin 2017 de 18h30 à 21h30.

Venez nous aider à cartographier sur OpenStreetMap, la carte du monde collaborative et libre !

CartONG, Médecins Sans Frontières et la FPH vous invitent à un mapathon Missing Maps pour découvrir la cartographie participative humanitaire dans OpenStreetMap : pas besoin d'être un expert, c'est accessible à tout le monde !

Pourquoi ?

L’objectif du projet Missing Maps est de créer des cartes pour les zones de crise des pays en voie de développement qui en ont le plus besoin. En effet, on peut penser qu'aujourd'hui toutes les parties du monde sont cartographiées, mais en réalité nombreuses régions ne possèdent encore aucunes cartes. L'objectif de Missing Maps est donc de cartographier toutes ces zones encore invisibles sur les cartes, pour permettre par la suite aux collectivités locales et acteurs de l'humanitaire de pouvoir agir plus efficacement en cas de crise.

*Comment ? *

Avec la plateforme de cartographie libre et contributive OpenStreetMap (OSM, le « Wikipédia des cartes ») un outil formidable pour « remplir les blancs », n'importe qui peut participer à la cartographie de n'importe quelle zone de la planète : il suffit d'un ordinateur, d'une souris et d'une connexion internet !

Grâce à la couverture globale d'image satellites disponible aujourd'hui, il est possible de tracer facilement routes, bâtiments ou cours d'eau, autant d'informations très utiles pour les organisations humanitaires et de développement sur le terrain.

Le programme de la soirée

Nous vous proposons de découvrir comment contribuer à OpenStreetMap durant un « mapathon ». Cet événement s'inscrit dans le cadre de l'initiative globale Missing Maps, projet humanitaire qui vise à cartographier en amont les parties du mondes vulnérables aux catastrophes naturelles, crises sanitaires, environnementale, aux conflits et à la pauvreté.

Au programme :

  • 18h30 : accueil des participants
  • 18h40 : Mot de bienvenue, présentation du projet Missing Maps et du déroulement de la soirée
  • 18h50 : Présentation de la contribution dans OSM
  • 19h00 : Cartographions !

Lightning Talks

  • 21:30 Fin du mapathon

Où?

A la Fondation pour les Progrès de l'Homme, 38 Rue Saint-Sabin, 75011 Paris

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

Nous sommes gracieusement accueillis à la FPH, un grand merci pour l'accueil !

[FR Nantes] Contribution Wikipédia Femme Féminisme - Le mercredi 7 juin 2017 de 18h30 à 21h30.

L'objectif de cet atelier est de rendre les femmes plus visibles sur Wikipédia en écrivant des biographies de femmes ou des articles en lien avec le féminisme.

Ouvert à tou.te.s, sans inscription, ces Ateliers sont libres et gratuits.

Cet atelier a lieu à l'Espace Simone de Beauvoir, 15 du quai Ernest Renaud, Nantes, arrêt ''Gare maritime'' de la ligne 1 du tramway.

Cet atelier fait partie du projet Femmes et féminisme de Wikipédia.

Voici les dates, pour le second semestre :

  • Mercredi 18 janvier - Lundi 30 janvier
  • Mercredi 15 février - Lundi 27 février
  • Samedi 18 mars à 10h-18h - Mercredi 29 mars
  • Lundi 10 avril - Mercredi 26 avril
  • Mercredi 10 mai - Lundi 22 mai
  • Mercredi 7 juin - Lundi 19 juin

Nous suivre sur Twitter : @lessanspagEs

[FR Bordeaux] Atelier artiste - hacker - Le mercredi 7 juin 2017 de 19h00 à 21h00.

Ateliers-cours à la fabrique-pola - L@bx

Tous les mercredi, 19h00, à partir du 07 décembre 2016

Passer aux logiciels libres pour toute sa pratique artistique :

graphisme, édition, site internet, photo, vidéo, 3D, dossiers, imprimerie, son, installations multimédia…

Reprendre le contrôle de sa vie privée

Chiffre ses emails, échapper aux GAFAM'S, se débarrasser des pubs, surfer avec tor, mettre en place un VPN…

S'approprier, détourner, contourner

Les machines physique et langagière, les espaces publics, les symboles, les techniques….

  • Quelques notions et référence sur l'histoire du hack…

Matériel : clé usb, pc portable (si possible).

[FR Chartres] OpenAtelier - Le mercredi 7 juin 2017 de 20h00 à 23h59.

L'OpenAtelier est un moment de rencontre et de partage ou les membres et curieux sont invités à échanger sur leurs idées et leurs projets.

Les espaces techniques sont également ouverts aux réalisations (électronique, informatique, menuiserie, impression 3D, découpe vinyle…).

Pour les curieux, c'est le bon moment pour venir découvrir l'association et ses membres.

[FR Toulouse] Rencontre Tetalab - Le mercredi 7 juin 2017 de 21h00 à 23h00.

Rencontre hebdomadaire des hackers et artistes libristes Toulousains.

[QC Montréal] Les mercredis cartographie - Le mercredi 7 juin 2017 de 18h30 à 21h30.

OpenStreetMap s'installe à la Grande bibliothèque !
Les cartes font partie de notre quotidien: elles nous servent à nous orienter, localiser des objets, des événements… mais pourquoi se contenter de les utiliser? Découvrez le projet mondial de cartographie OpenStreetMap, apprenez à améliorer la représentation des lieux que vous connaissez et ainsi construire les nouvelles cartes dont vous avez besoin.
Au programme des Mercredis cartographie : - 18h30 : Accueil des participants, découverte d'OpenStreetMap pour les débutants. Si vous avez déjà assisté à notre présentation « OpenStreetMap, le monde entre nos mains », vous pouvez améliorer les données de Montréal pendant ce temps ! - 19h : Cycle de formation progressif pour s'initier à la contribution à OSM. Au programme cette semaine : dessinez votre maison… et celle de vos voisins ! - 19h30 : Contribution aux importations des données ouvertes de la Ville grâce au gestionnaire de tâches d'OSM Montréal. - 20h : Présentation de la cartothèque par les bibliothécaires de BAnQ, et/ou les dernières actualités de la communauté OpenStreetMap internationale résumées quelques minutes. Pour ne pas perdre le nord. - 20h30 : La communauté locale se retrouve pour travailler sur les projets en cours, et améliorer les données de Montréal dans OSM.

[FR Toulouse] PGDay France - Le jeudi 8 juin 2017 de 09h00 à 17h00.

Le PGDay France est un moment de rencontres et de conférences pour la communauté francophone de PostgreSQL.

Les conférences s'adressent à tous les utilisateurs du logiciel : étudiants, administrateurs systèmes, DBA, développeurs, chefs de Projets, décideurs.

[FR Arles] Libérer son ordinateur : GNU/LINUX - Pourquoi ? Comment ? - Le jeudi 8 juin 2017 de 18h30 à 20h30.

Présentation du système d’exploitation libre GNU/linux

avec Attac Pays d'Arles & Arles Linux

Pour une fois, le système dont il est question ici, celui dont nous vous montrerons qu’on peut aisément se passer n’est pas le système politico financier mondialisé …

Il s’agit en effet du systèmes d’exploitation - OS, Operating System dans une langue que Shakespeare ne reconnaîtrait pas. Le cœur logiciel de nos ordinateurs.

Mais est-ce si éloigné ?

Abus de position dominante, vente liée et politique de lobbying agressive pour l’un, évasion fiscale et travail des enfants pour l’autre, les principaux concurrents sont d’excellents exemples de cette société que nous dénonçons.

GNU/Linux nous permet de nous en débarrasser !

Jeudi 8 juin de 18h30 à 20h30

Salle Jean et Pons Dedieu, 62 rue du 4 septembre 13200 Arles

[FR Paris] Soirée de Contribution au Libre - Le jeudi 8 juin 2017 de 19h00 à 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

tout nouveau projet est le bienvenu.

[FR Lyon] Jeudi Bidouille - Le jeudi 8 juin 2017 de 19h00 à 22h00.

Atelier de dépannage après une Install Party et de partage de connaissance entre utilisateurs de logiciels libres.

La Maison pour Tous / Salle des Rancy, l'ALDIL et des associations partenaires organisent cet atelier pour permettre à des utilisateurs de logiciels de se rencontrer pour échanger et se dépanner mutuellement dans leurs usages.

Tout public

De 19h à 22h

[QC Montréal] CLA - Rencontre des utilisateurs GNU/Linux de Montréal - Le jeudi 8 juin 2017 de 18h30 à 21h30.

Le Club Linux AtomicLe Club Linux Atomic (CLA) regroupe des utilisateurs, novices comme aguerris, de systèmes d’exploitation GNU/Linux et de logiciels libres. Il a pour principal objet de mieux faire connaître l’informatique libre et d’en favoriser l’utilisation par le plus grand nombre.La programmation de la rencontreConsultez la programmation de notre rencontre sur notre site Web.InscriptionNous vous invitons à vous inscrire sur Framadate. Votre inscription nous permet de configurer la salle en fonction du nombre de participants.Tous sont bienvenus à y participer. N’hésitez pas à venir accompagner! Invitez les personnes de votre entourage à fraterniser avec notre communauté.
English speaking people are welcome.

[FR Paris] Journées Perl 2017 - Du vendredi 9 juin 2017 à 09h00 au samedi 10 juin 2017 à 18h00.

Le vendredi 9 et le samedi 10 juin 2017, les Mongueurs de Perl organisent la quatorzième conférence « Les Journées Perl ».

Cet événement rassemblera les utilisateurs de Perl, du débutant à l'expert. Ce sera l'occasion de rencontrer de nombreux grands noms de la communauté Perl francophone, de partager nos expériences, et d'enrichir nos connaissances.

Nous souhaitons toucher un public large, notamment au travers des présentations en direction des débutants et des professionnels, utilisateurs de Perl 5 comme de Perl 6 ou souhaitant le devenir.

[FR Montpellier] Les logiciels libres, parlons-en ! - Le vendredi 9 juin 2017 de 17h00 à 19h00.

Le Faubourg Marché, qu’est-ce que c’est ?

Le Faubourg Marché est une permanence partagée qui permet aux associations d’accueillir ensemble, les publics de ces associations une fois par semaine, le vendredi entre 17h00 et 19h00, au 19, rue du Faubourg de Nîmes, 34000 Montpellier.

L’idée est de s’informer et d’informer les adhérents des diverses associations sur le fonctionnement du lieu et des associations, et notamment sur les 5 partenaires qui l’animent et lui permettent ainsi d’exister (autour.com, L’Accorderie, enercoop, modulauto, La Nef). Lors de cette permanence partagée vous pourrez rencontrer les associations La Graine (monnaie locale de Montpellier), éCOhabitons, Montpellier à pied, et bien sûr Montpel’libre.

Alors, si vous avez un peu de temps le vendredi soir, voici une occupation qui me semble très intéressante.

Montpel’libre est une association et un groupe d’utilisateurs (GULL), qui propose une multitude d’activités dans le cadre de la promotion des logiciels libres, et des Communs.

Depuis longtemps déjà, Montpel’libre participe à l’économie sociale et solidaire en organisant tout un éventail d’ateliers et de manifestations, au développement durable et à l’innovation sociale au travers de permanences et ateliers de présentations des logiciels libres et évidement les cartoparties, véritable actions citoyennes, sur le thème de l’accessibilité des personnes en situation de handicap.

L’activité économique, l’intérêt collectif, le fonctionnement démocratique, autant d’éléments que porte Montpel’libre, en proposant un accès entièrement libre et gratuit à une éducation populaire, au travers de ses ateliers à destination de tous les publics.

Les logiciels libres parlons-en ! Ouvrons le dialogue sur l’ouverture des données ! Partageons nos expériences pour une meilleure répartition des connaissances.

Ces permanences sont suivies d’un Apéro « refaire le monde » convivial et partagé, de 18h30 à 21h30. Elles ont lieu au Faubourg marché, tous les vendredis de 17h00 à 19h00 :

  • vendredi 2 juin 2017 de 17h00 à 19h00
  • vendredi 9 juin 2017 de 17h00 à 19h00
  • vendredi 16 juin 2017 de 17h00 à 19h00
  • vendredi 23 juin 2017 de 17h00 à 19h00
  • vendredi 30 juin 2017 de 17h00 à 19h00

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

Cet événement est proposé dans le cadre du partenariat qui lie le Faubourg Marché et Montpel’libre.

Vendredis 2, 9, 16, 23 et 30 juin 2017 de 17h00 à 19h00

Le Faubourg - 15, rue du Faubourg de Nîmes, 34000 Montpellier

Tramway lignes 1, 2 et 4 arrêt Corum

GPS Latitude : 43.614186 | Longitude : 3.881404

Carte OpenStreetMap

[FR Le Tholonet] Réunion mensuelle de l'Axul - Le vendredi 9 juin 2017 de 20h00 à 23h55.

Les membres de l'Axul (Association du Pays d'Aix des Utilisateurs de Linux et des Logiciels Libres) vous invitent à leur réunion mensuelle qui aura lieu le vendredi 9 juin de 20h00 à 23h55 au 1er étage du centre culturel Georges Duby du Tholonet (859 avenue Paul Julien, à proximité de la place du marché) à Palette, premier village sur la D7n au Sud-Est d'Aix.

Ordre du jour

  • 20h00 - 20h15 : Accueil
  • 20h15 - 20h30 : Présentation des participants et organisation de la soirée
  • 20h30 - 22h30 : Atelier sur l'autohébergement

L'auto-hébergement sera présenté avec des démonstrations de "ownCloud" et de "Nextcloud" suivies par un atelier de mise en œuvre, sur une plateforme Raspberry Pi par exemple.

  • 22h30 - 23h55 : Discussion générale
    • Compte rendu de l'Open Bidouille Camp Provence (19 - 20 mai)
    • Compte rendu de l'Orme 2.17 (31 mai - 1 juin)
    • Préparation du Samedi Libre du 1 juillet
    • Autres interventions de l'Axul…
    • Information sur les ateliers : Arduino, Raspberry Pi…
    • Autres questions ?

Événements ultérieurs

  • Samedi Libre du 1 juillet 2017

La plupart des réunions donnent lieu à une présentation ou à une démonstration liée au Logiciel libre.

Ces réunions libres et gratuites sont ouvertes à toutes et à tous, débutant(e)s ou expert(e)s GNU/Linux, membres ou non de l'Axul.

Entrée Libre. Tout Public.

[CH Pully] Pully.INTERGEN.digital - Le samedi 10 juin 2017 de 10h00 à 17h00.

Entraide numérique de 7 à 107 ans

Les enfants sont associés aux parents, aux informaticiens bénévoles, et aux seniors, pour assurer une entraide numérique intergénérationnelle mensuelle.

Bien souvent, nos "digital naïfs", heu pardon, nos "digital natifs" sont souvent bien plus appropriés pour expliquer simplement à nos seniors, le fonctionnement d'un Smartphone, explorer des jeux sympas (là ils sont trop forts… ;)

Que ce soit pour faire son Ebanking, une réservation, dépatouiller un truc, ou explorer de nouvelles possibilités, au lieu de le faire tout seul chez soi, autant s'y mettre à plusieurs. D'autant que si les formations c'est bien, la mise en pratique après, c'est parfois un peu "galère"… Alors qu'avec un "junior" sous la main, c'est souvent débloqué en 5 minutes (4 minutes pour le sortir de son jeux et attendre la fin de la "partie en cours", et 1 minute pour débloquer le truc…Patience, il va venir)

Combien cela coûte ? Rien du tout ! Le local et électricité sont offerts par la coopérative d’habitation des Liaudes Le WiFi par le président de CloudReady.ch, et repas et boissons par vous Qui venez avec un peu, à boire et à manger, avec vos propres équipements informatiques, si possible, sinon sans, on t’en prêtera.

• Tu viens quand tu peux,

• tu repars quand tu veux,

• tu feras ce que tu pourras, et dans la bonne humeur ;-)

Mais on fait aussi des trucs cool, comme "PC revival" car on peut faire du numérique en récupérant les vieux portables Windows XP, pour les faire "revivre" sous Linux Facile !

Aussi des "Mapathon", et tu peux venir découvrir "OpenStreetMap" et MissingMaps.org

• Cf. http://pully.intergen.digital

C'est simple, c'est facile à faire !

Tu voudrais la même chose dans ta commune ? Fais-le :)

http://intergen.digital

[CH Genève] Portes ouvertes d'itopie - Le samedi 10 juin 2017 de 10h00 à 18h00.

*Portes ouvertes de la coopérative itopie informatique ! *

Vous avez toujours rêvé de venir voir ce qu'il se passe chez itopie dans jamais oser ? Le 10 juin, les portes sont grandes ouvertes à tous, n'hésitez plus !

Au programme :

  • découverte des logiciels libres
  • atelier sculpture avec du vieux matériel informatique pour les enfants et les plus grands (de 10h à 14h)
  • ateliers spontanés autour des alernatives libres
  • atelier-performance-marionnettiste "Youtube Vivant" (de 14h à 18h) pour rendre youtube plus humain (Dans le cadre du festival Baz'Art : http://www.baz-art.ch/2017/)
  • discussions, rencontres, café et bonne humeur :)

Venez nombreux, vous pourrez aussi profiter du festival Baz'Art et de ses nombreuses installations, concerts, buvette, spectacles, toute la journée dans la rue Lissignol.

À samedi ! o/

[FR Valenciennes] Permanence ValLibre - Le samedi 10 juin 2017 de 09h30 à 12h00.

Permanence assistance informatique.

Dépannage petits bobos informatiques.

Initiation à l'informatique libre.

Tous les samedis ouvrables sauf les derniers samedis du mois et les samedis en période de vacances scolaires.

Si besoin particulier, la prise de rendez-vous est fortement conseillée.

Téléphone accueil MQCV : 03 27 22 43 90

[FR Fontenay-le-Fleury] Install Party GNU/Linux - Le samedi 10 juin 2017 de 10h00 à 17h30.

l'association Root66 vous invite à une install party GNU/Linux, le samedi 10 juin 2017 (10h-17h30) en salle Crevillent à la mairie de Fontenay le Fleury.

Cette journée sera consacrée à installer des logiciels et systèmes d'exploitation libres (principalement GNU/Linux) en "dur" ou en virtuel sur les matériels apportés par les visiteurs.

Venez avec votre machine, nous vous y aiderons

Les visiteurs intéressés par une installation sont invités à apporter leur matériel. Ils penseront à sauvegarder au préalable leurs données personnelles sur un support externe et à défragmenter leur disque dur.

Durant cette journée, les visiteurs intéressés par des démonstrations et explications pourront s'adresser aux membres de Root66 disponibles. Vous pouvez aussi venir simplement discuter avec nous et découvrir le monde du logiciel libre.

Ouvert à tou·te·s – accessible aux débutant·e·s

[FR Castelnau-le-Lez] Atelier développement et programmation - Le samedi 10 juin 2017 de 10h00 à 12h00.

Pour cette nouvelle saison, les ateliers Dev/Prog de Castelnau auront lieu chaque semaine le samedi matin, pour satisfaire aux attentes de toutes et tous.

Rendez-vous hebdomadaire, tous les samedis, salle 38 de la mjc (fermé pendant les vacances).

Cet atelier de développement est essentiellement axé sur les langages du Web : html, css (même si ce ne sont pas des langages à proprement parler) javascript et PHP, possibilité aussi d’utiliser Ajax, Jquery, Sqlite et MySql, mais il peut aussi aborder d’autres langages à la demande.

Notre équipe vous attend pour répondre à vos questions et satisfaire votre curiosité.

Entrée libre et gratuite sur inscription.

Bus Ligne 35 arrêt Collège Frédéric Bazille

Tramway ligne 2 arrêt La Galine

GPS : Latitude : 43.633946 | Longitude : 3.905794

Carte OpenStreetMap

Samedis 3 et 10 juin 2017 de 10h00 à 12h00

Mjc Centre André Malraux 10, avenue de la Moutte, 34170 Castelnau-le-Lez

[FR La Couronne] Permanence - accueil public - Le samedi 10 juin 2017 de 10h00 à 13h00.

Notre permanence d'accueil avec le sourire, le café et les gâteaux !

Lieu de rencontre et d'échange convivial pour discuter informatique et outils numériques.

Cette association permet à chacun de découvrir également l'univers de Linux et par extension de tous les **logiciels* et matériels libres*.

Entrée Libre. Tout Public.

[FR Roubaix] Choisir un OS et des logiciels libres, les installer ! - Le samedi 10 juin 2017 de 10h00 à 12h30.

Choisir un OS et des logiciels libres, les installer !

http://www.mediathequederoubaix.fr/agenda/install-party-linux-0

Nous vous invitons à participer au cycle “Choisir un OS et des logiciels libres, les installer !” organisé, pour la 5ème année consécutive par et à la Médiathèque de Roubaix.

- ce 03/06 de 10h00 à 12h30, sera un atelier au cours duquel pour rappellerons les principales fonctions d’un système d’exploitation pour ordinateur, les qualités et défauts des plus courants (Linux, Macos, Windows) et les choix possibles.

- le samedi 10/06 de 10h00 à 18h00, vous pourrez emmener votre ordinateur, portable ou fixe (pas besoin d’emmener clavier, souris, écran) pour y installer une version de Linux (lubuntu sera notre préconisation).

Pensez à faire une défragmentation de votre disque dur (http://www.commentcamarche.net/faq/58-defragmenter-son-disque-dur) et à sauvegarder votre données essentielles avant cette date

- au cours des deux ateliers suivants (les 17 et 24/06 de 10h00 à 12h30), toujours avec votre ordinateur, vous pourrez apprendre l’essentiel pour utiliser Linux Ubuntu au jour le jour,

N’hésitez pas à nous contacter pour toute question complémentaire, ça se passe 2, rue Pierre Motte à Roubaix !

[FR Casseneuil] Installe Partie - Le samedi 10 juin 2017 de 10h30 à 17h00.

Samedi 10 juin, de 10h30 à 17h

** aGeNUx et 2L **
organisent une Installe Partie à Casseneuil

Nous vous y attendons, à bientôt

Plan d'accès

[FR Clisson] Café vie privée - Le samedi 10 juin 2017 de 14h00 à 18h00.

Ce café vie privée se déroulera dans la salle Aqua’Trium, esplanade de Klettgau à Clisson.

Il est organisé en partenariat avec l’association Gullivigne: Groupe d’Utilisateurs de Logiciels Libres et FabLab du Vignoble Nantais.

Venez échanger avec nous et apprendre à protéger vos données personnelles lors des ateliers organisés tout au long de l’après­-midi.

L’entrée est libre et gratuite, et les ateliers sont ouverts à toutes et à tous !

Programme de l’après midi :

***À* partir de 14h**

  • Protéger sa vie privée en ligne : Échanges sur les bonnes pratiques d’hygiènes numériques (naviguer sur Internet, gérer ses mots de passe, etc.), les alternatives libres, les metadonnées, le cyberharcèlement, etc. Présentation d’outils et de méthodes pour se protéger.

***À* partir de 16h**

  • Chiffrer ses communications : Atelier d’initiation pour apprendre à chiffrer ses mails avec PGP et ses sms avec Silence ou Signal.
  • Chiffrer son trafic sur Internet : Présentation du VPN (réseau privé virtuel), de son fonctionnement et de sa configuration.
  • Protéger son anonymat: Présentation du système d’exploitation Tails et du réseau Tor, et Installation sur clé USB.
  • Désactiver le sans contact indiscret de sa carte bancaire: Découverte de la radio-identification et désactivation d’une puce sans contact.

N’hésitez pas à venir avec votre ordinateur ! Vous pourrez en profiter pour installer des outils lors des ateliers pour protéger votre vie privée.

Ou venez avec une clé USB avec un espace d’au moins 4Go pour installer le système Tails.

[FR Strasbourg] Décentraliser ses usages numériques - Le samedi 10 juin 2017 de 14h00 à 18h00.

Lors de cet atelier, des bénévoles d’Alsace Réseau Neutre et d’autres associations, vous proposent de reprendre le contrôle sur vos données numériques en vous accompagnant dans l’adoption de solutions alternatives à vos usages numériques courants.

Concrètement, il s’agit de vous aider à :

  • Configurer votre navigateur pour limiter les données transmises à votre insu
  • Découvrir des services numériques éthiques
  • Installer Linux ou LineageOS (Install Party)
  • Prendre en main une solution d’auto-hébergement qui vous permet d’avoir votre propre cloud de fichier, d’héberger votre site web ou encore vos mails (La brique Internet / YunoHost)

Tout public

Gratuit (dons acceptés)

*Inscriptions : , *

[FR Martigues] Install Party - Le samedi 10 juin 2017 de 14h00 à 17h00.

L’association vous invite à une install party,.

Lieu EPN Médiathèque de Martigues, Salle des rencontres.

Responsables

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

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 avec un ensemble de et pour une utilisation quotidienne.

Entrée Libre. Tout Public.

[FR Ivry-sur-Seine] Mapathon Missing Maps - Le samedi 10 juin 2017 de 14h00 à 18h00.

Venez nous aider à cartographier sur OpenStreetMap, la carte du monde collaborative et libre !

CartONG, la commune d'Ivry-sur-Seine avec la participation du comité de jumelage, et des associations maliennes d’Ivry, vous invitent à un mapathon Missing Maps pour découvrir la cartographie participative et humanitaire dans OpenStreetMap : pas besoin d'être un expert, c'est accessible à tout le monde !

Pourquoi ?

L’objectif du projet Missing Maps est de créer des cartes pour les zones de crise des pays en voie de développement qui en ont le plus besoin. En effet, on peut penser qu'aujourd'hui toutes les parties du monde sont cartographiées, mais en réalité nombreuses régions ne possèdent encore aucunes cartes. L'objectif de Missing Maps est donc de cartographier toutes ces zones encore invisibles sur les cartes, pour permettre par la suite aux collectivités locales et acteurs de l'humanitaire de pouvoir agir plus efficacement en cas de crise.

*Comment ? *

Avec la plateforme de cartographie libre et contributive OpenStreetMap (OSM, le « Wikipédia des cartes ») un outil formidable pour « remplir les blancs », n'importe qui peut participer à la cartographie de n'importe quelle zone de la planète : il suffit d'un ordinateur, d'une souris et d'une connexion internet ! Grâce à la couverture globale d'image satellites disponible aujourd'hui, il est possible de tracer facilement routes, bâtiments ou cours d'eau, autant d'informations très utiles pour les organisations humanitaires et de développement sur le terrain.

Le programme du mapathon

Nous vous proposons de découvrir comment contribuer à OpenStreetMap durant un « mapathon ». Cet événement s'inscrit dans le cadre de l'initiative globale Missing Maps, projet humanitaire qui vise à cartographier en amont les parties du mondes vulnérables aux catastrophes naturelles, crises sanitaires, environnementale, aux conflits et à la pauvreté.

Au programme :

  • 14h00 : accueil des participants et lancement du mapathon
  • 16h00 : Remise aux participants de la version imprimée de la carte de la commune de Dianguirdé par Séverine Peter, adjointe au maire d'Ivry-sur-Seine, chargée de la communication
  • 18:00 Fin du mapathon

Où?

A l'espace public Internet JJ. Rousseau - Maison de quartier Ivry-Port , 46 rue Jean-Jacques Rousseau 94200 Ivry sur Seine

Un grand merci à la Maison de quartier Ivry-Port pour l'accueil !

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

[FR Ivry sur Seine] Cours de l'Ecole du Logiciel Libre - Le samedi 10 juin 2017 de 14h00 à 18h00.

Présentation de l'E2L

Quel est le rôle de l'école du logiciel libre ?

Tout d'abord, ce n'est pas une école comme les autres. Elle n'a pas d'établissement fixe, pas de cours de récréation, pas de carte d'étudiant, ni de diplôme de fin d'année.

Comme toutes les écoles, son rôle est d'apprendre à ses élèves les logiciels libres, c'est-à-dire :

  • comment en trouver de bons parmi les nombreux sites qui en proposent,
  • comment en prendre possession en fonction des licences,
  • comment les installer en fonction de ses besoins,
  • comment les tester et les utiliser,
  • comment en comprendre le fonctionnement pour ensuite les modifier,
  • comment écrire ses propres logiciels libres.

En fait, l'école du logiciel libre est une université populaire, comme celles qui ont vu le jour en France à partir du 19 ème siècle, et dont le but est de transmettre des connaissances théoriques ou pratiques à tous ceux qui le souhaitent. Et pour atteindre ce but, sa forme juridique est de type " association à but non lucratif ".

Comment fonctionne l'école ?

Cette école étant une association, elle possède, comme toutes les autres, un bureau, élu chaque année en assemblée générale, pour l'administrer. Mais elle a aussi des responsables pédagogiques dont le rôle est essentiel car ce sont eux qui établissent les programmes des cours en fonction des souhaits des adhérents, valident les candidatures des enseignants et affectent les sessions.

Les membres du bureau et les responsables pédagogiques forment "l'encadrement de l'école ". Tous les membres "encadrants" doivent être membres de l'association.

Les locaux où se déroulent les cours seront ceux que l'on veut bien nous prêter : une salle des fêtes, un théâtre, une salle de réunion publique, un amphi dans une école publique, ou autre.

Les thèmes des cours sont définis par les adhérents en fonction de leurs envies, de leurs besoins. Les cours sont ensuite décidés par les responsables pédagogiques de l'école en fonction des enseignants disponibles.

Afin de permettre au plus grand nombre de participer et d'assister aux cours, les sessions se tiennent essentiellement le samedi. Une première de 9h à 12h30, et une autre de 14h à 17h30.

Programme détaillé sur le site http://e2li.org

[FR Juvisy-sur-Orge] Permanence GNU/LINUX - Le samedi 10 juin 2017 de 14h30 à 16h30.

Permanence GNU/LINUX, installation et maintenance par LINESS en partenariat avec l'ACJ (Association Culture et Jeunesse) de Juvisy-sur-Orge.

Il s'agit d'une assistance pour vous aider à installer et utiliser LINUX, mais ce n'est pas un cours à proprement parler.

Aucune inscription préalable n'est nécessaire, aucune assiduité n'est requise.

Quand vous avez un problème vous passez nous voir.

C'est un pavillon dans un jardin.

Attention du fait des travaux de la gare l'accès en voiture peut être difficile.

Éventuellement stationner parc Danaux ( à coté du pont sur la Seine ) qui est gratuit le samedi après-midi ( 3 mn à pied après pour aller à l'ACJ)

Par contre c'est tout à coté de la gare.

Télécharger ce contenu au format Epub

Lire les commentaires

Sortie d'it-edit version 3.0

3 juin, 2017 - 12:01

La version 3.0 de l'éditeur it-edit (Integrated Terminals Editor) est disponible.

La principale amélioration de cette nouvelle version est l'intégration optionnelle de la correction orthographique à l'aide de la bibliothèque de Sébastien Wilmet (mainteneur de gtk-sourceview3 - sur laquelle se base it-edit - et auteur de Texilla entre autres) gspell-1.

Mais c'est loin d'être le seul changement dans le code d'it-edit, et pas le seul ajout non plus.

Il s'agit de la 4e version majeure d'it-edit, et vous pouvez en voir une description plus détaillée dans l'annonce de la version 1.0.1.

Changements dans cette nouvelle version

Le logiciel est maintenant une GtkApplication en lieu et place de la paire gtk_init(…) / gtk_main(…), ce qui implique pas mal de changements dans le fond. Il améliore sa capacité à reconnaître le langage de programmation utilisé afin de colorer syntaxiquement les fichiers.

Il se sert maintenant du GtkSourceFileSaver de la bibliothèque gtk-sourceview3 ce qui permet de définir le jeu de caractères (encodage) lors de la sauvegarde de vos fichiers, faire des copies de sauvegarde, et choisir le caractère de fin de ligne.

La manière de gérer les fichiers vierges nommés « New » change : le fichier est créé dans l'emplacement des fichiers temporaires de votre système puis le fichier est effacé mais it-edit vous laisse disposer du tampon ce qui permet au fichier vierge de disposer d'un chemin valide, sans réellement exister.

Il implémente maintenant quelques propres types de G_OBJECT que vous pouvez en partie réutiliser, si le cœur vous en dit…

Nouveautés d'it-edit version 3.0 Correction orthographique intégrée

Il intègre maintenant optionnellement la correction orthographique grâce a la bibliothèque gspell-1. On peut bien sûr configurer la langue en téléchargeant des dictionnaires myspell, aspell ou ispell.

Deux modes de correction sont disponibles :

  • en place : les mots mal orthographiés sont soulignés et vous pouvez les corriger grâce au menu contextuel ;
  • modale : une fenêtre de dialogue permet de parcourir le document à la recherche de mots mal orthographiés.

Comme la bibliothèque gspell-1 est relativement jeune, elle peut ne pas être disponible sur tous les systèmes ; les paquetages *.deb et *.rpm n'incluent pas gspell-1 comme dépendance et it-edit peut fonctionner sans cette bibliothèque.

On peut malgré tout installer la version de développement (-dev ou -devel) de gpsell-1 si cela est possible avant d'installer it-edit, ou utiliser des paquets Debian, disponibles dans le dépôt sid ou dans le ppa gnome3-staging, entre autres.

Introduction de la notion de session

Chaque fichier ouvert est enregistré :

  • s'il est fermé, il n'est plus enregistré ;
  • chaque fichier de documentation lancé avec le File Handler est enregistré ;
  • chaque application lancée avec it-edit est enregistrée.

Au prochain lancement d'it-edit, ces éléments peuvent être rechargés.

Il existe 3 modes pour la gestion des sessions :

  • automatique ;
  • demande à l'utilisateur si le programme doit enregistrer la session à la fermeture du programme ;
  • pas de gestion de session.
Autres nouveautés

Il émet maintenant des avertissements (optionnels) lorsque l'utilisateur :

  • essaye d'ouvrir un fichier déjà présent dans l'éditeur ;
  • ferme un fichier non-sauvegardé ;
  • ouvre un fichier protégé en écriture.

Et toutes ces alertes sont configurables.

En vrac, d'autres nouveautés :

  • sauvegarde des permissions des fichiers  : pratique pour les scripts ;
  • ordonnancement lexical des onglets ;
  • une fenêtre liste le temps passé dans it-edit ;
  • affichage du chemin absolu du fichier en cours d'édition sous forme de bulles en plaçant la souris au-dessus de l'onglet ou sur le nom du fichier en bas ;
  • il fournit un moyen de copier le chemin absolu du fichier ou de son dossier dans le presse-papier grâce à un raccourci clavier ou une entrée de menu ;
  • remplacement de toutes les occurrences dans tous les fichiers ouverts ;
  • la fenêtre d'informations du fichier a fait l'objet de quelques ajouts de fonctionnalités  :
    • copie ou déplacement du fichier vers une autre destination ;
    • compression du fichier, utile pour les pages de manuel.
L'éditeur it-edit à l'usage Pour le cas des petites définitions d'écran
  • configurez la taille des terminaux de la barre latérale ;
  • configurez la taille de la police du terminal ;
  • configurez la taille de la police de l'éditeur.
Pour les testeurs volontaires

Vous êtes invités à tester ou à mettre à jour vers cette nouvelle version d'it-edit. Prenez le temps de vous familiariser avec cet éditeur pour vous en faire une idée. Par exemple, pendant une petite semaine, pour vraiment travailler avec. Et faites nous part ici de vos impressions en commentaire.

Télécharger ce contenu au format Epub

Lire les commentaires

G’MIC 2.0 : un second souffle pour le traitement d’images libre

2 juin, 2017 - 10:38

L’équipe IMAGE du laboratoire GREYC de Caen (UMR CNRS 6072) est heureuse de vous annoncer la sortie d’une nouvelle version majeure (numérotée 2.0) de son projet G’MIC, un cadriciel libre, générique et extensible pour le traitement des images.
Nous exposons ici les avancées principales réalisées sur cet ensemble d’interfaces logicielles, depuis notre dernière dépêche. Les nouveautés présentées ici englobent le travail réalisé ces douze derniers mois (versions 2.0.0 et 1.7.x, pour x variant de 2 à 9).

Sommaire

N. D. A. : Cliquez sur les images de la dépêche pour en visualiser des versions à meilleure résolution.

1. Contexte et vue d’ensemble

G’MIC est un projet libre ayant vu le jour en août 2008, dans l’équipe IMAGE du GREYC.
Cette équipe française, composée de chercheurs et d’enseignants‐chercheurs, est spécialisée dans les domaines de l’algorithmique et des mathématiques du traitement d’images. G’MIC est distribué sous licence CeCILL (compatible GPL) pour différentes plates‐formes (GNU/Linux, macOS et Windows). Il fournit un ensemble d’interfaces utilisateur variées pour la manipulation de données images génériques, à savoir des images ou des séquences d’images hyperspectrales 2D ou 3D à valeurs flottantes (ce qui inclut de fait les images couleurs « classiques »).
  Fig. 1.1 : Logo du projet G’MIC, cadriciel libre pour le traitement d’image, et sa mascotte Gmicky.

La popularité de G’MIC vient en majeure partie du greffon qu’il propose pour le logiciel GIMP, depuis 2009. À ce jour, celui‐ci dispose de plus de 480 filtres et effets différents à appliquer sur vos images, et permet donc d’enrichir considérablement les filtres de traitement livrés par défaut avec GIMP.

G’MIC fournit également une interface en ligne de commande, relativement puissante, qui peut s’utiliser de manière autonome, et qui est complémentaire aux outils en ligne de commande proposés par ImageMagick ou GraphicsMagick. Il existe aussi un service Web G’MIC Online, permettant d’appliquer des effets sur vos images directement à partir d’un navigateur. D’autres interfaces plus confidentielles basées sur G’MIC existent : l’interface de diffusion vidéo ZArt, un greffon pour Krita, un sous‐ensemble de filtres pour Photoflow, Blender ou encore Natron… Toutes ces interfaces se basent sur les bibliothèques C++ CImg et libgmic qui sont portables, compatibles multi‐fil d’exécution (thread‐safe et multi‐thread), via l’utilisation d’OpenMP.

À l’heure actuelle, G’MIC possède plus de 950 fonctions différentes de traitement, toutes paramétrables, pour une bibliothèque de seulement 6,5 Mio, représentant un peu plus de 180 000 lignes de code source. Les fonctionnalités proposées couvrent un large spectre du traitement d’images, en proposant des algorithmes pour la manipulation géométrique, les changements colorimétriques, le filtrage d’image (débruitage, rehaussement de détails par méthodes spectrales, variationnelles, non locales…), l’estimation de mouvement et le recalage, l’affichage de primitives (2D et objets 3D maillés), la détection de contours et la segmentation, le rendu artistique, etc. C’est donc un outil très générique aux usages variés et très utile, d’une part pour convertir, visualiser et explorer des données images, et d’autre part, pour construire des pipelines élaborés et des algorithmes personnalisés de traitements d’images (voir les diapositives de présentation du projet pour davantage de détails).

2. Une nouvelle interface polyvalente, basée sur Qt

La nouveauté essentielle de cette version 2.0 concerne le code du greffon, qui a été complètement repensé et réimplémenté à partir de zéro. Ce module, G’MIC-Qt, développé par Sébastien (enseignant‐chercheur — expérimenté — de l’équipe), propose ainsi une refonte complète en Qt de l’interface du greffon, en étant le plus indépendant possible de l’interface logicielle et des widgets de GIMP.
  Fig. 2.1 : Aperçu de la version 2.0 du greffon G’MIC-Qt pour GIMP.

Cela a plusieurs conséquences intéressantes :

  • Le greffon utilise ses propres widgets (en Qt) et permet d’avoir une interface plus flexible et personnalisable qu’avec les widgets GTK proposés par défaut pour les greffons dans l’API de GIMP : la fenêtre de prévisualisation des filtres est par exemple redimensionnable à volonté, gère le zoom à la molette de la souris, et peut être localisée à gauche ou à droite de l’interface. Un moteur de recherche de filtres par mots‐clés a été ajouté, ainsi que la possibilité de choisir entre un thème clair ou sombre. La gestion des filtres favoris a été améliorée et l’interface propose même un mode d’édition de visibilité des filtres pour une personnalisation maximale.
  • Le greffon définit aussi sa propre API, pour faciliter son intégration dans des logiciels tiers autres que GIMP. Pour le développeur, il s’agit en pratique d’écrire un unique fichier host_software.cpp implémentant les fonctions de l’API pour faire le lien entre le greffon et l’application hôte. Actuellement, le fichier host_gimp.cpp réalise ce travail pour le logiciel hôte GIMP. Mais il existe désormais aussi une version stand‐alone (fichier host_none.cpp) qui propose de lancer l’interface graphique Qt du greffon en mode solo, depuis la ligne de commande (commande gmic_qt).
  • Boudewijn Rempt, gestionnaire et développeur du projet Krita a également débuté l’écriture du fichier host_krita.cpp pour la communication de ce greffon « nouvelle génération » avec le logiciel de peinture numérique Krita. Il s’agit à terme de remplacer le greffon G’MIC actuellement distribué avec Krita, qui se fait vieillissant et qui pose des problèmes de maintenance pour les développeurs.

Minimiser l’effort d’intégration pour les développeurs, partager au maximum le code du greffon G’MIC_ entre différentes applications, et proposer une interface d’utilisation la plus confortable possible ont été les objectifs principaux de cette refonte complète. Comme vous vous en doutez, cette réécriture a demandé un travail long et soutenu, et nous ne pouvons qu’espérer que cela suscitera de l’intérêt chez d’autres développeurs de logiciels, où disposer d’une base conséquente de filtres de traitement d’images peut être utile (à quand un host_blender.cpp ? On peut rêver !). L’animation ci‐dessous illustre quelques‐unes des fonctionnalités offertes par cette nouvelle interface basée sur Qt.
  Fig. 2.2 : La nouvelle interface G’MIC-Qt en action.

À noter que le code de l’ancien greffon utilisant GTK a quand même été mis à jour pour fonctionner avec la version 2.0 de G’MIC, mais possède moins de fonctionnalités et n’évoluera sans doute plus dans le futur, contrairement à la version Qt.

3. Faciliter la vie des dessinateurs…

Mais une des raisons d’être de G’MIC, c’est aussi de proposer toujours plus de filtres et de fonctions pour traiter les images. Et ça tombe bien, car dans ce domaine, nous n’avons pas non plus relâché nos efforts, malgré le nombre de filtres conséquent déjà disponible dans les versions précédentes !

Une des grandes nouveautés de cette version concerne l’apparition et l’amélioration de filtres pour l’aide à la colorisation de dessins au trait (line‐arts). Nous avons en effet eu la chance de recevoir au laboratoire pendant quelques jours l’artiste David Revoy, bien connu des amateurs d’art et de logiciels libres de par ses contributions multiples dans ces domaines (en particulier, son webcomic Pepper & Carrot, à lire absolument !). En collaboration avec David, nous avons travaillé sur la conception d’un filtre original de colorisation automatique de dessins au trait, nommé Smart Coloring.
  Fig. 3.1 : Utilisation du filtre « Colorize lineart [smart coloring] » de G’MIC.

Dans le domaine de la bande dessinée, la colorisation d’un dessin au trait se réalise en effet en deux étapes successives : Le dessin d’origine en niveaux de gris (fig. 3.2.[1]) est d’abord pré‐colorisé en aplats, c.‐à‐d. en attribuant une couleur unique à chaque région ou objet distinct du dessin (fig. 3.2.[3]). Dans un second temps, le coloriste retravaille ce pré‐coloriage, ajoutant ombres, lumières et modifiant l’ambiance colorimétrique, pour obtenir le résultat de colorisation final (fig. 3.2.[4]). Pratiquement, la colorisation en aplats aboutit à la création d’un nouveau calque qui ne contient que des zones de couleurs constantes par morceaux, formant ainsi une partition colorisée du plan. Ce calque est fusionné avec le line‐art d’origine pour obtenir le rendu colorisé du dessin en aplats (fusion des calques en mode multiplication, typiquement).
  Fig. 3.2 : Étapes d’un processus de colorisation d’un dessin au trait (source : David Revoy).

Les artistes l’avouent eux‐mêmes : la colorisation en aplats est un processus long et fastidieux, nécessitant patience et précision. Les outils « classiques » présents dans les logiciels de peinture numérique ou de retouche d’images ne rendent en effet pas cette tâche aisée. Par exemple, les outils de remplissage par croissance de région (bucket fill), même les plus évolués, gèrent mal les discontinuités dans les traits de dessin (fig. 3.3.a), et encore plus mal les traits lissés (anti‐crénelés). Il est alors courant que l’artiste effectue ses aplats en peignant manuellement ses couleurs avec une brosse sur un calque séparé (fig. 3.3.b), avec tous les problèmes de précision (notamment aux abords des traits) que cela suppose (fig. 3.3.c, et ce lien pour plus de détails).
  Fig. 3.3 : Problèmes classiques rencontrés lors de la colorisation en aplats (source : David Revoy).

Il peut même arriver que l’artiste décide de contraindre explicitement son style de dessin, en utilisant par exemple des lignes crénelées en résolution supérieure (plutôt que des lignes anti‐crénelées), et/ou en se forçant à ne tracer que des traits sans « trous », pour faciliter le travail de colorisation du préparateur d’aplats.

Le filtre Smart Coloring que nous avons développé dans la version 2.0 de G’MIC permet de pré‐coloriser un dessin au trait donné en entrée, d’une part à partir d’une analyse de la géométrie locale des traits de crayon (normales et courbures) et, d’autre part, par leur complétion automatique par des courbes splines. Cela autorise une fermeture (virtuelle) et un remplissage d’objets pouvant contenir des discontinuités dans les tracés de leurs contours. Ce filtre a de plus l’avantage d’être rapide en temps de calcul et donne des résultats de colorisation de qualité similaire à des techniques d’optimisation plus coûteuses, utilisées dans certains logiciels propriétaires. L’algorithme que nous avons élaboré gère sans problème les traits anti‐crénelés, et propose deux modes de colorisation en aplats : par couleurs aléatoires (fig. 3.2.[2] et fig. 3.4) ou guidée par des marqueurs de couleur placés au préalable par l’utilisateur (fig. 3.5).
  Fig. 3.4 : Utilisation du filtre « Smart Coloring » en mode couleurs aléatoires, pour la colorisation d’un dessin au trait (source : David Revoy).

En mode couleurs aléatoires, le filtre génère un calque d’aplats qu’il est très facile de recoloriser par la suite avec de « bonnes » couleurs. Ce calque contient en effet uniquement des régions de couleurs constantes, et l’outil de remplissage classique (bucket fill) est ici efficace pour réassigner rapidement une couleur cohérente à chaque région existante colorisée aléatoirement par l’algorithme.
En mode marqueurs de couleurs, les couleurs placées par l’utilisateur sont extrapolées de façon à respecter au mieux la géométrie du dessin, notamment avec la prise en compte des discontinuités dans les traits de crayon, comme on peut le voir très clairement sur l’exemple ci‐dessous :
  Fig. 3.5 : Utilisation du filtre « Smart Coloring » en mode guidage par marqueurs de couleurs, pour la colorisation d’un dessin au trait (source : David Revoy).

Cet algorithme innovant de colorisation en aplats a fait l'objet d’une pré‐publication sur HAL : Un algorithme semi‐guidé performant de colorisation en aplats pour le dessin au trait. Les plus curieux y trouveront tous les détails techniques de la méthode utilisée.
Les discussions récurrentes que nous avons eues avec David Revoy sur l’élaboration de ce filtre nous ont permis d’améliorer l’algorithme petit à petit, jusqu’à ce qu’il devienne réellement utilisable en production. Cette méthode a pu être ainsi utilisée avec succès, et donc validée, pour la pré‐colorisation de tout l’épisode 22 du webcomic Pepper & Carrot.

Les plus avisés pourraient nous dire que G’MIC possédait déjà un filtre de colorisation de dessins ! C’est vrai, mais celui‐ci ne gérait malheureusement pas très bien les dessins avec des traits discontinus (tels que celui présenté en fig. 3.5), et pouvait alors nécessiter de la part de l’utilisateur le placement d’un grand nombre de marqueurs couleur pour guider correctement l’algorithme. La performance de ce nouvel algorithme est en pratique bien supérieure.

Et puisque ce nouveau filtre d’aide à la colorisation ne voit pas d’objection aux traits anti‐crénelés, pourquoi s’en priver ? Justement, un autre filtre Repair / Smooth [antialias] a également fait son apparition pour ajouter de l’anti‐crénelage à des traits de dessin qui seraient à l’origine trop crénelés.
  Fig. 3.6 : Le filtre « Smooth [antialias] » peut supprimer le crénelage éventuel de traits de dessins (source : David Revoy).

4. …Sans oublier les photographes !

« Coloriser des dessins, c’est bien gentil, mais mes photos à moi sont déjà en couleurs ! », nous fait gentiment remarquer le photographe impatient. Pas de souci ! De nombreux filtres relatifs à la transformation et l’amélioration de photos ont également fait leur apparition dans G’MIC 2.0. Faisons un petit tour du propriétaire.

4.1. CLUT et transformations colorimétriques

Les CLUT (Color Lookup Tables) sont des fonctions de transformations colorimétriques définies dans le cube RVB (rouge, vert et bleu) : pour chaque couleur source d’une image Imgs définie par un triplet (Rs, Vs, Bs), une CLUT lui associe une nouvelle couleur (Rd, Vd, Bd) que l’on reporte dans une image destination Imgd aux mêmes positions. Ces fonctions de transformation pouvant être vraiment quelconques, on peut obtenir des effets très différents suivant les CLUT utilisées, et les photographes en sont donc généralement friands (d’autant que ces CLUT sont un bon moyen de simuler le rendu couleur de certains vieux films argentiques).

En pratique, on stocke une CLUT comme une image volumique couleur (éventuellement « déroulée » suivant l’axe z = B pour en obtenir une version 2D), ce qui peut vite devenir encombrant lorsque l’on doit gérer plusieurs centaines de CLUT. Heureusement, G’MIC possède un algorithme de compression spécifique de CLUT assez efficace (déjà mentionné dans une précédente dépêche LinuxFr.org), qui a été amélioré au fil des versions. Et c’est donc en toute décontraction que nous avons pu ajouter plus de 60 nouvelles transformations colorimétriques basées CLUT dans G’MIC, pour un total de 359 CLUT utilisables, toutes stockées dans un fichier de données qui pèse à peine 1,2 Mio ! Remercions en passant Marc Roovers et Stuart Sowerby pour leurs contributions à ces nouvelles transformations.
  Fig. 4.1.1 : Quelques‐unes des nouvelles transformations colorimétriques disponibles dans G’MIC (source : Pat David).

Mais que faire si nous disposons déjà de nos propres fichiers CLUT et que nous voulons les utiliser dans GIMP ? Aucun problème ! Le filtre tout frais Film emulation / User‐defined vous permet d’appliquer de telles transformations, avec même une prise en charge des fichiers à extension .cube (format de fichiers CLUT proposé par Adobe et encodé en ASCII o_O !).

Et les plus exigeants, qui ne trouveraient pas leur bonheur dans les CLUT déjà présentes, peuvent dorénavant construire leur propre CLUT personnalisée, grâce au filtre Colors / Customize CLUT disponible dans le greffon. Ce filtre, très polyvalent, permet de placer des points clefs colorés dans le cube RVB, points qui seront interpolés en 3D par la suite (suivant une triangulation de Delaunay), pour reconstruire une CLUT complète, c.‐à‐d. une fonction dense dans RGB. Toutes les fantaisies sont alors permises, comme dans l’exemple ci‐dessous, où le filtre est utilisé pour changer l’ambiance colorimétrique d’un paysage, en modifiant principalement la couleur du ciel. La CLUT ainsi synthétisée peut être, bien sûr, sauvegardée sous forme de fichier et réutilisée plus tard pour d’autres photographies, ou même dans d’autres logiciels prenant en charge ce type de transformations colorimétriques (RawTherapee ou Darktable, par exemple).
  Fig. 4.1.2 : Création d’une transformation colorimétrique personnalisée avec le filtre « Customize CLUT ».

  Fig. 4.1.3 : Résultat de la transformation colorimétrique personnalisée appliquée sur un paysage.

Toujours pour rester dans des modifications relatives aux couleurs, notons aussi l’apparition du filtre Colors / Retro fade qui créé un rendu « rétro » d’une image avec du grain généré par moyennages successifs de quantifications aléatoires d’une image d’entrée.
  Fig. 4.1.4 : Le filtre « Retro fade » du greffon G’MIC.

4.2. Faire ressortir les détails

De nombreux photographes cherchent des moyens de traiter leurs photographies numériques de façon à faire ressortir les moindres détails de leurs images, parfois même jusqu’à l’exagération. On en croise notamment sur Pixls.us, site récent spécialisé dans les techniques de photographie utilisant uniquement des projets libres. Et c’est en collaboration avec ceux‐ci, que plusieurs nouveaux filtres de rehaussement de détails et de contraste ont été ajoutés dans G’MIC. On peut citer notamment les filtres Artistic / Illustration look et Artistic / Highlight bloom, ré‐implémentations directes des tutoriels et des scripts rédigés par Sébastien Guyader, ainsi que le filtre Light & Shadows / Pop shadows suggéré par Morgan Hardwood. Être immergé dans une telle communauté de photographes donne sans cesse des opportunités de création de nouveaux effets !
  Fig. 4.2.1 : Filtres « Illustration look » et « Highlight bloom » appliquées sur une image de portrait.

Dans la même veine, G’MIC se dote de sa propre implémentation de l’algorithme de Retinex multi‐échelle, dont une version était déjà présente dans GIMP, mais qui se trouve ici enrichie avec des possibilités de contrôle supplémentaires, pour améliorer la cohérence de la luminosité dans les images.
  Fig. 4.2.2 : Filtre « Retinex » pour uniformiser la luminosité dans une image.

Notre ami et grand contributeur de G’MIC, Jérome Boulanger, a également implémenté et ajouté un algorithme d’atténuation de l’effet de brouillard dans les images (Dehazing), basé sur la méthode du Dark Channel Prior. Le réglage des paramètres de ce filtre n’est pas toujours aisé, mais il donne parfois des résultats très intéressants.

  Fig. 4.2.3 : Filtre « DCP Dehaze » pour l’atténuation de l’effet de brouillard dans une image.

Pour terminer cette sous‐section, notons également l’implémentation dans G’MIC de l’algorithme de Rolling Guidance, qui permet de simplifier des images et qui est devenu une brique de base utilisée dans de nombreux filtres récemment ajoutés. C’est le cas notamment pour cette méthode épatante de rehaussement de contours (Sharpening), que vous pourrez trouver dans Details / Sharpen [texture], et qui se réalise en deux étapes successives. D’abord l’image est séparée en une composante texture + une composante couleur, puis on rehausse les détails de la composante texture uniquement, avant de recomposer l’image. Cette façon de procéder permet de bien faire ressortir tous les petits détails de l’image, tout en minimisant la création de halos disgracieux près des contours, problème récurent rencontré avec la plupart des méthodes de rehaussement de détails plus classiques (tel que le bien connu Unsharp Mask).
  Fig. 4.2.4 : Le filtre « Sharpen [texture] » illustré pour deux amplitudes différentes de rehaussement de détails.

4.3. Masquage par sélection de couleurs

Il existe une multitude de techniques de retouche numérique de photographies se basant sur la création au préalable d’un ou plusieurs « masques », c.‐à‐d. des zones spécifiques de l’image qui vont recevoir des traitements différenciés. Par exemple, la technique très courante des masques de luminosité permet de traiter différemment les zones d’ombre et de lumière dans une photographie. G’MIC 2.0 se dote d’un nouveau filtre Colors / Color mask [interactive], implémentant un algorithme relativement rusé (quoique coûteux en temps de calcul) d’aide à la création de masques. Ce filtre demande à l’utilisateur de passer sa souris au‐dessus de quelques points représentatifs des régions qu’il souhaite isoler. L’algorithme apprend en temps réel les couleurs ou les luminosités correspondantes et en déduit l’ensemble des pixels qu’il doit conserver dans l’image entière (par analyse en composante principale sur les échantillons RVB), pour la construction rapide d’un masque global.

Une fois le masque généré par ce filtre, l’utilisateur peut modifier les pixels correspondants avec tout type de traitement. L’exemple ci‐dessous illustre l’utilisation de ce filtre pour modifier radicalement la couleur d’une voiture (l’opération se réalise en moins d’une minute trente ! Voir la vidéo correspondante). Une autre vidéo expose une technique identique pour modifier la couleur du ciel dans un paysage.
  Fig. 4.3.1 : Modification de la couleur d’une voiture à l’aide du filtre « Color mask [interactive] ».

5. Et pour les autres…

Les dessinateurs et les photographes étant maintenant rassurés, passons à d’autres types de traitements, récemment ajoutés à G’MIC, à usage plus exotique, mais qui restent néanmoins intéressants !

5.1. Moyenne et médiane d’une série d’images

Vous êtes vous déjà demandé comment calculer facilement l’image moyenne ou médiane d’une série d’images d’entrée ? Le photographe Pat David, aficionado du Libre (il est le créateur du site Pixls.us), s’est, quant à lui, souvent posé la question. Tout d’abord pour tenter de débruiter ses images, en combinant plusieurs clichés d’une même scène. Puis, pour simuler un temps d’exposition plus long par moyennage de photographies prises à des instants successifs. Et enfin, en calculant des moyennes d’images diverses et variées à des fins artistiques (par exemple, des trames de clips vidéo musicaux, l’ensemble des couvertures de Playboy, ou encore des portraits de célébrités).

C’est donc avec sa bénédiction que nous avons ajouté les commandes -median_files, -median_videos, -average_files et -average_videos pour réaliser toutes ces choses très simplement, à partir de l’interface en ligne de commande gmic de G’MIC. L’exemple ci‐dessous illustre le résultat de ces commandes appliquées sur une portion de la vidéo de Big Buck Bunny. Nous avons tout simplement invoqué les commandes suivantes depuis Bash :

$ gmic -average_video bigbuckbunny.mp4 -normalize 0,255 -o average.jpg $ gmic -median_video bigbuckbunny.mp4 -normalize 0,255 -o median.jpg

  Fig. 5.1.1 : Portion de la vidéo de Big Buck Bunny, réalisée par la fondation Blender.

  Fig. 5.1.2 : Résultat : Image moyenne de la séquence de Big Buck Bunny ci‐dessus.

  Fig. 5.1.3 : Résultat : Image médiane de la séquence de Big Buck Bunny ci‐dessus.

En restant dans le domaine du traitement vidéo, remarquons également l’apparition des commandes -morph_files et -morph_video permettant de calculer des interpolations temporelles de séquences vidéo prenant en compte le mouvement des objets dans les séquences, grâce à un algorithme variationnel et multi‐échelle ’estimation de mouvement intra‐trames. La vidéo visible sur YouTube illustre la différence de rendu pour le recalage d’une séquence, entre une interpolation temporelle utilisant ou non l’estimation du mouvement.

5.2. Déformations et « Glitch Art »

Ceux qui aiment maltraiter leurs images encore plus agressivement seront ravis d’apprendre qu’un tas de nouveaux effets de déformations et de dégradations d’image sont apparus dans G’MIC.

Tout d’abord, le filtre Deformations / Conformal maps, qui permet de déformer vos images par des transformations conformes. Ces déformations ont la propriété de préserver localement les angles, et sont le plus souvent exprimées par des fonctions utilisant des nombres complexes. En plus de jouer avec des déformations prédéfinies, ce filtre permet aux matheux en herbe d’expérimenter en spécifiant leurs propres formules complexes, si besoin est.
  Fig. 5.2.1 : Filtre « Conformal maps » appliquant une transformation conforme à l’image de la Joconde.

Les amateurs de Glitch Art pourront être également concernés par plusieurs nouveaux traitements dont le rendu fait furieusement penser à des artefacts ou des bogues d’encodage ou de compression d’images. Tout d’abord, l’effet Degradations / Pixel sort qui se permet de trier les pixels d’une image par ligne ou par colonne suivant différents critères et sur des régions éventuellement masquées, tel que cela a été proposé et décrit sur cette page.
  Fig. 5.2.2 : Filtre « Pixel sort » pour un rendu de type « Glitch Art » du plus bel effet !

Mais aussi avec ses deux petits frères, les filtres Degradations / Flip & rotate blocs et Degradations / Warp by intensity. Le premier permet de diviser une image en blocs et de tourner ou inverser ces blocs (façon « mirroir ») en ne le faisant potentiellement que pour certaines caractéristiques couleur de l’image (teinte ou saturation par exemple).
  Fig. 5.2.3 : Filtre « Flip & rotate blocs » appliqué uniquement sur la teinte afin d’obtenir des artefacts de couleurs façon « Glitch Art ».

Le deuxième s’amuse à déformer localement une image plus ou moins fortement en fonction des informations données par sa géométrie locale et, là aussi, permet de générer des images étranges, mais pouvant être appréciées des amateurs de Glitch Art.
  Fig .5.2.4 : Filtre « Warp by intensity » appliqué sur l’image de la Joconde (pauvre Joconde !).

Il faut préciser que ces filtres‐là ont été très largement inspirés par le greffon Polyglitch disponible pour Paint.NET, et réalisés après une suggestion d’un sympathique utilisateur (oui, oui, on essaye d’écouter nos utilisateurs les plus sympathiques !).

5.3. Simplification d’image

Qu’avons‐nous d’autre en réserve ? Ah oui ! Un nouveau filtre d’abstraction d’image, baptisé Artistic / Sharp abstract et basé sur l’algorithme du Rolling Guidance déjà évoqué précédemment. Ce filtre applique un lissage à préservation de contours sur une image, et a pour effet principal de supprimer sa texture. La figure ci‐dessous illustre son utilisation pour générer plusieurs niveaux d’abstraction d’une même image, à différentes échelles de lissage.
  Fig. 5.3.1 : Abstraction d’images via le filtre « Sharp abstract ».

Dans le même genre, G’MIC_ voit également débarquer Artistic / Posterize, un effet de postérisation d’image. Contrairement au filtre de postérisation livré par défaut dans GIMP, qui essaye principalement de réduire le nombre de couleurs (et qui s’apparente donc plus à un processus de quantification, notre version ajoute des traitements de simplification des informations spatiales de l’image pour s’approcher un peu plus d’un rendu de type « vieux poster ».
  Fig. 5.3.2 : Filtre « Posterize » de G’MIC et comparaison avec le filtre du même nom disponible par défaut dans GIMP.

5.4. Et en vrac…

Si vous n’êtes toujours pas rassasiés (et dans ce cas, on peut dire que vous êtes sacrément gourmands !), nous finissons cette section en extirpant en vrac de nos cartons quelques autres effets nouvellement implémentés.

À commencer par ce filtre Artistic / Diffusion tensors, qui affiche un champ de tenseurs de diffusion, calculés à partir des tenseurs de structure d’une image (les tenseurs de structure étant des matrices symétriques et définies positives, classiquement utilisés pour l’estimation de la géométrie locale des structures). Pour être tout à fait honnête, cette fonctionnalité n’avait pas été développée originellement dans un but artistique, mais des utilisateurs du greffon sont tombés dessus un peu par hasard et nous ont demandé d’en faire un filtre pour GIMP, dont acte. Et ma foi, c’est vrai que c’est plutôt joli, non ?
  Fig. 5.4.1 : Le filtre « Diffusion tensors » et sa multitude d’ellipses multicolores.

D’un point de vue technique, ce filtre a été en réalité l’occasion d’introduire de nouvelles fonctionnalités de dessin de primitives à l’intérieur de l’évaluateur d’expressions mathématiques de G’MIC, et il est devenu maintenant assez facile de développer ses commandes de visualisation personnalisées pour des données image diverses et variées. C’est ce qui a été fait par exemple avec la commande -display_quiver, réimplémentée de zéro, et qui permet de générer ce type de rendu :
Fig. 5.4.2 : Rendu de champs de vecteurs par la commande -display_quiver.

Pour les amateurs de textures, nous pouvons mentionner l’arrivée de deux nouveaux effets amusants : D’abord, le filtre Patterns / Camouflage qui, comme son nom le suggère, produit une texture de type « camouflage » militaire.
  Fig. 5.4.3 : Le filtre « Camouflage », à imprimer sur vos T‐shirts pour passer inaperçu en soirée !

Et dans le même genre, le filtre Patterns / Crystal background superpose plusieurs polygones colorés aléatoires pour synthétiser une texture faisant vaguement penser à du cristal vu à la loupe. Plutôt sympa quand on veut obtenir rapidement des fonds d’images pas trop ternes.
  Fig. 5.4.4 : Le filtre « Crystal background » en action.

Et nous finirons ce tour d’horizon des nouveaux traitements apparus depuis l’an dernier avec l’effet Rendering / Barnsley fern, qui trace un rendu de la fractale Barnsley fern. Pour les curieux, notons que l’algorithme de génération de cette figure fractale notoire est disponible sur Rosetta Code, avec même une version du code écrite en langage de script G’MIC, à savoir :

# Put this into a new file 'fern.gmic' and invoke it from the command line, like this: # $ gmic fern.gmic -barnsley_fern barnsley_fern : 1024,2048 -skip {" f1 = [ 0,0,0,0.16 ]; g1 = [ 0,0 ]; f2 = [ 0.2,-0.26,0.23,0.22 ]; g2 = [ 0,1.6 ]; f3 = [ -0.15,0.28,0.26,0.24 ]; g3 = [ 0,0.44 ]; f4 = [ 0.85,0.04,-0.04,0.85 ]; g4 = [ 0,1.6 ]; xy = [ 0,0 ]; for (n = 0, n<2e6, ++n, r = u(100); xy = r<=1?((f1**xy)+=g1): r<=8?((f2**xy)+=g2): r<=15?((f3**xy)+=g3): ((f4**xy)+=g4); uv = xy*200 + [ 480,0 ]; uv[1] = h - uv[1]; I(uv) = 0.7*I(uv) + 0.3*255; )"} -r 40%,40%,1,1,2

Et voici le rendu que cette fonction génère :
  Fig. 5.4.5 : Rendu de la fractale « Barnsley fern » calculé par G’MIC.

6. Autres informations générales

Bien évidemment, les filtres qui ont été présentés tout au long de cette dépêche ne constituent que la partie émergée de l’iceberg G’MIC. Ils sont en réalité le résultat de nombreux développements et améliorations effectués « sous le capot », c.‐à‐d. directement sur le code de l’interpréteur du langage de script que G’MIC définit, et qui sert in fine de base à l’écriture de tous les filtres et commandes disponibles pour les utilisateurs. Durant cette année écoulée, un gros travail a donc été réalisé pour améliorer les performances et les possibilités de cet interpréteur :

  • l’évaluateur d’expressions mathématiques a été considérablement enrichi et optimisé, avec toujours plus de fonctions disponibles (particulièrement pour le calcul matriciel), la gestion des chaînes de caractères, l’introduction de variables const pour une plus grande rapidité d’évaluation, la possibilité d’écrire des macros variadiques, ou encore d’allouer des vecteurs de manière dynamique, etc. ;
  • de nouvelles optimisations ont également été introduites dans la bibliothèque CImg, avec notamment la parallélisation de nouvelles fonctions (via l’utilisation d’OpenMP). Cette bibliothèque C++ fournit les implémentations des traitements d’images « critiques » et son optimisation a donc des répercussions directes sur les performances de G’MIC (à ce propos, notons que CImg passe également en version majeure 2.0) ;
  • la compilation de G’MIC sous Windows utilise maintenant une version de g++ récente (la 6.2 plutôt que la 4.5), ce qui se traduit par un impact énorme sur les performances des exécutables compilés ; certains filtres s’exécutent jusqu’à 60 fois plus rapidement qu’avec les binaires générés précédemment (c’est le cas, par exemple, pour le filtre Deformations / Conformal Maps, évoqué en section 5.2) ;
  • la prise en compte des images .tiff de grande dimension (format BigTIFF, avec des fichiers dont la taille peut dépasser les 4 Gio) est maintenant opérationnelle en lecture et écriture, tout comme celle des images TIFF à valeurs flottantes sur 64 bits ;
  • le moteur de rendu d’objets 3D maillés intégré à G’MIC a également été amélioré, avec la prise en charge du bump mapping ; aucun filtre n’utilise actuellement cette fonctionnalité, mais sait‐on jamais, on se prépare pour la suite !

  Fig. 6.1 : Comparaison du rendu texturé avec (à droite) et sans « Bump mapping » (à gauche).

  • et comme il est toujours bon de se détendre après une dure journée de travail, nous avons ajouté le jeu du Puissance 4 à G’MIC ! Il est accessible via la commande shell gmic -x_connect4 ou en passant par le greffon, via le filtre Various / Games & demos / Connect-4. À noter qu’il est possible de jouer contre l’ordinateur, qui a un niveau décent mais pas imbattable non plus (l’IA, très simple, utilise l’algorithme Minimax avec un arbre de décisions à deux niveaux seulement). Fig. 6.2 : Le jeu du « Puissance 4 », jouable dans G’MIC.

Et pour en finir avec le rayon des nouveautés, mentionnons le travail en cours de refonte du service Web G’MIC Online, avec une version bêta en cours de développement. Ce re‐développement du site, réalisé par Christophe Couronne, chapeauté par Véronique Robert (tous deux également membres du laboratoire GREYC), a été étudié pour mieux s’adapter aux appareils mobiles, et les premiers tests sont plus qu’encourageants. N’hésitez pas à expérimenter et nous faire part de vos impressions !

7. La suite ?

Que retenir de cette looooooongue dépêche ?

D’abord que cette version 2.0 représente effectivement une étape importante dans la vie du projet G’MIC, et que les améliorations réalisées ces derniers mois sont de bon augure pour les développements futurs. Il semble que les utilisateurs soient de plus en plus nombreux (et apparemment satisfaits), et nous espérons que cela incitera d’autres développeurs à déployer notre nouvelle interface G’MIC-Qt comme greffon pour leurs propres logiciels libres. En particulier, on a bon espoir de voir tourner le nouveau G’MIC sous Krita prochainement, et ce serait déjà une étape formidable !

Ensuite, que ce projet libre continue d’être actif et d’évoluer au fil des rencontres et des discussions avec les membres des communautés d’artistes et de photographes, qui peuplent en particulier les forums et IRC de Pixls.us et de GimpChat. Vous avez de grandes chances de nous y retrouver si vous désirez de plus amples informations ou simplement discuter de choses relatives au traitement d’images (libre de préférence).

On tient, bien sûr, à remercier les contributeurs du projet, que l’on ne peut malheureusement pas tous citer ici, mais qui sont de plus en plus nombreux. Merci également à tous ceux qui payent leurs impôts en France sans ronchonner et qui font donc avancer indirectement le développement de ce projet libre, mis à disposition gracieusement — faut‐il le rappeler ? — par le GREYC, un laboratoire public de recherche en STIC — Sciences et technologies d’information et de communication — de Caen, et qui est développé par des fonctionnaires motivés et passionnés (et du coup quelquefois aussi fatigués ! :)).

Et en attendant une prochaine dépêche hypothétique sur une future version de G’MIC, vous pouvez toujours suivre l’avancement pas à pas du projet via notre fil Twitter.

D’ici là, vive le traitement d’images libre et la science reproductible !

Crédits images : Sauf mention contraire, les diverses images non synthétiques qui ont servi à illustrer cet article proviennent du site Pixabay.

Télécharger ce contenu au format Epub

Lire les commentaires

PyParis 2017 — fin des inscriptions dans 10 jours

1 juin, 2017 - 10:01

La conférence PyParis, qui fait suite à PyData Paris, aura lieu les 12 et 13 juin 2017 à La Défense. Plus de 300 personnes sont attendues. Si vous souhaitez participer, il est impératif de prendre vos billets avant le 9 juin. Le code promo LINUXFR4PY vous donnera 10 % de réduction.

Le programme est maintenant bouclé, avec trois cycles de présentations consacrés à l’analyse de données en Python :

  • Integrating and shaping data : gestion des données massives, intégration, analyses statistiques, exploration interactive, etc. ;
  • Learning, deep and wide : machine learning / deep learning ;
  • scikit-learn day : une journée entière consacrée à la bibliothèque scikit-learn dédiée au machine learning en Python, qui est développée en partie en France.

Et également :

  • quatre interventions plénières (keynotes) : les tendances du Web en Python, Jupyter, scikit-learn, Python dans l’éducation ;
  • Python Core : les dernières évolutions du langage Python et des outils qui vont bien autour ;
  • Web & Cloud : cadriciels et outils pour faire des applications Web en Python ;
  • Education : une journée de conférence sur l’utilisation de Python dans l’éducation (scolaire, universitaire ou hors système). Cette journée est gratuite pour les professionnels de l’enseignement et les membres des associations intervenant dans l’apprentissage du « code », sur présentation du code promo EPI4PY ;
  • 8 ateliers de 90 minutes ;
  • une session de lightning talks.
Télécharger ce contenu au format Epub

Lire les commentaires

Sortie du noyau Linux 4.11

31 mai, 2017 - 13:56

La sortie de la version stable 4.11 du noyau Linux a été annoncée le 1er mai 2017 par Linus Torvalds. Le nouveau noyau est, comme d’habitude, téléchargeable sur les serveurs du site kernel.org.

Sommaire Annonces des versions candidates par Linus Torvalds RC-1

La version RC-1 est sortie le 5 mars 2017 :

Deux semaines sont passées, la fenêtre de fusion s’est terminée et 4.11-rc1 a été étiquetée et publiée.

Cela ressemble à une version habituelle. Elle semble appartenir à une variété comportant peu de modifications, mais principalement comparée aux 4.9 et 4.10 — ce n’est pas à proprement parler singulièrement petit (dans les derniers noyaux, 4.1, 4.3, 4.5, 4.7 et maintenant 4.11, toutes avaient environ le même nombre de commits dans la fenêtre de fusion).

Il semble bien qu’il y avait plus de choses à intégrer que ce qui était dans linux-next. C’est toujours ce qu’il se passe, mais il semble que ce soit plus que d’ordinaire. Comparé à l’arborescence de linux-next au moment de la publication de la version 4.10, environ 18 % des commits hors fusion n’étaient pas dans linux-next. Cela semble plus élevé que d’habitude, bien que j’imagine que Stephen Rothwell doit avoir les vrais chiffres des fusions passées.

Maintenant, environ un quart des correctifs qui n’étaient pas dans linux-next finissent par avoir le même identifiant [ID patch] que quelque chose qui y était, donc une partie était due juste à du rebasing. Cependant, nous avons environ 13 % de la fenêtre de fusion qui n’était pas dans linux-next quand la 4.10 est sortie.

En en regardant les sources, il y a quelques classes différentes :

  • des corrections :
    C’est évidemment bien et inévitable. Je ne m’attends pas à ce que tout ait été dans linux-next, après tout.

  • les appels système de statx() :
    Ouais, je vais garder celui‐ci aussi parce que, franchement, la première version de ce correctif a été postée il y a plus de six ans.

  • il y a l’assez remarquable série de scissions dans <linux/sched.h> :
    Celui‐ci a été posté et discuté avant la fenêtre de fusion, et a dû être fusionné en retard (et a même alors causé quelques conflits). Il y avait donc de vraies raisons pour la tardive inclusion.

  • quelques sous‐systèmes ; DRM, InfiniBand, watchdog et Btrfs se démarquent :
    Ce dernier cas est ce que j’ai trouvé plutôt ennuyeux pour cette fenêtre de fusion.

En particulier, si vous ne pouvez pas suivre les simples règles de la fenêtre d’intégration (le processus entier de la fenêtre d’intégration et de linux-next est en place depuis plus d’une décennie), au moins faites en sorte que le résultat final ait bonne allure. Que tout ait l’air naturel et exempt de tout problème. Faites en sorte d’avoir l’air de savoir ce que vous faites, et assurez‐vous vraiment que le code a été exhaustivement testé d’une autre façon.

Parce que si vous contournez les contrôles sanitaires de linux-next, vous feriez mieux d’avoir vos propres contrôles sanitaires, avec lesquels vous les remplacerez. Ou alors, vous avez juste besoin d’être tellement bon que personne ne vous en voudra de les contourner, et personne ne remarquera jamais vos raccourcis.

Se dire « ignorons toutes les règles et les processus que nous avons mis en place pour vérifier les choses » et ensuite m’envoyer de la daube qui ne compile même pas, pour moi ce n’est pas acceptable.

Vous savez qui vous êtes. Pour la prochaine fenêtre de fusion je n’accepterai rien de tel, même à distance. Les choses qui n’ont pas été dans linux-next seront rejetées et, puisque vous êtes déjà sur ma liste noire, je vous crierai dessus une fois de plus.

Linus

RC-2

La version RC-2 est sortie le 12 mars 2017 :

Comme d’habitude, la semaine qui suit la RC-1 tend à être assez calme quand les gens cherchent toujours des bogues et reprennent leur souffle après la fenêtre d’intégration. Mais nous avons là un nombre assez sain de correctifs, et il y a des correctifs de nettoyage et de préparation pour la gestion des tables de pages à cinq niveaux que j’ai pris après la fenêtre d’intégration, juste pour faciliter cette phase d’intégration.

Il y a aussi une (petite) mise à jour tardive du pilote des nombres aléatoires.

Mais pour la plupart, il ne s’agit que de correctifs, la majeure partie concernant les architectures et les pilotes (PowerPC et i915, respectivement, se démarquent), mais avec un composant notable situé ailleurs (les correctifs mm principalement via Andrew, quelques mises à jour des systèmes de fichiers, mise à jour des tests des arbres radix, etc.).

Les détails sont ajoutés au journal abrégé. Allez‐y, testez. Je pense que nous sommes en bonne forme pour aborder cette étape du développement noyau. Ça ne devrait pas être particulièrement effrayant de se dire « je vais me lancer à l’aventure et tester un noyau RC-2 ». D’accord, on est toujours dans les premières RC, mais continuez quand même. Aidez‐nous à nous assurer qu’on fait les choses correctement.

Linus

RC-3

Une nouvelle semaine, une nouvelle RC :

Suivant notre schéma habituel après la fenêtre d’intégration, la RC-3 est plus grande que la RC-2, mais nous arrivons heureusement au point où les choses commencent à se réduire et à se calmer. Nous avons eu une faute de frappe de dernière minute dans la RC-2 qui a affecté ARM et PowerPC (le code préparatoire pour les tables de pages à cinq niveaux) et, heureusement, il n’y a plus de bogues honteux de ce genre dans la RC-3.

Dans l’ensemble, la RC-3 a l’air assez normale, avec deux tiers de mises à jour de pilotes (les dernières mises à jour du pilote SCSI qla2xxx arrivent en tête, mais les pilotes Ethernet pour Broadcom et Cavium ne sont pas très loin derrière ; et il y a des mises à jour pour les processeurs graphiques, md, cpufreq, les pilotes de la plate‐forme x86, etc.).

En dehors des pilotes, le reste est un mélange de mises à jour des architectures (PA-RISC, PowerPC, x86), des systèmes de fichiers (AFS, NFS et XFS) et du « divers » (principalement le tronc commun du noyau et des mises à jour réseau générales).

Journal abrégé ci‐joint pour ceux qui veulent avoir un aperçu des détails, mais nous, ce qu’on veut, ce sont des tests. S’il vous plaît.

Linus

RC-4

La RC-4 est sortie le 26 mars 2017 :

Alors, la semaine dernière, j’ai dit que j’espérais que la RC-3 était le moment où l’on commençait à réduire les RC en taille et, oui, la RC-4 est plus petite que la RC-3. D’un tout petit soupçon. Elle touche bien à quelques fichiers de plus, mais elle compte deux commits de moins et comprend globalement moins de lignes modifiées. Mais dans l’ensemble, les deux sont à peu près de taille identique.

Ce qui n’est pas si mal, en fait, si l’on considère que la RC-4 comporte à la fois une fusion du côté du réseau et des traditionnels pilotes de chez Greg, et quelques correctifs DRM — et ça, ce sont généralement de gros morceaux.

Donc, dans l’ensemble, ça a l’air bien. Il y a des changements un peu partout et, pour la plupart, dans les proportions habituelles. Du code du cœur du noyau apparaît dans diffstat un peu plus qu’à l’accoutumée. Nous avons un correctif des audits, un correctif de la hashmap BPF, mais globalement tout a l’air normal : principalement des pilotes, du réseau, des correctifs d’architectures et un peu de bruit sur les systèmes de fichiers. Le journal abrégé est joint, comme d’habitude, pour les gens qui veulent écumer les détails.

Allez‐y, testez.

Linus

RC-5

La version RC-5 est sortie le dimanche 2 avril 2017 :

OK, les choses commencent à se calmer pour de bon. Espérons que cela continue comme ça et que ce ne soit pas juste un coup de bol.

Les choses ont l’air assez normales, avec seulement moins de 60 % des changements situés dans les pilotes (EDAC, son, périphériques en mode bloc_, PCI, etc.) et environ 30 % dans les mises à jour des architectures (quelques correctifs divers dans ptrace et des choses dans le générateur de nombres aléatoires).

La seule chose quelque peu inhabituelle est la façon dont plus de la moitié des mises à jour des architectures concernent PA-RISC, mais il ne s’agit que d’une curiosité temporaire du correctif des routines de copie en espace utilisateur de PA-RISC, duquel en a résulté un correctif assez gros (dû au fait qu’elles étaient écrites en assembleur ordinaire plutôt qu’en un bazar bogué formé d’assembleur inline avec quelques lignes de C mélangées au milieu).

Le reste se compose de divers correctifs de systèmes de fichiers (NFS[d], Btrfs), ainsi que de quelques correctifs au cœur du noyau et dans la gestion de mémoire.

Journal abrégé ci‐joint pour ceux qui aiment écumer les détails. Il n’est pas gros, survolez‐le simplement de haut en bas.

Linus

RC-6

La version RC-6 est sortie le dimanche 9 avril 2017 :

Tout semble normal, donc voici la RC hebdomadaire habituelle.

Elle est un peu plus grosse que la RC-5, cela dit rien d’alarmant ni de particulièrement inquiétant. Touchons du bois. La seule chose légèrement inhabituelle est la répartition des correctifs, presque à parts égales entre les mises à jour des architectures, les pilotes, les systèmes de fichiers, le réseau et « divers ».

Mais les dernières RC sont suffisamment petites pour voir plus de variations de ce genre de statistiques qu’on en voit dans les publications plus grosses, donc cette « distribution pas tout à fait habituelle » correspond plutôt au bruit normal du développement dans son ensemble.

Allez‐y, récupérez‐la.

Linus

RC-7

La version RC-7 est sortie le dimanche 16 avril 2017 :

Vous connaissez le principe à présent. Nous sommes en fin de phase RC et il se peut que ce soit la dernière RC si rien de surprenant ne se produit.

Les choses ont été assez calmes la semaine passée (le début de la semaine a été particulièrement calme et, comme d’habitude, vendredi est arrivé…). Nous avons un certain nombre de retours en arrière concernant les choses qui ne marchaient pas ou qui ne valaient pas la peine d’être corrigées à ce stade. C’est normal aussi (les gens regarderont ça pour la prochaine version à la place).

Donc, ce n’est pas trop gros et les choses ont l’air tout à fait normales, avec deux tiers des changements portés aux pilotes, et le reste étant un mélange de mises à jour des architectures (ARM, x86, IA64 et PA-RISC), du réseau et des systèmes de fichiers (Btrfs, CIFS et OrangeFS). Avec une poignée d’autres choses (outils, fichiers d’en‐têtes et cœur du noyau).

Merci de tester.

Linus

RC-8

La version RC-8 est sortie lundi 24 avril 2017 :

Alors, au départ, j’avais simplement prévu de publier la version 4.11 finale aujourd’hui. Mais, alors que nous n’avons pas eu beaucoup de changements la semaine dernière, nous en avons connu deux très ennuyeux, donc je publie encore une version RC à la place. J’ai bien reçu des correctifs pour les problèmes qui sont apparus, j’aurais donc pu publier la 4.11 telle quelle, mais ça ne semble pas opportun.

Ce n’est pas comme si la laisser mûrir une semaine de plus allait faire du mal.

Le plus notable des problèmes est que nous avons dû marquer certaines fonctions de la gestion de l’énergie de NVM Express (NVMe) qui posaient apparemment problème sur certaines machines. On n’a pas encore totalement élucidé la cause de ces problèmes (qui n’était pas limitée à quelques implémentations matérielles de NVMe, mais également à des plates‐formes particulières), mais testons tout cela.

Et nous avons aussi plusieurs correctifs de kernel oops, même s’ils n’étaient là que dans des cas très spéciaux.

Donc, allez‐y, testez, les filles et les gars, et assurez‐vous que je puisse faire une publication finale le week‐end prochain. D’accord ?

Linus

Version finale

Alors après cette semaine de plus avec une version RC-8, les choses ont été assez calmes et je suis bien plus à l’aise pour publier une version 4.11 finale maintenant.

Nous avons toujours différents correctifs de plus petite taille la dernière semaine, mais rien qui me fasse faire « Hmm… ». Journal abrégé ci‐joint pour ceux qui veulent examiner les détails, mais c’est un mélange d’un peu tout, avec environ la moitié concernant les pilotes (le réseau domine, mais quelques petites corrections concernant le son, également), le reste étant constitué de mises à jour des architectures, de la gestion générique du réseau, et des correctifs des systèmes de fichiers (NFS[d]). Mais tout cela reste assez maigre, ce qui est ce que j’aime voir la dernière semaine d’un cycle de publication.

Et avec ça, la fenêtre d’intégration est bien sûr ouverte. J’ai déjà deux demandes d’intégration [pull requests] dans ma boîte de courriel, j’en attends beaucoup plus tout au long de la nuit.

Linus

Améliorations apportées à cette version Processeurs Intel
  • prise en charge des processeurs Intel de génération Kaby Lake (2017) par l’outil perf [lien] ;
  • meilleure prise en charge des systèmes monpuces Bay Trail et Cherry Trail, avec l’ajout de la gestion du flux audio pour le HDMI et des C-state.
Architectures x86

Nettoyage de code et optimisation.

Allwinner
  • le Allwinner V3s est maintenant pris en charge ;
  • le Allwinner A33 prend en charge cpufreq et des codecs audio ;
  • le Allwinner A64 prend en charge le MMC et de l’USB.
Samsung

Arrivée de la gestion de l’USB 3.0 pour l’Exynos 5433.

Qualcomm

Meilleure prise en charge des diverses fonctions du système monopuce Snapdragon 410 (MSM8916).

Protocoles Samba

Ajout de fonctionnalités au niveau de la sécurité dans le protocole SMB 3 [lien].

Matériel

Prise en charge du module Wi‐Fi/Bluetooth Marvell SD8787 Wi‐Fi/BT chip [lien].

syscall

Cette version du noyau propose un nouvel appel système statx(2). Ce dernier est une amélioration de la fonction POSIX stat(2). Pour rappel, la fonction int stat(const char *pathname, struct stat *buf) va nous permettre de connaître un certain nombre de métadonnées sur le fichier qui se trouve à la position indiquée par pathname. On retrouve dans la structure stat passée en paramètre, le numéro du nœud d’index (inode), la taille, le propriétaire et le groupe du fichier. En plus de la fonction stat(2), POSIX décrit la fonction fstat(2) qui prend en paramètre un descripteur de fichier à la place du nom du fichier et la fonction lstat(2) qui, lorsque le nom pointe un lien symbolique, ne suit pas le lien mais fournit les informations du lien lui‐même.

Le nouvel appel est de la forme long statx(int dfd, const char *filename, unsigned atflag, unsigned mask, struct statx *buffer). En plus des paramètres filename et du tampon buffer qui gardent les mêmes fonctions (même si le tampon utilise un nouveau type de structure), on trouve :

  • dfd : si l’on fournit un nom de fichier NULL, c’est le descripteur dfd qui est lu (équivalent à fstat(2)) ;
  • atflag : si l’on fournit un atflag équivalent à 0 et qu’on lui passe un lien symbolique, c’est bien le lien qui est analysé (équivalent à lstat(2)) ;
  • mask : permet de modifier le comportement de l’appel. Avec AT_NO_ATTR_SYNC, cela autorise le système de fichiers à faire des approximations. C’est particulièrement intéressant dans le cas des systèmes de fichiers réseau comme NFS ou CIFS. Le masque AT_FORCE_ATTR_SYNC permet l’exact inverse.

La nouvelle structure statx permet quant à elle d’obtenir plus d’informations, comme la date de création du fichier et les attributs de celui‐ci. Le système de fichiers peut indiquer quelles informations il prend en charge ou non et il est possible d’étendre la structure. Pour faire les choses proprement statx(2) est protégé du bogue de l’an 2038 et le tampon a la même structure quelle que soit l’architecture.

Réseau ICMP

Le protocole ICMP est connu pour être le protocole utilisé par la commande ping. Les réponses consomment maintenant moins de ressources et des réponses commencent à être supprimées pour, par exemple, éviter la saturation du réseau.

Divers

Diverses autres améliorations ont été faites comme l’optimisation des performances d’envoi pour l’interface réseau virtualisée vhost_net utilisée dans QEMU ou encore dans le filtre BPF (utilisé dans le pare‐feu).

Sécurité

Un début d’implémentation de SIPHASH a été réalisé pour sécuriser les numéros de séquence et les syncookies qui protègent contre les attaques par inondation de requêtes SYN.

Statistiques

Il y a eu pour cette version 4.11 du noyau, un total de 12 724 correctifs proposés par 157 entreprises, ce qui correspond à 816 319 lignes modifiées et pas loin de 300 000 nouvelles lignes.
Les trois plus grosses contributions viennent des développeurs d’Intel (12,8 %), Red Hat (8,5 %) et Linaro (5 %).

Au classement par pays, c’est encore la Chine qui a le plus contribué à cette version, avec 975 correctifs (7,66 %), suivie par l’Allemagne : 960 correctifs (7,54 %) et les États‐Unis : 686 (5,39 %). Un total de 40 nations ont participé par leurs travaux à ce noyau, dont la France avec 480 correctifs (3,77 %).

Télécharger ce contenu au format Epub

Lire les commentaires

Linutop OS, désormais disponible au format Noobs pour Raspberry Pi

31 mai, 2017 - 13:35

Créée en France en 2006, Linutop s’est spécialisée dans les solutions informatiques accessibles à tous, performantes et économiques. Linutop propose trois produits, les PC miniatures Linutop 5 et Linutop XS, le système d’exploitation léger Linutop OS, permettant à l’utilisateur de transformer sa machine en borne d’accès Internet ou en panneau d’affichage dynamique, et enfin le serveur cloud ou local Linutop.TV donnant la possibilité aux entreprises de gérer en ligne leur affichage dynamique.

Le format Noobs a été conçu spécialement pour aider toute personne, quel que soit son niveau en informatique, à installer un système d’exploitation sur Raspberry Pi.
Le logiciel se présente sous la forme d’un fichier qu’il suffira de télécharger puis transférer sur une carte SD (de 8 Gio minimum) préalablement formatée.

Vous n’aurez ensuite plus qu’à démarrer votre Raspberry Pi à l’aide de cette même carte SD. Le logiciel vous proposera, par l’intermédiaire d’une liste, d’installer le système d’exploitation. Choisissez alors Linutop OS XS, patientez quelques instants et vous pourrez profiter de votre machine sous le système d’exploitation Linutop.

Linutop a déjà vendu ses solutions dans plus de 60 pays, elles sont utilisées dans de nombreux domaines tels que les écoles, l’hôtellerie, les usines, les musées, les salles d’attente ou des lieux publics. Linutop est lauréate du prix TIC21 de l’innovation durable.

Linutop OS XS

Linutop OS XS est un système d’exploitation conçu pour simplifier l’usage en entreprise d’un Raspberry Pi. Lors de l’installation, le système d’exploitation Linutop est livré avec tous les logiciels de base vous permettant d’utiliser votre machine le plus rapidement possible.

Logiciels pré‐installés :

  • Epiphany ;
  • LibreOffice ;
  • Lecteur PDF ;
  • Connection Manager (Wi‐Fi) ;
  • VLC Media Player (avec accélération matérielle pour lecture HD) ;
  • Linutop Kiosk.

Le temps d’allumage est de 30 secondes. De plus, le système d’exploitation est facile à maintenir et basé sur Raspbian.

Linutop Kiosk

Le logiciel Linutop Kiosk permet de facilement transformer votre Raspberry Pi :

  • en système d’affichage dynamique, afin de diffuser différents médias en plein écran (images, liens URL, pages Web, vidéos HD, musiques…) ;
  • en borne d’accès Internet sécurisée, avec ou sans barre de navigation, ou restriction(s) de site(s) pour la navigation Internet.

Linutop Kiosk peut être utilisé dans les accueils et vitrines de magasins, en communication interne dans l’entreprise, dans des écoles, des hôtels, des restaurants, des musées…

Linutop OS XS free via Noobs

Si vous choisissez d’installer Linutop OS XS via l’interface Noobs, vous disposerez de la version gratuite du système d’exploitation, cette version n’est ni bridée ni limitée dans le temps, afin de vous donner un aperçu valide du système d’exploitation au quotidien.

Linutop OS XS free contient une version de démo du Linutop Kiosk, vous permettant de l’utiliser comme bon vous semble avec une publicité Linutop toutes les trois diapos en affichage dynamique et, si vous optez pour la borne Internet, la première page de celle‐ci sera sur la page d’accueil Linutop.

Télécharger ce contenu au format Epub

Lire les commentaires

Revue de presse de l’April pour la semaine 21 de l’année 2017

30 mai, 2017 - 09:15

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

[Reporterre] Le coût écologique d’Internet est trop lourd, il faut penser un Internet low‐tech
Par Félix Tréguer et Gaël Trouvé, le samedi 27 mai 2017. Extrait :

« Le combat pour une informatique émancipatrice échoue le plus souvent à expliquer les effroyables coûts écologiques et humains du Numérique, expliquent les auteurs de cette tribune. Qui proposent des pistes pour un Internet low‐tech afin de nous émanciper des sphères technocratiques et industrielles. »

[Numerama] Des informaticiens découvrent comment Volkswagen a trompé les tests environnementaux
Par Antoine Boudet, le vendredi 26 mai 2017. Extrait :

« Volkswagen avait vu son image ternie par cette affaire de tricherie aux tests d’émission de CO₂ de ses véhicules. Aujourd’hui, une équipe de chercheurs en informatique a trouvé le code qui a justement servi à truquer ces fameuses évaluations environnementales. »

[Les Echos] Les entreprises consomment plus de logiciel à la demande
Par_Erick Haehnsen, le mercredi 24 mai 2017. Extrait :

« À l’ère de la transition numérique, l’utilisation de logiciels en entreprise passe de plus en plus par le cloud. Bien que les bastions du logiciel installé sur les ordinateurs individuels ou les serveurs de l’entreprise résistent. Mais le logiciel libre et le SaaS bousculent le paysage des logiciels professionnels. »

[Monde qui bouge] « Pair à pair » : l’essor des communs dans le champ numérique
Par Guillaume Lohest, le mardi 23 mai 2017. Extrait :

« Les “communs” se définissent comme la gestion collective d’une ressource, par une communauté, selon des règles et pratiques sociales définies par celle‐ci. Les communs sont le contraire de l’appropriation privée d’une ressource. On conçoit assez aisément ce fonctionnement avec une collection de semences, une parcelle de forêt, un lac ou un gisement de minerai. Mais comment cela s’applique‐t‐il à ce qu’on appelle les “communs de la connaissance”, c’est‐à‐dire des ressources culturelles, des savoirs, des procédés d’invention ? »

Et aussi :

[clicanoo] « Il faut faire évoluer la propriété intellectuelle pour faire face aux défis du numérique »
Par Johanne Chung, le mardi 23 mai 2017. Extrait :

« À l’heure où internet permet la diffusion et le partage de toutes sortes de contenus, notamment culturels, qui se demande si ce qu’il publie est la propriété intellectuelle de quelqu’un ? Afin de mieux comprendre comment s’exerce la propriété intellectuelle sur le Web, nous avons posé quelques questions à Sulliman Omarjee, juriste de propriété intellectuelle et des nouvelles technologies de l’information et de la communication. »

[Numerama] Emmanuel Macron interpellé sur les liens entre Microsoft et le ministère des Armées
Par Julien Lausson, le lundi 22 mai 2017. Extrait :

« L’association de promotion et de défense du logiciel libre interpelle le chef de l’État sur le renouvellement imminent du contrat entre Microsoft et le ministère des Armées. Elle demande à Emmanuel Macron d’y mettre un terme. »

Et aussi :

Voir aussi :

[The Conversation] Fab lab : do it yourself, hackers et autres open source
Par Clément Duhart, le dimanche 21 mai 2017. Extrait :

« Il serait réducteur de voir dans les fab labs une simple évolution 2.0 du garage californien des années 70. Car il s’agit avant tout de nouveaux espaces pour l’industrie de demain. »

Télécharger ce contenu au format Epub

Lire les commentaires

Participez à la campagne du Pacte du logiciel libre pour les législatives 2017

29 mai, 2017 - 14:06

À l’occasion des élections législatives françaises des 11 et 18 juin 2017, l’April relance sa campagne du Pacte du logiciel libre afin de sensibiliser les futur⋅e⋅s élu·e·s au logiciel libre. Pour informer les futur⋅e⋅s député·e·s sur les enjeux qui y sont associés, et notamment sur les questions d’usage des logiciels libres et des formats ouverts dans les administrations et collectivités, nous vous invitons à participer à cette campagne en contactant les candidat·e·s et en les encourageant à signer le Pacte du logiciel libre.

Une nouvelle plate‐forme a été mise en ligne pour ces élections et la liste des candidat·e·s aux législatives a été importée.

NdM. : Merci à Patrick Trauquesègues qui a aussi proposé une dépêche sur le sujet, dont le contenu a été utilisé pour compléter celle‐ci.

Principe

Il s’agit d’occuper le terrain, notamment autour d’une idée toute simple : un tract ? un pacte !

Lorsque vous croisez un⋅e candidat⋅e, typiquement sur un marché (ce genre d’information est souvent relayé à l’avance sur les sites de campagne), celui‐ci vous tend un tract et cherche à vous convaincre ; en retour, tendez‐lui un pacte et parlez‐lui logiciel libre !

Qui sont les candidats ? Cherchez sur la carte de France électorale. Voir aussi la présentation des élections législatives sur le site du ministère de l’Intérieur. Notez que le site du Ministère de l’Intérieur demande votre autorisation pour activer Twitter ou FaceBook, ce qui est bien ; en revanche, le premier lien n’est pas disponible en HTTPS, ce qui est regrettable pour la page des résultats officiels.

Historique de candidats.fr

L’initiative Candidats.fr a déjà accompagné plusieurs élections :

  • européennes de 2009 ;
  • présidentielles 2007, 2012 et 2017 (via Pour la connaissance libre 2017) ;
  • régionales 2010 et 2015 ;
  • cantonales 2008 et 2011 puis départementales 2015 ;
  • municipales 2008 et 2014 ;
  • législatives 2007, 2012 et 2017.

Le sujet a été fréquemment abordé sur LinuxFr.org : retrouvez les actus précédentes via l’étiquette candidatsfr.

Concrètement, à quoi ça sert ?

La campagne vise deux objectifs :

  • identifier au sein de la future assemblée celles et ceux sur qui nous pourrons nous appuyer pour promouvoir, ou défendre quand nécessaire, les libertés informatiques ;
  • sur le plus long terme, créer un contact entre vous et le ou la futur⋅e élu⋅e et devenir une forme de référent logiciel libre pour celui-ci ou celle-ci au sein de sa circonscription et au niveau national.

Le Pacte du logiciel libre s’inscrit donc dans une double démarche : fournir une base au dialogue entre les citoyen⋅ne⋅s et les candidat·e·s avant les élections autour des enjeux du logiciel libre ; disposer d’engagements clairs pris en conscience.

Télécharger ce contenu au format Epub

Lire les commentaires