Les dépêches de LinuxFr

S'abonner à flux Les dépêches de LinuxFr
Mis à jour : il y a 1 heure 36 min

Statistiques 2018 du site LinuxFr.org

dim, 06/01/2019 - 12:19

En ce début d’année 2019, commençons par deux marronniers de saison : d'abord bonne année à tous, meilleurs vœux, écrivez de belles dépêches en 2019, partagez et contribuez. Et ensuite un petit regard en arrière sur les douze mois d’activité de LinuxFr.org en 2018 : quelles évolutions en termes de trafic Web, de contenus créés, de commentaires déposés, de navigateurs utilisés, d’utilisation des fonctionnalités du site, de contribution au code, etc. Bref : qu’est‐ce qui a changé et comment durant 2018 ?

Le site rend accessible un grand nombre de statistiques (faites‐vous plaisir si vous souhaitez vous plonger dedans, c’est fait pour) ; cette dépêche résume les variations constatées en 2018.

Sommaire Statistiques Web

La comparaison des statistiques annuelles (voir 2017 et 2018) montre la fin du comportement un poil bourrin d'un (ou plusieurs) yacybot apparus en 2017 et calmé en 2018 par des limitations imposées côté serveur. D'où un retour à un niveau plus habituel de ~900 000 hits par jour (en légère hausse néanmoins), de ~1,1 To par mois (en légère hausse en fin d'année néanmoins) et à ~45/50k visites par jour ;

Un changement notable cette année : le nombre de contenus publiés en un an remonte, même si le nombre de commentaires publiés diminue.

Contenus

Au 31 décembre 2018, le site comportait environ 102 340 contenus répartis ainsi :

  • 25 364 dépêches publiées :
    • 475 dépêches publiées en 2018 (nette amélioration de 10% par rapport à 2017 qui était le niveau le plus bas, en très nette baisse),
    • la taille moyenne (en code Markdown, hors images donc) des dépêches a encore augmenté de 4 % (une partie de l’explication vient des dépêches hebdomadaires tirées de l’Agenda du Libre) ;
  • 37 601 journaux (plutôt stable avec -1% de publications par rapport à 2017) ;
  • 36 654 entrées de forum (nette baisse avec -23% de publications par rapport à 2017) ;
  • 408 sondages (dix-sept publiés dans l’année, soit trois de plus qu'en 2017) ;
  • 130 pages de wiki (une vingtaine de tutoriels publiés) ;
  • 369 liens, le nouveau type de contenus apparus en mars 2018.

Le pic de publication des contenus reste le mercredi (talonné par le mardi) sur l’ensemble des contenus (mais on note une différence entre les contenus modérés a priori et les autres, voir la partie Modération plus bas). Un jour de semaine compte 70 % de publications en plus qu’un jour de week‐end (chiffre stable par rapport à 2017).

La publication sous licence Creative Commons By-SA se fait par défaut depuis les dix ans de CC, fin 2012 pour les dépêches (permet explicitement une rédaction collaborative ou un renvoi en re‐rédaction) et les journaux (qui peuvent être convertis en dépêche) : tout naturellement on retrouve 97 % de dépêches et 96 % des journaux sous cette licence au final (les autres étant notamment sous licence Art Libre ou autres, au choix de l’auteur). Les dépêches collaboratives sont toujours aussi nombreuses sur de multiples sujets, vraies réussites du site ; nous sommes cependant toujours à la recherche de volontaires pour couvrir les nombreux sujets qui n’ont pu être abordés. Une liste des thèmes récurrents sur LinuxFr.org peut donner des idées de participation : si une dépêche n’a pas été créée dans les temps, tout inscrit peut la démarrer dans l’espace de rédaction.

Modération

Le temps moyen passé entre la création d’une dépêche (en rédaction ou directement envoyée en modération) et sa modération et publication est de 1007 heures (contre 297 h en 2016 et 696 h en 2017) ; la mesure du temps passé uniquement en modération n’est pas actuellement disponible (et la modération retient volontairement des dépêches non-urgentes pour réguler la publication) ; le temps médian est de 15 heures (contre 17 h en 2016 et 20 h en 2017). Il y a des demandes de statistiques dans le suivi, envoyez les pull‐requests. ;-)

Le jour de modération a priori des contenus est le mardi pour les dépêches et le lundi pour les sondages.

Les nombres d’interdictions de tribune et d’interdictions de poster des commentaires (pour une durée de un ou deux jours, une semaine ou un mois) sont en augmentation mais restent très faibles à l’échelle du site (respectivement 21 et 35 fois), utilisées surtout comme restrictions immédiates sur les spammeurs en attendant la purge du compte fautif par un admin.

Commentaires

Au 31 décembre 2018, le site comporte 1,74 million de commentaires. Le nombre de commentaires par an est en baisse de 15 % (pour la 6e année consécutive) pour arriver à 32 619.

Il y a désormais, en moyenne, 29 commentaires par journal (36 précédemment en 2017, 23 depuis l’origine du site), 15 par dépêches (17 précédemment et 24 depuis l’origine), 40 par sondage (40 précédemment, mais très dépendant des sondages considérés ; 72 depuis l’origine), 7 par entrée de forum (2 précédemment et 5 depuis l’origine), 4 par entrée de suivi (3 depuis l’origine), 3 par lien et une poignée par page wiki.

Le jour préféré pour commenter reste le mercredi et un jour de semaine compte deux fois plus de commentaires de plus qu’un jour de week‐end.

Notes

Il n’y a (toujours) pas de statistiques disponibles concernant les notes. Les entrées de suivi sur les statistiques ont trop peu avancé en 2018.

Tags
  • 11 735 tags dont 11 415 tags publics ;
  • 92 735 saisies de tags (tagués en moyenne huit fois pour les tags publics et dix fois pour les tags privés) ;
  • les tags sont répartis ainsi par contenus :
    • 46 900 pour les dépêches,
    • 29 600 pour les journaux
    • 13 900 pour les forums,
    • 1 150 pour les liens,
    • 650 pour les pages wiki,
    • 260 pour les sondages,
    • 250 pour le système de suivi des défauts et évolutions.

Depuis le début du site, on constate en moyenne 5 tags par pages wiki, 3 par lien 1,9 par dépêche, 0,8 par journal, 0,7 par sondage, 0,4 par entrée de forum et 0,1 par entrée du suivi.

On peut aussi noter une autre particularité : le jour où le plus de tags sont apposés est le lundi (et non le milieu de semaine, qui est le pic de publication des contenus et des commentaires).

Équipe de bénévoles

Il y a actuellement 7 admins Web/système, 11 modérateurs (+1, bienvenue à Julien Jorge) et 7 animateurs de l’espace de rédaction qui font tourner ce site (un admin et un animateur de moins, merci à eux pour le travail accompli). Pour mémoire, il s’agit de bénévoles plus ou moins disponibles et donc absolument pas de 24 équivalents temps plein pour jargonner comme une entreprise.

Code et développement

Au 31 décembre 2018, le système de suivi de défauts et de demandes d’évolutions contient 142 entrées (contre 223 en 2017). On voit assez rapidement un manque de développeurs apparaître. En 2018, il y a eu 69 entrées ouvertes (contre 87 en 2017) : 28 entrées encore ouvertes venant s’ajouter à celles datant d’avant, 26 corrigées et 15 déclarées invalides). On peut noter que ceux qui ouvrent le plus d’entrées sont des membres actuels ou anciens de l’équipe du site.

C’est Bruno qui, de loin, a corrigé le plus d’entrées. Le temps moyen de résolution est de 112 jours (contre 91 précédemment), encore en hausse. La moitié des entrées fermées ont été traitées en moins de sept jours. On ressent donc toujours un besoin de nouveaux contributeurs côté code.

La charge moyenne sur le serveur est de 1,8 (contre 1,9 en 2017) sur la machine actuelle (baptisée gruik). La charge minimale a été de 1,0 et la maximale de 3,6.

La consommation mémoire est stable sur la partie de l’année sur laquelle ces statistiques existent. Le trafic réseau sur la partie Web est en moyenne de 5,6 Mbit/s sortants (contre 8,2 précédemment) pour 535 kbit/s entrants (contre 520 précédemment), avec des pics à deux fois ces valeurs). Le trafic réseau total est en moyenne de 7,1 Mbit/s sortants (contre 9,7 précédemment) pour 590 kbit/s entrants (=), avec des pics à 14 Mbit/s sortants.

Comptes utilisateurs

Au 31 décembre 2018, sur les 47 990 comptes utilisateurs valides existants, 2 750 ont été utilisés au cours des trois derniers mois (33 % (- 1 point) ont déjà rédigé des dépêches, 38 % (=) des journaux, 38 % (- 1 point) des entrées de forums, 10 % (=) des entrées dans le système de suivi ; 79 % (- 2 points) ont écrit des commentaires et 42 % tagué des contenus (+ 1 point) ; 25 % (- 1 point) des comptes actifs ont indiqué un site personnel, 11 % (=) un identifiant XMPP, 23 % (- 1 point) un avatar et 5 % une signature.

Côté utilisation des fonctionnalités, 3 % ont demandé à ne pas voir les signatures, 5 % à ne pas voir les avatars et 8% avec le tri chronologique en page d'accueil (chiffres stables) et à peine quelques pourcents ont changé les contenus par défaut en page d’accueil (souvent pour retirer les sondages et ajouter les journaux). Peu de feuilles de style CSS du site sont utilisées : presque quatre visiteurs sur cinq utilisent celle par défaut ; il est facile d’en changer avec le lien Changer de style.

Une douzaine de comptes ont un karma négatif, soit 0 % des visiteurs actifs ; 18 % des comptes actifs durant les trois derniers mois ont été créés en 2018.

36 % des visiteurs actifs ont une adresse de courriel GMail, 12 % chez Free, 4 % chez Yahoo et 4 % chez Hotmail ou Outlook, 3 % chez LaPoste et 2 % chez Orange ou Wanadoo.

Soucis divers

Le compteur d'années sans mises en demeure reçues s'est incrémenté (passant à 1 donc).

/ Only two formals notice in the default \ \ install, in a heck of a long time! / ---------------------------------------- \ \ .--. / Ouep... \ |o_o | \ Euh coin / |:_/ | ---------- // \ \ \ (| | ) \ /'\_ _/`\ \ >()_ \___)=(___/ (__)__ _

Depuis la création du site, statistiques liées au légal (dans les sens liés à la force publique ou à du juridique) :

  • deux mises en demeure reçues (pour zéro assignation) ;
  • une réquisition judiciaire reçue (qui au final ne nous concernait pas, mais a donné l’occasion de discuter avec la police nationale) ;
  • un cas d’usurpation d’identité et de harcèlement type « revenge porn » (discussion avec la gendarmerie nationale).
Test d'autres solutions de statistiques que webalizer

Une entrée dans le suivi (de 2010) concernait le test d’une autre solution des stats Web (depuis 2010). Une dépêche avait été amorcée en janvier 2017 sur le sujet mais n'avait pas été terminée. Voici donc un test de solutions de statistiques web (Debian Stretch) sur un an de logs (l'année 2017) traité (environ 5 Gio de access.log.xz, à décompresser et traiter).

Les solutions d'analytique sont appelées depuis la page web, elles tracent en temps réel le visiteur avec des cookies pour suivre de façon très fine son parcours dans le site. On les utilise par exemple sur des objectifs déterminés de parcours visiteur ou de référencement, dont elles mesurent l'efficacité.
L'analyse de logs intervient à posteriori.

  • les solutions basées sur du code dans les pages (probablement pas la solution idéale pour nous en raison de l'injection de JavaScript, indépendamment de la richesse des fonctionnalités) :
    • Open Web Analytics (GPL) : PHP/MySQL, nécessite d'être appelé depuis du JavaScript (ou du PHP, mais on n'en a pas sur le site…). Non empaqueté Debian ;
    • Matomo (anciennement Piwik) (GPL) : PHP/MySQL, nécessite d'être appelé depuis du JavaScript (ou via Ruby-Rack). Non empaqueté Debian. Projet actif ;
  • les solutions basées sur les logs :
    • Webalizer 2.23.08-1+b3 (GPL) : écrit en C, traite un an de logs en moins de 2h30, le résultat est celui déjà connu car c'est la solution actuelle. La version date de 2013 (hors correctifs Debian) et n'est plus maintenue ; il existe des forks comme Webalizer Xtended (dernière version en 2014) ou Stone Steps Webalizer (dernière version en 2015) ;
    • Analog 6.0-22 (GPL) : écrit en C ; vu que le projet d'origine a perdu son domaine (remplacé par une communauté), que les échanges sont réduits à une liste de diffusion qui semble peu active, qu'il n'y a pas de nouvelle version depuis 2015 et que le paquet Debian est orphelin, ça ne donne pas forcément envie de tester ;
    • Awstats 7.6+dfsg-1 (GPL) : écrit en Perl, dernière version le 7 janvier 2018 ; paquet Debian orphelin (mais il vient de recevoir un correctif sécu chez Ubuntu et Debian) ; il traite un an de logs en 13h40 (sans résolution DNS) ;
    • Matomo : permet aussi d'importer des données depuis des journaux d'un serveur http plutôt que d'utiliser du JavaScript (le test avait échoué début 2017 et serait à refaire) ;
    • GoAccess : écrit aussi en C, le projet a maintenant plus de 8 ans (premier commit sur GitHub le 9 juillet 2010), et reste maintenu (la version 1.3 date de novembre 2018) ;

Awstats :

  • une visite Awstats correspond à une IP accédant à quatre pages différentes durant une heure.
  • une visite Webalizer est comptée comme le retour d’une même adresse IP après un certain temps, 10  min pour LinuxFr.org.
  • Webalizer annonce 22,6 To téléchargés, 18,5 M de visites, 137 M de pages, 445 M de fichiers et 529 M de hits.
  • Awstats annonce 8,2 To téléchargés, 3,8 M de visiteurs différents, 12,3 M de visites, 90,3 M de pages et 208 M de hits de trafic vu (hors robots), et 13,3 To téléchargés, 291 M de pages et 302,5 M de hits de trafic non vu.
  • Awstats nous apprend aussi
    • que les images PNG+SVG font 40% des hits et 4,8% du volume, les flux Atom font 80% du volume pour 28,2% des hits, css/js/epub font chacun moins de 3% en volume et hit. Enfin les pages web (XML) font 9,3% des hits et 2,1% du volume (stat absente côté Webalizer).
    • que les pages les plus téléchargées sont sans surprise /news.atom, /journaux.atom, /, /journaux, /forums.atom, /news, /sondages.atom, /forums et /board
    • que le système d'exploitation utilisé est Linux pour 40% des pages, inconnu (?) pour 38%, Windows pour 18% et Macintosh pour 4%
    • que le navigateur est inconnu (?) pour 36% des pages, Firefox pour 29%, Google Chrome pour 25%, et que Liferea/Safari/MS Internet Explorer et Opera ont chacun 1 ou 2%.
Dans les choses toujours à dire et à faire

Il y a encore bien d’autres choses à dire et à faire concernant les statistiques du site, notamment des statistiques supplémentaires demandées par mjourdan dans le cadre de l’amélioration de l’expérience utilisateur sur le site ou les entrées de suivi concernant les statistiques.

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

Chaque mardi à 15h30 : nouveau rendez-vous avec l'émission Libre à vous ! de l'April

ven, 04/01/2019 - 20:20

Depuis mai 2018, l'April anime Libre à vous !, une émission mensuelle d'explications et d'échanges sur la radio Cause Commune. Pour pouvoir traiter encore plus de sujets et être réactif par rapport à l’actualité, l'émission devient un rendez-vous hebdomadaire à partir du 8 janvier 2019. Pour la première émission de cette nouvelle année, nous recevrons Laure Lucchesi directrice de la mission Etalab, et Laurent Joubert de la DINSIC.

En 2018, nous avons démarré une nouvelle action importante pour la promotion et la défense des libertés informatiques : depuis le mois de mai, nous animons une émission de radio mensuelle, chaque premier mardi du mois de 15h30 à 17h, sur Cause Commune. La radio Cause commune a commencé à émettre fin 2017 sur la bande FM en Île-de-France (93.1) et sur le site web de la radio. Sur le site de la radio on lit :

Radio associative et citoyenne, les missions de Cause Commune sont de fédérer toutes les initiatives autour du partage et de l’échange de savoirs, de cultures et de techniques. ```Nous avons alors proposé de tenir une émission April intitulée _Libre à vous !_ — l'émission pour comprendre et agir avec l'April, l'association de promotion et de défense du logiciel libre —, émission d'explications et d'échanges concernant les dossiers politiques et juridiques que l'April traite et les actions qu'elle mène. Une autre partie de l'émission est consacrée aux actualités et actions de type sensibilisation. En 2018, sept émissions ont été diffusées ([les podcasts et les transcriptions sont disponibles](https://april.org/les_podcasts_libre_a_vous)). Ces émissions ont permis d'aborder des sujets variés allant de l'Open Bar Microsoft/Défense, en passant par la téléphonie mobile et les libertés, sans oublier les relations entre logiciel libre et monde associatif, le projet de directive sur le droit d’auteur, les menottes numériques (DRM), le label Territoire Numérique Libre, le Libre en Fête, les données publiques ouvertes, … Pour pouvoir traiter encore plus de sujets et être réactif par rapport à l’actualité ce rendez-vous deviendra hebdomadaire à partir du 8 janvier 2019. L'émission sera diffusée chaque mardi de 15h30 à 17h. Le podcast sera disponible peu après la fin de l'émission. Pour la première émission de cette nouvelle année, notre sujet principal consistera en la présentation des actions de la Direction interministérielle des systèmes d’information et de communication de l’État (DINSIC) ainsi que celles de la mission Etalab, chargée de la politique d'ouverture et de partage des données publiques du gouvernement français. L’émission dispose d’un [flux RSS compatible avec la baladodiffusion](https://april.org/lav.xml) auquel vous pouvez vous abonner, ainsi qu’un [salon dédié à l’émission sur le webchat de la radio](https://talk.libre-a-toi.org/channel/libreavous). La radio a besoin de soutien financier pour notamment payer les frais matériels (loyer du studio, diffusion sur la bande FM, serveurs, …). Je vous encourage à [aider la radio en faisant un don](https://cause-commune.fm/faire-un-don/). Une nouveauté sur la radio Cause Commune, il y a une messagerie sur laquelle vous pouvez laisser des messages (annonces, rires, poèmes, coups de gueule, voeux, …) destinés à passer à l'antenne sur la radio. Le numéro à appeler est le 01 88 32 54 33. Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

Sortie de Gambas 3.12

lun, 31/12/2018 - 21:13

Gambas est un langage de programmation orienté objet, basé sur un interpréteur BASIC, et une plate‐forme de développement complète, comportant, entre autres, un compilateur, un interpréteur, un ensemble de modules complémentaires (appelés composants) et un environnement de développement intégré. Le tout est distribué sous licence GNU GPL v2 ou supérieure.

La précédente dépêche datant de septembre 2012, profitons de la sortie de la version 3.12 pour présenter comment le langage a évolué depuis six ans.

Nous invitons ceux qui ne connaîtraient pas Gambas à lire préalablement la présentation du logiciel sur le site web ainsi que la dépêche précédente.

Comme dans la dépêche précédente, il y a quelques coups de gueules, mais ils sont cette fois répartis dans le texte. (et partiellement édulcorés en modération)

Sommaire Un nouveau compilateur « à la volée »

L'évolution majeure de la version 3.12 est l'abandon de l'ancien compilateur basé sur une vieille version de LLVM, et la réécriture d'un nouveau compilateur « à la volée ».

Ce compilateur traduit le « bytecode » Gambas en langage C pendant l'exécution, et utilise ensuite le compilateur du système (gcc ou clang) pour obtenir le code machine final.

Cette méthode de compilation a le désavantage d'être plus lente que la génération de code classique. Mais elle a le gros avantage de ne pas dépendre de l'API souvent peu fiable offerte par chaque compilateur C.

Contrairement à l'ancien compilateur, le support du langage est complet. De plus, il y a maintenant la possibilité de désactiver certains tests comme la vérification des accès aux tableaux ou les tests de division par zéro afin de gagner en vitesse au risque de possibles plantages de l'application.

Remarque : Apparemment les développeurs de Ruby ont eu la même idée !

Coup de gueule n°1

L'API de génération de code de LLVM a été refaite entre LLVM 3.5 et LLVM 3.6. C'est quoi cette manie de sortir une version mineure d'une bibliothèque sans assurer de rétro-compatibilité ?

Développement d'applications Web avec interface graphique

Une autre évolution majeure est la possibilité de développer des applications Web depuis l'environnement de développement à la manière des applications graphiques classiques.

Nouveau composant et support de l'environnement de développement

Cette fonctionnalité repose sur un nouveau composant, gb.web.form, qui ajoute à l'environnement de développement un nouveau type de formulaire graphique, les WebForm.

Ces "formulaires web" servent à définir les différents écrans de votre application web, qui pourront être ou bien des pages HTML classiques, ou bien des boites de dialogues modales.

Le composant offre ensuite de nombreux contrôles graphiques web qui vont peupler vos différents formulaires, à la manière d'une interface graphique locale classique.

Voici par exemple un formulaire d'une application web de gestion de radio Internet :

Principe de fonctionnement

Le principe retenu diffère sensiblement des habitudes à la mode : votre application, une fois compilée, devient un script CGI, et pratiquement tout est géré au niveau du serveur.

Le navigateur de l'utilisateur est principalement utilisé comme un terminal graphique, le HTML devenant le protocole de description de l'interface. On utilise le minimum de Javascript possible.

Les actions de l'utilisateur sont envoyées à l'application sous forme de requêtes XML/HTTP qui répond en envoyant le code javascript nécessaire au rafraîchissement de la page.

L'état de l'interface graphique est mémorisée dans la session de chaque utilisateur.

C'est bien évidemment plus lent que les applications web s'exécutant majoritairement dans le navigateur, et cela offre moins de possibilités. Mais cela fonctionne pas mal.

Voici le résultat du formulaire précédent dans le navigateur Chrome :

Il y aurait encore beaucoup à dire sur ce composant !

Autres évolutions majeures Changements dans l'infrastructure de développement

Le développement de Gambas a été migré de subversion vers git. Le référentiel étant stocké maintenant sur gitlab.com.

Après environ 18 mois d'utilisation, je peux confirmer que git est plus puissant, plus rapide, plus pratique et plus fiable. Il n'y a franchement rien à redire.

D'autre part, les listes de diffusion ont été migrées depuis Sourceforge vers un serveur privé maintenu par un utilisateur de Gambas.

Le gestionnaire de bugs est depuis longtemps un logiciel développé en Gambas hébergé par la société qui m'emploie.

Ne reste plus donc que le site web sur Sourceforge. Sans doute pas pour longtemps !

Support de nouvelles architectures / systèmes d'exploitation

Le support des systèmes autres que Linux et des architectures autres que i386 et x86_64 a été amélioré.

Gambas devrait normalement se compiler sans souci sur les systèmes :

  • FreeBSD.
  • NetBSD.
  • GNU/kFreeBSD.
  • CygWin.

Ainsi que sur les architectures :

  • ARM.
  • ARM64.
  • PowerPC64.

Il y a même eu des modifications pour Hurd !

Serveur de publication de logiciels écrits en Gambas

Gambas dispose maintenant d'un serveur de publication de logiciels écrit lui-même en Gambas. Il permet de publier et d'installer tout type de logiciel écrit en Gambas.

L'environnement de développement dispose d'une interface graphique permettant de lister les logiciels publiés, de les filtrer, de les installer et de les désinstaller. Il permet aussi de publier très facilement votre projet.

Remarque : Les programmes d'exemples auparavant fournis avec les sources sont désormais stockés sur le serveur de publication.

Améliorations de l'environnement de développement intégré Nouvel éditeur d'images

L'éditeur d'images a été entièrement réécrit et amélioré :

  • Possibilité d'avoir des sélections multiples.
  • Opérations booléennes sur les sélections, grâce au nouveau composant gb.clipper (voir plus loin).
  • Rotation, étirement, duplication de sélections.
  • Sélection par baguette magique.
  • Balance des couleurs, floutage, opacité.
  • Coloriage, désaturation, transformation d'une couleur en transparence.

Support de git

Le gestionnaire de version intégré supporte maintenant git en plus de subversion, et son interface a été revue.

L'intégration de git à l'IDE possède un mode de fonctionnement similaire à subversion, elle a en plus le support des branches.

Dans tous les cas, rien n'empêche d'utiliser la ligne de commande dès qu'on a d'autres besoins. git est si vaste qu'il est difficile de proposer une interface graphique qui soit simple sans devoir restreindre les fonctionnalités.

Mode fichier unique

L'environnement de développement peut être maintenant utilisé pour éditer des fichiers uniques, sans devoir créer de projet pour cela.

Cette fonctionnalité est très pratique pour éditer rapidement une image, ou bien pour examiner une base de données SQLite.

Modèles de projet

La boite de dialogue d'ouverture de projet a été revue : elle se base maintenant sur une liste de modèles de projet.

Cette liste est extensible à volonté. Il suffit de créer de nouveaux projets dans le répertoire ~/.local/share/gambas3/template/, et ils seront pris en compte en tant que nouveaux modèles.

Police Gambas dédiée à l'édition de code

Une police appelée « Gambas » est maintenant installable dans votre répertoire personnel à partir de l'écran des options.

Il s'agit d'une police bitmap existant en deux tailles, 9 et 10 points, et en deux variantes, normale et grasse.

Elle contient de nombreux caractères Unicode, et même si elle n'est pas complète, elle est largement plus utilisable que nombre de polices Bitmap existantes.

Améliorations diverses
  • Possibilité de désactiver un point d'arrêt.
  • Support des fichiers au format patch.
  • Le créateur de paquets gère maintenant les applications indépendantes du toolkit graphique.
  • Complétion automatique des noms de fichiers.
  • En cas de plantage de l'environnement de développement, les fichiers modifiés sont automatiquement sauvegardés.
  • La boite de dialogue d'ouverture de projet a été revue.
  • L'aide hors-ligne est téléchargeable depuis l'écran des options.
  • La compression des fichiers Javascript et CSS a été améliorée.
  • Les fichiers PNG peuvent être automatiquement compressés si l'outil pngquant est présent.
  • Le support des thèmes sombres a été grandement amélioré.
  • Le gestionnaire de sessions du bureau est supporté.
  • L'interface du débogueur a été revue.
  • Fenêtre d'insertion de caractères spéciaux.
  • etc.
Accès aux bases de données

Le système d'accès aux bases de données a été amélioré :

  • Les connexions définies dans l'environnement de développement sont accessibles à l'exécution, et les mots de passes éventuellement associés et stockés dans le portefeuille du bureau sont automatiquement récupérés.

  • Les collations de champs sont maintenant gérées, lorsqu'elles sont supportées par le type de bases de données sous-jacent.

  • Une classe SQLRequest a été ajoutée. Elle permet de construire une requête SQL en tenant compte automatiquement des différences de syntaxe entre les SGBD.

  • La propriété Connection.LastInsertId permet de récupérer la dernière valeur générée par un champ auto-incrémenté.

  • Le composant gb.db.mysql permettant d'accéder aux bases de données MySQL est plus rapide, grâce à l'implémentation d'un cache interne de méta-données.

  • Le composant gb.db.sqlite3 permettant d'accéder aux bases de données SQLite 3 a été complètement récrit en C. Il est maintenant plus fiable, plus rapide et consomme moins de mémoire.

  • Le composant gb.db.odbc peut maintenant recevoir une chaîne de connexion ODBC complète comme nom d'hôte de la base de données.

  • Le composant gb.db.form, qui offre des contrôles graphiques liés aux bases de données, a reçu pas mal de corrections.

D'autre part, le gestionnaire de bases de données de l'environnement de développement offre maintenant la possibilité de stocker la structure d'une base de données dans le projet.

Cette structure est ensuite utilisée à l'exécution pour créer automatiquement de nouvelles bases de données à l'identique, par l'intermédiaire de la méthode Connections.Create().

Composant éditeur de texte

L'éditeur de texte avec coloration syntaxique a été complètement récrit en Gambas. Il est implémenté dans le nouveau composant gb.form.editor.

Cet éditeur offre toutes les fonctionnalités de l'ancien, et apporte les nouveautés suivantes :

  • Barre de défilement avec pré-visualisation du texte.
  • Complétion automatique des parenthèses, crochets, et des séparateurs de chaînes.
  • Plus de colorations syntaxiques.
  • Passage à la ligne automatique.
  • Défilement fluide.
  • Mise en évidence de la structure de contrôle courante.
  • Mise en surbrillance de la chaîne de recherche courante.

Et comme l'éditeur est écrit en Gambas, il est possible de l'utiliser dans des applications GTK+.

Composant émulateur de terminal

Le nouveau composant gb.form.terminal implémente un contrôle émulateur de terminal compatible VT-100 complet, intégralement écrit en Gambas.

Il permet enfin à l'environnement de développement d'afficher la sortie du projet en cours dans un vrai terminal.

Accès aux cartes

gb.map est un nouveau composant qui permet l'affichage de cartes au format tuile, telles que OpenStreetMap, Google, Microsoft Earth et autres.

Le composant fournit une classe Map représentant la carte à afficher : elle est capable de superposer un nombre arbitraire de calques provenant de serveurs de tuiles différents, ainsi que des calques affichant des formes vectorielles.

Il fournit aussi un contrôle MapView qui se charge d'afficher la carte et qui permet d'interagir avec via la souris.

Les transformations entre les différents systèmes de projection et de coordonnées sont gérés par l'outil cs2cs du projet Proj.

Exemple :

──────────────────────────────────────────────────────────────────────────────────────── Public Sub Form_Open() MapView1.Map.AddTile("OpenStreetMap", "http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png", Null).Copyright ="© OpenStreetMap contributors" ' Centrer sur Paris MapView1.Map.Center = MapPoint(48.866667, 2.333333) MapView1.Map.Zoom = 5 End ────────────────────────────────────────────────────────────────────────────────────────

Composants d'interfaces graphiques Toolkits graphiques

Gambas supporte toujours les toolkits graphiques QT et GTK+, et offre une API identique pour les deux composants, ce qui permet à une application graphique d'utiliser indifféremment l'un ou l'autre toolkit, voire de décider lequel utiliser en fonction du bureau courant.

Un nouveau composant gb.qt5 prend en charge la bibliothèque QT5, tandis qu'un nouveau composant gb.gtk3 gère la bibliothèque GTK+3.

Il y a donc maintenant quatre composants d'interface graphique qui ont tous la même interface.

Les autres modifications principales sont les suivantes :

  • L'API de dessin standard est maintenant la classe Paint, qui implémente un modèle similaire à Cairo. Des fonctions de tracé de texte avec ombres ont été ajoutées, ainsi que quelques fonctions de dessin utilitaires.

  • Les fenêtres avec composante alpha sont maintenant supportées.

  • L'ancienne API de dessin GTK+2 a été abandonnée et Cairo est utilisé partout dans les composants GTK.

  • Les sessions du bureau sont maintenant gérées. La propriété Application.Restart permet de définir la commande à exécuter par le gestionnaire de session pour rétablir l'application à l'ouverture du bureau.

  • Le support du multi-écran s'est amélioré (par exemple les boites de dialogues doivent apparaître et se centrer dans l'écran de leur fenêtre parente).

Coup de gueule n°2

Chaque nouvelle version mineure de GTK+3 octroyait le divin plaisir de voir une partie de la bibliothèque ne plus fonctionner. À tel point que certains m'ont suggéré de ne plus tenter de la prendre en charge dans Gambas.

Je crois que GTK+3 est la pire bibliothèque que j'ai jamais dû utiliser, en termes d'absence de rétro-compatibilité

Ce que j'espère : que GTK+3 était en réalité une version bêta permanente de GTK+4, et que tout ira bien à l'avenir.

Réécriture de contrôles en Gambas

De nombreux contrôles natifs ont été réécrits en Gambas, et fonctionnent donc de manière identique avec Qt ou GTK+.

Ils sont implémentés dans le nouveau composant gb.gui.base, qui sert de base pour tout le code écrit en Gambas commun à tous les toolkits graphiques.

Grâce à cette réécriture et cette mise en commun poussée, il a été possible d'implémenter les fonctionnalités suivantes : les vues avec défilement affichent maintenant des ombres intérieures, et supportent automatiquement un défilement fluide.

Ajout de nombreux nouveaux contrôles
  • ColorPalette : un sélecteur de couleurs choisies parmi une palette.
  • DirBox : un champ texte couplé à une sélection de répertoire.
  • DocumentView : un contrôle permettant de visualiser tout type de document.
  • FileProperties : un contrôle qui affiche les propriétés d'un fichier et la taille des répertoires, taille qu'il calcule dans une tâche d'arrière-plan.
  • FontBox : un champ texte couplé à une sélection de police.
  • ImageView : un contrôle permettant de visualiser une image à différents niveaux de zoom.
  • ListEditor : un contrôle permettant d'éditer et de réordonner une liste d'éléments.
  • MessageView : un panneau d'affichage de messages qui apparaît ou disparaît automatiquement.
  • SliderBox : le regroupement d'un Slider et d'une SpinBox, similaire à ce qui existe dans GIMP.
  • Spinner : l'affichage d'une animation d'attente sous forme de traits en rotation.
  • Spring : un contrôle "ressort" qui est l'équivalent d'un Panel dont la propriété Expand vaut True.
  • SwitchButton : un bouton ON/OFF.
Gestion de la barre d'icônes du bureau

La gestion de la barre d'icônes a été revue. Désormais, si une barre d'icône prenant en charge le protocole DBus de freedesktop est détectée, ce protocole est automatiquement utilisé par l'intermédiaire du composant gb.dbus.trayicon.

Autrement, et pourvu que cela soit encore supporté par le bureau courant, c'est l'ancien protocole X11 qui est utilisé.

Coup de gueule n°3

Les développeurs de KDE, Gnome (et Unity) ont réussi l'exploit de se mettre d'accord sur un protocole DBus de barre d'icône système, et de l'implémenter chacun de manière incompatible.

Par conséquent, la gestion des icônes par DBus ne fonctionne intégralement qu'avec le bureau KDE. Pour tout autre bureau, le support du protocole est aléatoire, certaines choses fonctionnant et d'autres non.

Jeux d'icônes intégrés

Le composant gb.form.stock fournit deux jeux d'icônes complets pour Gambas : un en couleur, et un monochrome. Ils sont composés d'images PNG de 32 × 32 pixels, qui sont ensuite automatiquement étirées en fonction des besoins.

Ces deux jeux d'icônes permettent d'écrire des applications graphiques qui ne dépendent pas du jeu d'icônes standard du bureau.

Composants multimedia Support de GStreamer

Le composant gb.media est maintenant basé sur GStreamer 1.0. Sa stabilité a été grandement améliorée, même si tout n'est pas parfait, à cause, entre autres, de la grande fragilité de l'API de GStreamer.

Les fonctionnalités suivantes ont été ajoutées :

  • Le support des « capsfilter », c'est-à-dire des filtres de formats multimédias.
  • L'interception des messages émis par les « pipelines » GStreamer.
  • La capture de la trame vidéo en cours de traitement.
  • La capture de la dernière image émise par un « pipeline ».
  • La possibilité d'enchaîner deux flux multimédia sans coupure.

D'autre part un nouveau composant gb.media.form fournit un lecteur multimédia simple sous forme de contrôle graphique.

Support des scanners

gb.scanner est un nouveau composant qui est principalement un « wrapper » du programme scanimage fournit par le projet Sane.

L'acquisition d'une image s'effectue de la manière suivante :

──────────────────────────────────────────────────────────────────────────────────────── Dim hImg as Image hImg = Scanners["hpaio:/net/HP_LaserJet_MFP_M426fdn?ip=192.168.1.25"].Scan() ────────────────────────────────────────────────────────────────────────────────────────

Toutes les options disponibles dans scanimage sont accessibles via la propriété Option de chaque objet Scanner.

La possibilité de scanner plusieurs pages est offerte en mode asynchrone.

Composants réseau

En plus des nombreuses corrections de bugs apportées au composant réseau de base gb.net, les améliorations suivantes ont été apportées :

  • Le composant gb.net.smtp, qui gère le protocole SMTP, a été entièrement réécrit en Gambas. Il est beaucoup plus fiable, et il supporte maintenant les authentifications PLAIN et CRAM-MD5, ainsi que SSL et TLS.

  • Le composant gb.net.curl gère maintenant le procole ftps://. Il dispose d'une classe HttpForm pour facilement soumettre des formulaires HTTP, et d'une classe DownloadManager pour gérer des téléchargements multiples de manières asynchrone.

  • gb.web.feed est un nouveau composant pour gérer les flux RSS.

  • gb.httpd est un nouveau composant qui implémente un serveur HTTP embarqué simplifié. Il est utilisé par l'environnement de développement pour déboguer les applications web réalisées avec les composants gb.web ou gb.web.form.

Arithmétique multi-précision

Le nouveau composant gb.gmp apporte à Gambas la possibilité de manipuler des nombres entiers et des nombres rationnels avec une précision arbitraire.

Il est basé sur la bibliothèque GNU d'arithmétique multi-précision.

Exemple :

──────────────────────────────────────────────────────────────────────────────────────── ' Série convergente vers ℯ Dim A, B As Rational Dim I As Integer A = 0 B = 1 For I = 0 To 17 A += B / BigInt.Fact(I) Print A; Space$(30 - Len(Str(A)));; ":";; CStr(CFloat(A)) Next ──────────────────────────────────────────────────────────────────────────────────────── 1 : 1 2 : 2 5/2 : 2.5 8/3 : 2.66666666666667 65/24 : 2.70833333333333 163/60 : 2.71666666666667 1957/720 : 2.71805555555556 685/252 : 2.71825396825397 ... 7437374403113/2736057139200 : 2.71828182845905 ──────────────────────────────────────────────────────────────────────────────────────── Composants utilitaires

Deux composants utilitaires ont été ajoutés :

Le premier, gb.util, regroupe des méthodes et des extensions pratiques de l'interpréteur :

  • Lecture et décodage de fichiers CSV.
  • Conversion de dates au format Unix ou RFC 822.
  • Calcul du jour de Pâques.
  • Fonctions de création, déplacement et suppression de répertoires « intelligentes ».
  • Distance de Damerau-Levenshtein entre deux chaînes de caractères.
  • Extraction du texte contenu dans un morceau de HTML.
  • Suppression des signes diacritiques.
  • Conversion d'une chaîne en expression phonétique (seul le Français étant implémenté).

Le second, gb.util.web, regroupe des méthodes indispensables à la programmation web :

  • Encodage vers Javascript.
  • Encodage et décodage de flux JSON.
  • Manipulation d'URI.
Autres nouveaux composants
  • gb.args est un nouveau composant qui sert à analyser les arguments passés en ligne de commande à partir de leur description.

  • gb.clipper est un nouveau composant basé sur la bibliothèque Clipper.

  • Le composant gb.data implémente maintenant les tas, les arbres radix, et une interface de manipulation de graphes.

  • gb.memcached est un nouveau composant qui implémente un client pour memcached.

  • gb.openal est un nouveau composant basé sur la bibliothèque audio 3D OpenAL.

  • gb.openssl est un nouveau composant qui offre une interface aux fonctions cryptographiques de la bibliothèque libcrypto du projet OpenSSL.

  • gb.inotify est un nouveau composant qui permet de monitorer les fichiers du système. Il se base sur l'interface inotify de Linux.

  • gb.markdown est un nouveau composant qui implémente le support de la syntaxe Markdown, sous une forme légèrement différente de l'originale.

  • Le composant gb.report a été remplacé par le nouveau composant gb.report2 qui en est une amélioration.

  • La bibliothèque SDL2 est maintenant supportée grâce aux nouveaux composants gb.sdl2 et gb.sdl2.audio.

  • Enfin gb.term est un nouveau composant permettant de manipuler les terminaux Unix, avec une interface très proche de celle offerte par le système d'exploitation.

Améliorations du langage Nouvelles syntaxes
  • If...Then...Else... peut maintenant s'écrire sur une seule ligne.

  • Match est un nouvel opérateur qui implémente une comparaison par correspondance de modèle ("pattern matching") en utilisant la bibliothèque gb.pcre.

  • .[xxx] et !xxx sont deux nouveaux raccourcis pour les opérateurs de tableaux, à utiliser au sein d'une structure With...End With.

  • Le symbole ... peut-être utilisé pour passer tous les arguments optionnels d'une fonction à une autre fonction.

  • Les constantes numériques peuvent être écrites en octal, sous la forme &Oxxx.

  • Les variables locales peuvent maintenant être déclarées n'importe où dans le corps d'une fonction. Mais leur portée reste toujours celle de la fonction courante.

  • Il est possible de déclarer les variables de boucles directement au début des structures For et For Each ainsi : For I As Integer = 1 To 100.

  • Il est maintenant possible d'accéder au contenu des chaînes de caractères avec l'opérateur de tableau.

  • Enfin le compilateur émet un avertissement pour chaque variable locale ou globale qui n'a pas été initialisée.

Nouvelles fonctions
  • IsMissing() permet de tester l'absence d'un argument optionnel.

  • Rand() retourne un nombre pseudo-aléatoire entier.

  • System.Log() permet d'écrire dans le log du système (c'est une interface à l'API syslog de la libc).

  • Url() et FromUrl() servent à respectivement encore et décoder les URLs.

  • Move ... Kill ... permet de déplacer un fichier tout en supprimant la destination de manière atomique. Cette fonctionnalité est indispensable dès lors que deux processus sont susceptibles d'écrire le même fichier en même temps.

  • Assert permet d'insérer des assertions dans le code qui stoppent le programme en cas d'échec. Ces assertions ne sont pas compilées lorsque vous générez un fichier exécutable.

Correction des fonctions de gestion du temps

Le support des fonctions de date et heure est désormais cohérent.

Il y a maintenant une claire séparation entre les fonctions qui interprètent une date en temps locale et celles qui l'interprètent en temps universel (UTC).

En particulier, les fonctions CStr() et CDate() sont maintenant réciproques comme elles auraient dû l'être depuis le début, au prix d'une rétro-incompatibilité.

Optimisations
  • La fonction Split() est plus rapide.

  • Les accès aux tableaux et aux collections sont plus rapides. Le benchmark sort est 25% plus rapide.

  • La plupart des méthodes Find() et Exist() des tableaux sont plus rapides.

  • Les instructions Input et Line Input sont plus rapides.

  • Les conversion vers le type Boolean, et vers ou depuis le type Variant sont plus rapides.

  • Les opérateurs d'inégalité sont plus rapides.

  • Les fonctions Dir() et RDir() sont maintenant plus rapides de 20 à 40%, grâce à l'utilisation de fstatat(), et au moins grand nombre d'appels à stat() que des suppositions intelligentes sur le nombre de liens durs vers le répertoire courant rendent facultatifs.

  • La recherche au sein d'une chaîne de caractères est maintenant environ quatre fois plus rapide en moyenne.

  • Les boucles utilisant des variables Integer sont 5% plus rapides.

Tests de performances

Voici les résultats d'une série de six « benchmarks » consistant en six programmes écrits en Gambas, en Perl et en Python, dont les sources sont bien évidemment disponibles ici.

Les versions des différents langages utilisés sont :

  • Python 2.7.15rc1.
  • Perl 5.26.1.
  • Gambas 3.11.90 (version de développement du 2 novembre 2018).

Ils ont été exécutés sur un système Ubuntu 18.04 avec le noyau Linux 4.15.0-38-generic. Les temps d'exécution sont donnés en secondes.

┌ ───────── ┬ ───────── ┬ ───────── ┬ ─────────── ┬ ────────────────── ┐ │ PythonPerlGambasGambas + JITGambas + JIT │ │ │ │ │ │ (exécution uniquement) │ ┌ ─────────── ┼ ───────── ┼ ───────── ┼ ───────── ┼ ─────────── ┼ ────────────────── ┤ │ sort │ 3,93 │ 6,36 │ 4,76 │ 0,84 │ 0,25 │ │ polynom │ 9,94 │ 13,40 │ 8,04 │ 0,84 │ 0,75 │ │ primes │ 6,29 │ 7,65 │ 2,99 │ 0,77 │ 0,61 │ │ nbody │ 4,54 │ 4,55 │ 4,03 │ 0,68 │ 0,29 │ │ mandelbrot │ 5,34 │ 4,24 │ 3,06 │ 0,22 │ 0,10 │ │ string │ 8,94 │ 1,81 │ 1,41 │ 1,49 │ 1,40 │ └ ─────────── ┴ ───────── ┴ ───────── ┴ ───────── ┴ ─────────── ┴ ────────────────── ┘

Par rapport aux tests précédents, on peut constater qu'il y a eu un gros effort d'optimisation sur les versions récentes de Perl et de Python.

Malgré tout, Gambas reste en tête dans tous les tests, à part sort (il s'agit d'un tri à bulle sur un tableau d'entiers).

On peut constater aussi que l'intérêt du compilateur « à la volée » réside dans l'optimisation des calculs, et qu'il n'apporte aucun gain significatif dans le traitement des chaînes de caractères.

Conclusion

Beaucoup de travail a été abattu au cours de ces six dernières années, mais il reste toujours de nombreuses choses à faire :

  • Même si Wayland n'est toujours pas prêt (contrairement à ce qui avait été prédit dans la dernière dépêche), il faudrait peut-être commencer à penser à éventuellement l'envisager.

  • Puisque Gambas supporte les architectures ARM, ce serait bien d'arriver à le faire fonctionner sur Android. Rien n'a bougé depuis la dernière dépêche.

  • Il y a beaucoup de composants qui sont mal voire pas du tout documentés dans le wiki.

  • Le composant gb.web.form mériterait une réflexion poussée sur la meilleure méthode pour implémenter les applications web en Gambas.

  • Il serait sans doute intéressant d'implémenter une syntaxe différente du BASIC dans le compilateur.

Autrement, en dépit de quelques coups de gueule, associés en pratique à de nombreuses heures perdues à contourner les délires des autres les problèmes rencontrés :-), l'évolution du langage est plutôt satisfaisante.

Les gens qui l'utilisent semblent être rarement déçus. Espérons donc, si vous tentez le pas, que vous l'apprécierez vous aussi.

Bonne année à tous les utilisateurs et développeurs de logiciels libres !

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

🎦 Présentation de ShinobiCCTV Community Edition 👁️

lun, 31/12/2018 - 16:49

ShinobiCCTV Community Edition est un serveur de vidéos surveillance multiplateforme, dont les finitions se situent quelque part entre ZoneMinder et Kerberos.
Voyons ensemble ses particularités, ses avantages et inconvénients.

Sommaire Version communautaire de Shinobi (« Community Edition ») 📰 Introduction

ShinobiCCTV, Shinobi pour les intimes, serveur de vidéos surveillance à ses heures, naquit dans une région froide du Canada sous les martèlements de clavier de Moe Alam.
Ce projet serait l'alternative de référence à ZoneMinder (src). Ce qu'il pourrait devenir, en effet, compte tenu du peu de choix dans cet écosystème libre. « Shishi » est basé sur FFmpeg et NodeJS, utilisant massivement du JavaScript, un peu de Python ainsi qu'un chouia de Shell (src).
Le serveur est multi-plateforme (BSD, Linux, Mac, Windows) et compatible avec l'architecture ARM. Une image docker est aussi disponible.
En termes de fonctionnalités, ShinobiCCTV se situe quelque part entre ZoneMinder (utilisable en milieu pro mais vieillissant) et Kerberos.io.
Il n'y a pas de limite en nombre de caméras (autre que la puissance de calcul de vos machines et la bande passante de votre réseau).

Shinobi se divise en deux branches distinctes :

  1. "Shinobi Community Edition" => Licence Libre (gratuit)
  2. "Shinobi Pro" => OpenSource Non Libre (payant sauf exceptions)

Nous n'allons ici, bien entendu, nous intéresser uniquement à la version libre.
D'après cet article, la version libre de Shinobi ne reçoit pas de mise à jour régulière (historique) et n'accepte aucun pull request. S'il existe donc bien une version libre de Shinobi, elle n'est, à l'heure de la rédaction de cet article, hélas point communautaire.
Il faut néanmoins souligner que Moe, pour le moment l'unique développeur, est très réactif, à l'écoute et surtout qu'il utilise le logiciel qu'il code. (les tarifs du support)

🛠️ Fonctionnalités et capacités
  • Capable de récupérer des flux vidéos/audio des caméras via http, rtp/rtsp, ONVIF. https est supporté, mais uniquement avec des certificats X.509 valides ;
  • Enregistrement au format vidéo compatible avec l'accélération matérielle, avec trois modes d'enregistrement différents. (enregistrement continu, enregistrement lors d'événement avec ou sans buffer, enregistrement puis suppression si pas d'événement détecté) ;
  • Enregistrement possible de l'audio ;
  • Détection de mouvements et analyse de formes ;
  • Diversité de formats d'enregistrement. (liste) ;
  • Diversité dans les méthodes de streaming. Par contre le délai entre la réalité et ce que l'on voit sur l'écran peut être important (jusqu'à 8s avec HLS) suivant la méthode de streaming choisie ;
  • Gestion des stockages distants (Amazon S3, Webdav, Backblaze B2) ;
  • Possibilité de définir le stockage pour chaque caméra ;
  • Gestion d'une petite partie des commandes pour caméras (PTZ, IR) ;
  • Possibilité de permuter entre le mode streaming "normal" et le mode JPEG moins gourmand en bande-passante et avec une plus faible latence. (très utile pour déplacer les PTZ ou couper les flux audio) ;
  • Utilisation de bot pour les alertes (courriel, Discord) ;
  • Compatible LDAP ;
  • Ligne du temps, TimeLapse.
  • Lancer des scripts (par défaut en root) lors d'événements ;
  • Dispose d'un calendrier par caméra où sont indiqué les évènements. Ce calendrier n'est pas encore synchronisable ;
  • Le mode cluster de Shinobi est basé sur le système Maître-Esclave, permettant de répartir la charge mais pas d'avoir de la haute-disponibilité. Seul le serveur Maître s'occupe de la communication avec la base de données, si ce serveur plante tout plante ;
  • Sur la WEBUI vous pouvez adapter votre Dashboard grâce au glisser-déposer (Drag&Drop) sur les différents moniteurs de caméra.

⚖️ Quelques différences avec les autres
  1. ZM et Shinobi permettent tous deux de visualiser plusieurs moniteurs simultanément (pas kerberos.io). Par contre avec Shinobi vous ne pouvez choisir la taille de l'affichage.
  2. La ligne du temps de Shinobi se base sur des points fixes sans image de prévisualisation. Pour voir ce qu'il s'est déroulé entre deux points il faut visualiser la vidéo liée. Sur ZM il suffit de survoler la ligne du temps pour charger une image de l'instant T. Vous ne pourrez donc pas visualiser une journée entière en quelques secondes comme avec ZM. Impossible aussi de trouver un évènement si vous ne savez pas le dater.
  3. Sur Shinobi il faudra paramétrer les commandes PTZ de chaque caméra, sauf pour celles compatible ONVIF. Vous pouvez éventuellement re-copier la configuration d'une caméra mais, pour le moment, pas choisir dans une liste de pré-configuration comme avec ZM.
  4. Shinobi n'est pas capable de contrôler autant de commandes pour les PTZ, infrarouge etc que ZoneMinder.
  5. La session utilisateur n'est pas liée au navigateur mais à l'onglet. Sauf bug.
  6. La consommation de mémoire Swap est assez imposante, on ne peut définir son path.
  7. Shinobi utilise massivement root (pm2, ffmpeg, …).
  8. ZoneMinder et Kerberos.io utilisent tout deux un serveur web, Shinobi intègre le sien. Vous devrez donc allouer un port différent (par défaut 8080) et ne pourrez logger les infos ni les exploiter avec Piwik/Matamo sauf à passer par un Frontend/Proxy (exemple avec : HaProxy). NodeJS oblige, ShinobiCCTV nécessite de l'expérience en node.js/expressjs afin de pouvoir ajouter des webpages sur le serveur (par exemple un fichier healthcheck).
  9. Avec ZoneMinder le mode cluster nécessite de dispatcher manuellement les caméras sur plusieurs nœuds et, si vous pouvez visionner les enregistrements depuis n'importe quel nœud, le direct quant à lui est limité aux caméras gérées par le serveur. Shinobi semble lui répartir la charge entre ses nœuds-fils automatiquement en se basant sur l'utilisation du CPU. Le visionnage du direct ou des enregistrements se fait donc uniquement sur le serveur Maître. (src) Le système de ZoneMinder permet de faire un cluster répartis sur plusieurs réseaux, Shinobi semble capable d'accomplir aussi cette tâche.
  10. Le détecteur de mouvement est plus difficile à configurer sur Shinobi (sur ZM il se résume a l'activer et optionnellement adapter le niveau de "bruit").
  11. Kerberos utilise un mécanisme de mise à jours via la WEBUI (src). ZoneMinder est directement intégré au système. Shinobi quant à lui passe par git (src).
🔎 Shinobi est composé de : 📡 Au niveau logiciel
  • NodeJS - Moteur JavaScript basé sur Chromium - Nom des processus : node (tourne en root)
  • pm2 - Gestionnaire de processus pour NodeJS - Nom des processus : PM2 v3.2.2: God Daemon (tourne en root)
  • ffmpeg - Acquisition et traitement des flux vidéos et audio - Nom des processus : ffmpeg (tourne en root)
📡 Au niveau dépendance

Ces logiciels peuvent être installés sur la même machine ou dispatchés sur plusieurs.

  • MariaDB - Serveur de Base de Données - Nom des processus : mysqld (tourne sous l'utilisateur « mysql »)
  • Si accessible via WAN : Un frontend au choix (HaProxy, Apache2, etc)
  • Si sur plusieurs machines : un logiciel pour chiffrer les communications entre le(s) frontend(s) et le serveur maître ShinobiCCTV voir aussi entre ShinobiCCTV et le(s) serveur(s) de BDD.
📱 Au niveau de la WEBUI (interface web)
  • http://your_shinobi:8080 ⇒ Dashboard.
  • http://your_shinobi:8080/admin ⇒ Ici les utilisateurs créés par l'Administrateur pourront créer eux-mêmes des « sous-utilisateurs » (équivalent des modérateurs), permettant de partager l'accès à des caméras.
  • http://your_shinobi:8080/super ⇒ Gestion de l'administrateur, des comptes utilisateurs et de quelques paramètres de base.
Mise en place 🌱 Installation (de base)

Est expliqué comment faire une installation minimale de Shinobi Community Edition. Pour une installation complète, avec notamment https, voyez ce tutoriel « Ubuntu/Debian Installation complète de Shinobi Community Edition ».

Lancez l'installation du logiciel.

mv /tmp/ wget https://gitlab.com/Shinobi-Systems/Shinobi-Installer/raw/master/shinobi-install.sh sudo bash shinobi-install.sh

Créez la base de données et son utilisateur avec multiple accès. (Adaptez bien entendu le mot de passe ainsi que 10.8.%.% qui dans cet exemple autorise l'accès a n'importe quel client ayant une adresse IP comprise entre 10.8.0.0 et 10.8.255.255. Attention que localhost est différent de 127.0.0.1 et qu'autoriser l'un n'autorise pas automatiquement l'autre)

mysql -u root -p -e "GRANT ALL PRIVILEGES ON ccio.* TO 'shinobi'@'localhost' identified by 'my_super_password'; GRANT ALL PRIVILEGES ON ccio.* TO 'shinobi'@'10.8.%.%' identified by 'my_super_password'; FLUSH PRIVILEGES;

Éditez /home/Shinobi/conf.json afin d'y ajouter les informations concernant la base de données.

nano /home/Shinobi/conf.json

Initialisez la base de données

mysql -u shinobi -p shinobi < /home/Shinobi/sql/framework.sql mysql -u shinobi -p shinobi < /home/Shinobi/sql/tables.sql mysql -u shinobi -p shinobi < /home/Shinobi/sql/database.sql

Redémarrez le coeur de Shinobi.

pm2 --update-env restart all 🗑️ Désinstallation

Suppression de la base de données et de son utilisateur.

mysql -uroot -p -e "DROP DATABASE ccio;" mysql -uroot -p -e "DROP USER ‘shinobi’@’localhost’;" mysql -uroot -p -e "DROP USER ‘shinobi’@’10.8.%.%’;"

Suppression et purge des logiciels.

pm2 kill sudo npm uninstall pm2 -g sudo apt remove ffmpeg mariadb-server nodejs -y && sudo apt autoremove -y && sudo apt-get autoclean sudo rm -rf /usr/local/bin/npm /usr/local/share/man/man1/node* /usr/local/lib/dtrace/node.d ~/.npm ~/.node-gyp /opt/local/bin/node /opt/local/include/node /opt/local/lib/node_modules /usr/local/lib/node* /usr/local/include/node* /usr/local/bin/node* /home/Shinobi Bonus 🍔 Anecdotes 📊 Sondages

Un petit sondage, non représentatif, indique qu'Ubuntu semble être le serveur le plus utilisé.
Un autre sondage, pas plus représentatif, semble indiquer que la version la plus utilisée est Shinobi Pro.

🗨️ Avis personnels

Les avis du ou des auteurs sont subjectifs et ne doivent pas être pris comme règles.

☄️ Avis de Voxdemonix (2018)

Les technologies utilisées autant pour le core (NodeJS), la webui (HTML5), le support (Discord, tchat avec Moe intégré dans la documentation) que les fonctionnalités (discord bot, webdav, reconnaissance d'objet) sont rafraîchissantes. Aucun autre projet que j'ai testé ne discute de l'utilisation de réseau neuronaux.
Par contre voir tourner NodeJS/FFmpeg en root amène une certaine appréhension sur la sécurité. Pour infos, ffmpeg est suffisamment soumis à risque pour que le projet Nextcloud déconseille complètement son utilisation (afin d'éviter qu'un fichier corrompu ne passe dans le générateur de prévisualisation). FFmpeg qui récupère un flux réseau non sécurisé en root c'est assez dangereux. A tester si la version docker corrige ce problème important.
Il manque quelques fonctionnalités (pré-sélections de caméras voire scan à la ZoneMinder, ainsi que des boutons importants notamment au niveau des PTZ (ex: IR auto On/OFF), il n'y a pas de date sur les flux) et certaines fonctionnalités ne sont pas terribles (Ligne du temps qui nécessite de pouvoir dater un évènement pour le retrouver).
Le fait que ShinobiCCTV n'applique les mises à jours et les pull request que sur le projet proprio fait aussi peur, peut-être à tort, que le développeur ne ferme le projet dès qu'il aura des clients (époque #OpenWashing oblige). Sans compter que cela casse un peu l'envie de participer surtout au niveau code/bug report.
Quand aucun utilisateur n'est sur la WEBUI, la charge système machine reste sous 0.5. Par contre dès qu'un utilisateur se connecte sur la WEBUI et affiche des flux, la charge monte rapidement entre 1,5 et 2,5. Plusieurs utilisateurs m'ont indiqué utiliser/tester ShinobiCCTV sur Raspberry Pi 3 sans réel problème, il n'y a eu aucun retour quant aux ARM non 32/64bits par contre.
Bref, il y a encore du boulot pour que ShinobiCCTV devienne utilisable en milieu professionnel mais les fonctionnalités vitales sont déjà disponibles pour une utilisation familiale ou PME (si on rajoute une surcouche de sécurité).

♾️ Remerciements

Gros remerciement à la communauté et à Moe pour leur participation ! 💋

🎞️ Captures d'écran

🔗 Liens

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

Vision pour LILA et ZeMarmot

dim, 30/12/2018 - 11:32

Imaginez un studio de film, avec des artistes et techniciens qualifiés, qui travaillent sur des films ou des séries intéressantes… et qui les partagent sous une Licence Libre, pour être visibles par tous, partout (télé, cinéma, web…), partageables et réutilisables.

Imaginez maintenant que ce studio utilise essentiellement du Logiciel Libre (et de l’Open Hardware si disponible), qu’ils le corrigent, voire modifient et l’améliorent au besoin, aussi bien pour des logiciels finaux (tels que GIMP, Blender, Inkscape…), de bureau (tel GNOME), voire jusqu’au système d’exploitation (GNU/Linux) et tout le reste !

Voici donc mon rêve pour l’association à but non lucratif LILA, et pour le projet ZeMarmot (notre premier film, d’animation). C’est ce que je vise depuis le début, mais je me dis que ce n’était peut-être pas suffisamment clair.

Si vous aimez ce rêve, je vous encourage à nous aider en donnant par Patreon, Tipeee, Liberapay, ou tout autre moyen (donation directe bancaire, Paypal, etc.). Car comme toute association à but non lucratif, LILA et ZeMarmot vit par et pour vous !

Si vous voulez lire plus, je rajoute des détails ci-dessous !

Note: il s'agit d'une copie du même article publié sur notre journal de production.

Sommaire Mon emploi actuel

Au niveau personnel, j’ai récemment été engagé pour un an par le CNRS pour développer du code touchant à GIMP et G’Mic.

J’ai peu de salaire stable depuis quelques années, et je suis donc content que ce soit pour travailler sur GIMP (ce que j’ai fait bénévolement ou peu payé pendant six ans) !
Pour ajouter un peu de contexte, l’équipe de G’Mic m’avait d’abord proposé de travailler sur un plug-in Photoshop, ce que j’ai poliment refusé. Je n’ai rien contre Photoshop, mais ce n’est sûrement pas le boulot de mes rêves. Le projet fut alors retravaillé pour que je puisse continuer à travailler avec GIMP. Deux projets principaux ont été identifiés:

  • La gestion d’extension dans GIMP, ce dont j’avais déjà parlé (sans savoir à l’époque que je serais engagé pour cela), puisque cela aidera beaucoup G’Mic à être installé. J’en profiterai aussi pour améliorer les extensions de manière générale (ce que je prévoyais d’ailleurs depuis le début).
  • L’implémentation de leur algorithme de colorisation intelligente dans GIMP. Ce projet vint de ma propre initiative quand ils m’ont proposé de travailler ensemble, car cela rentrait très bien dans mes propres plans, et rendrait enfin leur super algo “utile” (l’interaction dans G’Mic est des plus douloureuses !). J’en reparlerai dans un article dédié. Voici pour donner une idée:
Et ZeMarmot dans tout ça ?

ZeMarmot est mon projet adoré (de même que celui d’Aryeom). Je le chéris et c’est là que je vois un futur (pas forcément ZeMarmot en soi, mais là où ça va mener). Ainsi même si j’ai une autre source de revenu temporaire, je voudrais réitérer que si vous aimez ce que j’ai fait jusque là, alors c’est à ZeMarmot qu’il faut donner. Financer ZeMarmot est le seul moyen de me permettre de continuer à améliorer GIMP sur le long terme.

Je vois cette année avec le CNRS comme une opportunité de permettre à ZeMarmot de s’épanouir. Car soyons clair, ce n’est pas encore le cas. Chaque année, nous répétons la routine de demander votre aide, et d’ailleurs on est très peu doué sur ce point (quand je vois notamment que les autres assos et fondations ont commencé leurs campagnes de dons depuis un mois !). On est des techniciens essentiellement (développeurs, animateurs, …), et on est vraiment nuls en marketing. Donc voici notre demande à la dernière seconde !

À ce jour, nous sommes financés à peine au dessus des 1000 € par mois, ce qui ne permet même pas de payer un salaire à temps plein au minimum légal en France. Ainsi en 2018, LILA a été capable d’engager Aryeom (réalisation/animation) et moi-même (développement) en moyenne 6 jours par mois. C’est peu ! Pourtant c’est ce qui nous a fait vivre.
On a estimé qu’il faut au moins 2100€ par mois pour une personne, et qu’en vrai nous avons besoin de 5000€ par personne pour un salaire raisonnable et des conditions de travail acceptables (nous avons vu d’ailleurs que la fondation Blender fait aussi cette même estimation), même si cela reste sous les prix du marché. Notre financement actuel est donc quatre fois trop petit pour un minimum déraisonnable et dix fois sous le minimum raisonnable. Sans même parler de la lointaine possibilité d’engager plus de gens. Triste, hein ?

LILA en deux mots

LILA est enregistrée officiellement en France comme une association à but non lucratif, loi 1901. Son numéro d’activité est celui d’une production de film, lui donnant un statut vraiment unique lui autorisant d’engager des gens pour la production de films libres, ce qui est fait depuis trois ans.

Le but de cette production n’est pas l’enrichissement d’actionnaires quelconques (il n’y en a pas). Nous voulons créer nos œuvres, les faire connaître et passer au projet suivant. Car nous aimons ce que nous faisons. C’est pour cela que ZeMarmot est sous licence Creative Commons by-sa, permettant à chacun de télécharger le film, le partager avec amis et famille, et même de le vendre ou de le modifier ! Sans blague ! Nous proposerons même chaque image source avec les calques !

En outre LILA paye de vrais salaires pour chaque participant. En effet, nous ne considérons pas que “Art Libre” signifie “œuvre au rabais” ou même “amateurisme”. C’est un projet sympa ? Oui. Mais c’est aussi professionnel.

Si LILA était soudainement financé au dessus de toutes nos espérances, cela ne se transformerait pas en des salaires indécents. Simplement LILA pourrait embaucher plus de personnes pour réaliser des superbes films et logiciels plus rapidement et ainsi rendre le monde de l’Art plus agréable. C’est ça être une association à but non lucratif !

Et le logiciel Libre alors ?

Là, c’est l’autre aspect du studio : nous utilisons uniquement des logiciels libres ! Non seulement cela, mais aussi nous en développons ! Je ne parle pas de libérer un script interne, mal codé et utilisé par trois personnes dans le monde tous les 36 du mois. Nous faisons notamment partie de l’équipe de développement de GIMP ! Ces dernières années, un quart des commits de GIMP sont les nôtres (ce qui peut être aisément vérifié, en particulier les commits à mon nom “Jehan”, de même que ceux d’Aryeom et Lionel N.) Je suis aussi à l’origine de la relaxe de notre politique de sortie pour que nous sortions davantage de versions de GIMP avec de nouvelles fonctionnalités (cela fait des années que je le demandais et ce fut finalement acté depuis GIMP 2.10.0 !). Il me semble évident que LILA a eu une contribution positive et importante pour GIMP.

Bien sûr GIMP est donc notre projet logiciel principal, ce qui n’a pas empêché divers patches ici ou là dans d’autres logiciels, parfois majeurs ! Sans compter nos rapports de bugs très réguliers quand nous n’avons pas le temps de corriger nous-même… nous sommes aussi des utilisateurs importants de tablettes graphiques, avons des contacts avec des développeurs de Wacom et Red Hat (on est d’ailleurs désolés, on sait qu’on peut être un peu chiant parfois avec nos bugs ! 😛). Et ainsi de suite. Ainsi la seule chose nous empêchant d’en faire plus est le temps. On a besoin de plus de mains, ce qui ne peut être amélioré que si notre financement nous permet enfin d’engager de nouveaux développeurs !

Aussi soyons clairs : ce n’est pas un truc temporaire. Nous croyons tout simplement aux Logiciels Libres. Nous pensons que c’est la chose à faire, que chacun doit avoir accès aux meilleurs logiciels et que c’est ainsi que peuvent être faits les meilleurs logiciels. Je le disais d’ailleurs : je développe environ un quart du code de GIMP. Cela signifie que trois quarts ne sont pas réalisés par moi ! Et c’est sans parler de GEGL (le moteur graphique de GIMP). En d’autres termes, je ne pourrais pas en faire autant seul. J’adore travailler avec certains autres des développeurs les plus brillants que j’ai eu l’occasion de rencontrer. En plus, les autres développeurs de GIMP sont également sympas et agréables. Que demander de d'autre ? C’est ça, le logiciel libre.
C’est ainsi que l’utilisation et la contribution au Logiciel Libre est dans les statuts de notre studio, notre “contrat en tant que studio à but non lucratif”, et cela ne disparaîtra donc pas.

2018 en revue

Une revue rapide des choses que j’ai menées à bien en 2018 :

  • 633 commits, soit près de deux commits par jour en moyenne, dans la branche master de GIMP (sans compter ce qui est dans les branches de fonctionnalités, mon travail en cours), plus mes patches dans divers projets que nous utilisons (GEGL, glib, GTK+, libwebp, Appstream, …).
  • Aider le projet MyPaint pour préparer une nouvelle sortie de libmypaint version un (espérons début 2019), et la création du paquet de données mypaint-brushes — maintenant un paquet officiel de MyPaint !
  • La création et maintenance continue du flatpak de GIMP sur flathub (d’après ce qu’on nous a dit, le logiciel le plus téléchargé de flathub !).
  • La sauvegarde automatique des images en cas de plantage de GIMP.
  • Outils de déboguage (traces d’exécution, infos de plateforme, …).
  • Prise en charge basique de HiDPI sur GIMP 2.10 (et plus à venir pour le futur GIMP 3).
  • Travail en cours pour la gestion d’extension dans GIMP.
  • Maintenance de diverses données (icônes, brosses, appdata, etc.) de GIMP.
  • Travail sur les tablettes et périphériques d’entrée.
  • Mentor pour un stagiaire FSF (amélioration de la prise en charge de JPEG 2000).
  • Correction de la plupart des cas d’enfer du DLL des plug-ins sous Windows (problème majeur il y a encore peu !).
  • Revue et amélioration de nombreuses fonctionnalités (redressement d’image dans l’outil de Mesure, libheif, libwebp, plug-in de capture d’écran, texte vertical dans l’outil Texte, et bien plus !).
  • L’option de colorisation intelligence dans l’outil de remplissage.

Et probablement plein de choses que j’oublie ! J’aide aussi à la maintenance du site et à l’écriture d’article sur gimp.org (63 commits cette année). Et tout cela sans compter les patches sans rapport avec GIMP que je fais aussi (par exemple pour les méthodes d’entrée en Coréen) ou les nombreux rapports de bugs que nous écrivons ou aidons à corriger (notamment en étant les premiers à installer Linux sur une Wacom MobileStudio, ou du moins les premiers à en parler, des bugs furent corrigés jusque dans le noyau, et Wayland).

Quant à Aryeom, en 2018, elle a beaucoup travaillé sur ZeMarmot bien sûr (l’animation requiert énormément de boulot ; un jour, on devra peut-être donner plus d’information sur le sujet), nous rapprochant davantage de la sortie du pilote (à ce sujet, nous avons récemment créé un compte Instagram où Aryeom poste régulièrement des images et vidéos courtes de son travail en cours, pour qui est intéressé !). Elle a aussi participé à des projets tiers (nous rappelons que ZeMarmot ne peut financer que quelques jours par mois pour l’instant !), tels qu’un jeu de société interne pour l’association “Petits Frères des Pauvres“, une vidéo marketing pour le logiciel libre Peertube, des designs de pin’s pour la Free Software Foundation. Elle a aussi donné quelques cours de peinture numérique et retouche avec GIMP à l’université.

Bien sûr elle préférerait passer tout son temps uniquement sur ZeMarmot. Mais encore une fois… on a besoin de vous pour permettre cela !

Le Futur

Comment je vois notre futur : dans quelques années, on pourra payer plusieurs artistes (réalisatrice, animateurs, artistes peintres, musiciens, …). LILA sera enfin un studio, certes petit, mais productif.

Et bien sûr cela signifie aussi plusieurs développeurs, donc plus de contrôle sur nos outils de production libres. J’ai tellement de rêves ! Enfin un éditeur vidéo stable et puissant sans être tordu (en contribuant au Blender VSE, à Kdenlive ou d’autres projets) ? Et quand aurons nous des outils de compositing professionnels maintenus (2018 fut un peu triste) ? Sans parler de communication entre outils pour éditer des XCF dans GIMP, voir les changements live dans Blender, etc. ? Tant d’espoirs ! Tant de rêves à réaliser si on avait le financement !

Les rêves peuvent se réaliser si vous aidez !

Que pouvez-vous y faire ? Vous pouvez aider ce studio à devenir viable. Me faire engager par le CNRS est cool pour moi mais un peu triste pour le projet. Cela signifie notamment un manque d'indépendance. Sans compter que c’est une situation encore très précaire et temporaire. Ce n’est pas une situation stable, ni de long terme.

Si nous atteignions 5000€ par mois en 2019, cela serait un premier pas énorme pour le projet et la preuve de viabilité du rêve de studio libre.

Nous aiderez-vous à créer un Studio d’Animation Libre ? Le graphisme professionnel 2D Libre est à notre porte. Il lui faut juste un peu d’aide pour lui permettre de passer le pas de porte ! 🙂

Passez de bonnes fêtes de fin d’année ! Et joyeuse nouvelle année !

Et pour voir notre petite vidéo animée marrante de fin d'année, c'est par ici !

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

Agenda du Libre pour la semaine 1 de l'année 2019

sam, 29/12/2018 - 21:45

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

Sommaire [FR Paris] Atelier Hebdomadaire de Contribution au Libre - Le mardi 1 janvier 2019 de 10h00 à 19h00.

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

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

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

[FR Caen] Permanence artifaille - Le mercredi 2 janvier 2019 de 16h00 à 19h00.

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

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

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

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

[FR Beauvais] Atelier hebdomadaire de partage de connaissances autour des logiciels libres - Le mercredi 2 janvier 2019 de 18h00 à 20h00.

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

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

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

[FR Toulouse] Rencontres Tetalab - Le mercredi 2 janvier 2019 de 20h30 à 23h30.

Rencontre hebdomadaire des hackers et artistes libristes Toulousains.

Ouvert au public tous les mercredi soir.

Venez nombreux.

[FR Montpellier] Atel’libre PAO Gimp, Inkscape, Scribus, Krita - Le jeudi 3 janvier 2019 de 17h00 à 19h00.

La publication assistée par ordinateur se fait à l’aide de logiciels spécialisés, appelés logiciels de mise en page ou logiciels de PAO, semblables à des logiciels de traitement de texte ordinaires, mais où un accent particulier a été mis sur la disposition des textes et des images sur une page. Le document à imprimer est affiché à l’écran de l’ordinateur exactement tel qu’il sera sur le papier, avec la possibilité de changer la typographie et de voir immédiatement le résultat.

Dans cet atelier vous pourrez aborder des logiciels tels que Gimp, Inkscape, Scribus, Krita… La Publication Assistée par Ordinateur concerne la création des supports de communication. Plaquettes, affiches, cartes de visites, kakemonos et autres outils sont le résultat de ce que vous imaginez, mis en forme grâce à une suite de logiciels.

Ces rencontres du groupe Blender ont lieu le premier jeudi de chaque mois de 17h00 à 19h00.

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

Cet événement vous est proposé par le partenariat qui lie Montpellier Méditerranée Métropole, la Médiathèque Federico Fellini, Les Fées Spéciales et Montpel’libre.

[FR Poitiers] Jeudi du Libre - Le jeudi 3 janvier 2019 de 17h30 à 20h30.

Chaque premier jeudi du mois, les membres de l’APP3L se réunissent au Centre Régional d’Information Jeunesse (CRIJ).

Ils vous invitent à les rejoindre, de 17h30 à 20h30, afin d’échanger et d’en apprendre plus à propos des logiciels libres.

Si vous le désirez, vous pouvez venir avec votre ordinateur portable ou fixe (nous prêterons écrans, claviers et souris).

Cette permanence est l’occasion pour chacun de

  • rencontrer d'autres utilisateurs
  • de discuter ou de s’informer
  • de trouver de l’aide (vous pouvez amener votre machine);
  • ou tout simplement de découvrir des alternatives aux logiciels et services privateurs.

Vous pourrez aussi échanger et vous faire aider dans votre contribution aux communs numériques (Wikipédia, OpenStreetMap), la protection de votre vie privée et les services en ligne respectueux de votre intimité.

Entrée Libre. Tout Public.

Accès 64 rue Léon Gambetta 86000 Poitiers

[FR Lyon] Permanence Wiktionnaire - Le jeudi 3 janvier 2019 de 18h00 à 23h00.

Découvrez le Wiktionnaire, dictionnaire collaboratif en ligne, et apprenez à diffuser vos connaissances sur les mots

Que vous soyez amoureux de votre langue maternelle ou apprenants de langues étrangères, le Wiktionnaire vous permet de découvrir et de partager vos savoirs.

Venez pratiquer et apprendre grâce aux connaissances des participants et aux ressources du KoToPo

[FR Rennes] Apéro du Libre - Le jeudi 3 janvier 2019 de 19h00 à 22h00.

L'association Actux vous donne rendez-vous pour un nouvel Apéro du Libre, jeudi 3 janvier 2019 à partir de 19h, au Papier Timbré, 39 rue de Dinan à Rennes (au croisement de la rue d'Échange).

Les sont des rencontres conviviales autour d'un verre, pour discuter, échanger et parfois troller entre utilisateurs et curieux de logiciels et culture.

Pour rappel, cet événement a lieu habituellement tous les premiers jeudi du mois, même heure, même endroit et est ouvert à tous !

Entrée Libre.

Plan d'accès http://actux.eu.org/Lieux/PapierTimbre

[FR Paris] Soirée de Contribution au Libre - Le jeudi 3 janvier 2019 de 19h30 à 22h00.

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

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

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

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

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

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

Regazouillez sur Twitter - Wiki des soirées

Programme non exhaustif

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

tout nouveau projet est le bienvenu.

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

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

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

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

[FR Paris] Soirée de Contribution au Libre - Le jeudi 3 janvier 2019 de 19h30 à 22h00.

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

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

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

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

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

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

Regazouillez sur Twitter - Wiki des soirées

Programme non exhaustif

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

tout nouveau projet est le bienvenu.

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

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

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

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

[BE Grivegnée] Présentation monnaie libre - Le jeudi 3 janvier 2019 de 19h30 à 20h00.

Courte présentation de la monnaie libre dans le cadre de la réunion mensuelle.

Possibilité de poursuivre les explications et inscriptions éventuelles en marge de la réunion

Bienvenue à tous  - entrée libre-)

[BE Grivegnée] Linux Meeting Party - Le jeudi 3 janvier 2019 de 19h30 à 22h30.

Notre "Linux Meeting Party" (table de conversation informelle) a lieu tous les.

Nos prochaines rencontres se tiendront dans un local du "Service de proximité" de Grivegnée, Av. Albert 1er, 5, à Grivegnée-bas. C'est à deux pas de la rue Belvaux (pour l'accès en bus) et un vaste parking est disponible carte interactive d'accès

Venez quand vous voulez entre 19h30 et 22h30 papoter Linux et Logiciels Libres dans la bonne humeur-)

[FR Caen] Permanence artifaille - Le vendredi 4 janvier 2019 de 16h00 à 19h00.

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

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

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

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

[FR Milly-sur-Thérain] Atelier mensuel de sensibilisation et de partage de connaissances autour des logiciels libres - Le vendredi 4 janvier 2019 de 17h00 à 19h00.

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

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

L'atelier aura lieu dans les locaux de la mairie.

[FR Aix-en-Provence] Samedi Libre - Le samedi 5 janvier 2019 de 10h00 à 18h00.

PROGRAMME

10h00 - 12h30 Préparation des ateliers 2019

12h30 - 13h30 Déjeuner en commun

13h30 - 18h00 Interventions sur rendez-vous et démonstrations

INFORMATIONS GÉNÉRALES

Ces Samedis Libres sont organisés par l'Axul en collaboration avec plusieurs associations de logiciels libres des Bouches-du-Rhône.

Ils proposent des présentations générales et une aide technique pour le dépannage et la mise à jour d'ordinateurs avec des logiciels libres. Ils présentent aussi des démonstrations de matériels libres.

Des informations sont disponibles sur la Culture Libre (OpenStreetMap, Wikipedia…).

PRÉSENTATIONS POSSIBLES

Présentation d'un Fairphone, un téléphone libre et éthique

Présentation de livres et de sites Internet consacrés au Libre

Présentation du nano-ordinateur micro:bit conçu pour rendre l’enseignement et l’apprentissage facile et amusant.

Présentation du nano-ordinateur PyBoard co-développé avec le langage MicroPython

Présentations liées aux nouveaux programmes scolaires sur le codage

  • Présentations de Pygame, Python, Scratch et Snap.
  • Présentations de modèles éducatifs libres écrits en HTML5 pour PC ou tablettes quel que soit le système d'exploitation exemple du site PhET.
  • Présentation du projet 1, 2, 3… codez: Enseigner l'informatique à l'école et au collège (Fondation La main à la pâte).
  • Présentations d'autres logiciels éducatifs et/ou scientifiques…

Autres présentations

  • Comparaison des environnements Cinnamon, GNOME, KDE, LXDE et Xfce installés avec la même version d'Ubuntu.
  • Distribution Emmabuntüs pour la rénovation d'ordinateurs anciens.
  • Distribution PrimTux 2 pour les élèves de l'école primaire.
  • Distribution Pure OS associée au projet Librem pour des ordinateurs avec des matériels et des logiciels libres.
  • Distribution Ubuntu 18.04.
  • Distribution Ubuntu Touch sur un téléphone mobile.
  • Distributions Linux installées sur des clefs USB insérées dans des ordinateurs Linux, Windows 7 ou Windows 10.
  • Cohabitation Linux - Windows 10 le cas d'Ubuntu 64 bits.
  • Évolution du projet pédagogique OLPC (One Laptop per Child) : ordinateur XO-4, tablette OLPC partiellement libérée avec F-Droid et différentes machines avec la plate-forme pédagogique Sugarizer.
  • Présentation d'Inkscape, logiciel de dessin vectoriel professionnel pour Windows, Mac OS X et GNU/Linux
  • Présentation de logiciels scientifiques libres (SageMath…)

NB Certaines démonstrations pédagogiques sont en libre service. Les autres démonstrations seront normalement possibles toute la journée elles seront lancées en fonction des souhaits des visiteurs et des disponibilités des spécialistes.

Adresse Centre Social et Culturel des Amandiers, 8 allée des Amandiers, Jas-de-Bouffan (cliquer sur ce dernier lien pour avoir un plan détaillé).

Ces samedis libres et gratuits sont ouverts à toutes et à tous, débutant(e)s ou expert(e)s GNU/Linux, membres ou non d'associations du Libre. Les locaux sont au rez-de chaussée et accessibles par tous.

Entrée Libre..

Prochain Samedi Libre

[FR Paris] Premier Samedi du Libre - Le samedi 5 janvier 2019 de 14h00 à 18h00.

Chaque premier samedi de chaque mois, de 14h00 à 18h00, des bénévoles passionnés de logiciels libres se retrouvent au Carrefour Numérique² de la Cité des Sciences, pour une install-party de distributions ou, ainsi que des ateliers et (parfois) des conférences.

Venez aider ou vous faire aider à installer et paramétrer des logiciels libres et toute distribution GNU/Linux ou Android avec les associations d'utilisateurs de Fedora, Mageia, Ubuntu, Debian, Trisquel… (pour GNU/Linux) ; Replicant, LineageOS, f-droid (pour Android), sur netbook, portable, tour, PC/Mac (pour GNU/Linux), smartphone ou tablette (pour Android), éventuellement à côté de votre système actuel (pour GNU/Linux).

N'hésitez pas non plus à passer si vous rencontrez des difficultés avec des périphériques, matériels, logiciels libres sous ou Android.

  • 12h30-13h45 déjeuner à la pizzeria Le Verona, 25 avenue Corentin Cariou
  • 14h00-18h00 salle Classe Numérique install party GNU/Linux et Android, toutes distros
  • 14h00-18h00 salle Atelier atelier Blender3D du BUG (Blender3D Users Group)
  • 14h00-18h00 salle LivingLab atelier Brique Internet/auto-hébergement avec franciliens.net
  • 14h00-18h00 salle Studio wikipermanence de l'association Wikimedia
  • et après 18h, on continue à échanger et discuter (généralement dans un bar avenue Corentin Cariou)

Pour les salles, voir le plan du Carrefour Numérique.

Nous avons besoin de volontaires pour l'accueil et les installations. Il est utile, mais pas obligatoire, de vous inscrire comme parrainé, parrain, ou visiteur sur le site premier-samedi.org en décrivant votre matériel et vos attentes.

Parrainé·e·s

  • Pour l'installation d'une distribution :

    • venez de préférence dès le début (vers 14h-14h30)
    • sauvegardez sur disque externe, clé usb ou DVD vos fichiers importants
    • supprimez les fichiers et logiciels superflus
    • faites un nettoyage de disque et une défragmentation (utilitaires Windows)
    • n'oubliez pas votre chargeur, vos câbles etc.
    • prenez connaissance de la présentation, du code de conduite, du document présentant les liens et infos utiles et de la décharge
    • apportez un disque dur externe ou une clé usb ou un dvd
  • Pour l'installation d'une distribution Android

    • venez de préférence dès le début (vers 14h-14h30)
    • sauvegardez les données des applications (SMS, contacts, etc) car elles seront effacées durant l'installation, et si possible les fichiers/dossiers personnels (musique, films, pdf, etc) afin de ne pas risquer de les perdre en cas d'erreur technique
    • Si possible, essayez de vérifier s'il y a des distributions compatibles avec votre appareil
    • https://wiki.lineageos.org/devices/: liste des appareils compatibles avec LineageOS
    • https://redmine.replicant.us/projects/replicant/wiki/ReplicantStatus#Replicant-60: liste des appareils compatibles avec Replicant, ainsi que la liste des fonctionnalités (GPS, camera, etc) prises en charge
  • Dans tous les cas:

    • demandez l'autorisation de prendre des photos si vous souhaitez en prendre
    • n'oubliez pas que nous sommes des bénévoles, pas un S.A.V. ;-)

Parrains et marraines

  • ISOs de nombreuses distros installables par serveur local Parinux et Raspberry-Pi 3
  • apportez une clé usb 3 ou un dvd, des ISOs, de vos distros favorites
  • demandez si l'installé·e a bien sauvegardé ses fichiers
  • demandez si l'installé·e a bien nettoyé, défragmenté, CHKDSKé
  • si possible, autonomisez l'installé-e, expliquez, laissez-lui le clavier
  • prenez connaissance de la présentation, du code de conduite, du document présentant les liens et infos utiles et de la décharge
  • évitez de commencer une installation complète après 16h00
  • préférez une réinstallation propre à une longue mise à jour
  • terminez ce que vous avez commencé ou passez le relais
  • incitez l'installé·e à se rapprocher de l'association dédiée à sa distribution
  • si possible, installez et lancez l'utilitaire Bleachbit.

Entrée libre et gratuite, pour tout public.

Transports

[FR Vire] Atelier à thème des réseaux sociaux libres - Le samedi 5 janvier 2019 de 16h00 à 19h00.

Venez assister à l'atelier à thème organisé tous les mois par l'association.

Venez découvrir les réseaux sociaux libre décentralisés Mastodon, Diaspora et le Fédiverse.

Vous pouvez aussi soumettre vos idées à partir du menu "Contact" du site.

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

darktable 2.6.0

jeu, 27/12/2018 - 08:13

darktable est un logiciel de retouche d'images spécialisé dans le traitement de photos « raw », c’est-à-dire des données brutes du capteur de l'appareil. Il a la particularité d'être non-destructif c’est-à-dire qu'il ne modifie jamais les fichiers sur lesquels il travaille : on gère un ensemble de transformations à appliquer au fichier raw, et darktable permet d'exporter le résultat dans les formats d'images classiques.

Comme le veut la tradition, une nouvelle version de darktable est sortie pour Noël : la 2.6.0. 2018 a été une année de renouveau pour darktable, avec de nombreuses fonctionnalités majeures réalisées par de récents contributeurs.

Pour connaitre les nouveautés…

Sommaire

Parmi les principales nouveautés :

  • Un nouveau module retouche, similaire au module de correction de taches, avec copie intelligente (outil de correction) et la possibilité d'agir sur chaque niveau de détails individuellement.

  • Un nouveau module filmique, capable de gérer la plupart des aspects de tonalité d'une image en un seul module, tout en préservant la couleur.

  • Une refonte complète du module de balance des couleurs, qui peut être vu comme une variante plus orientée couleurs que le module niveaux. Grâce à de nouvelles options de sélection de couleurs, ce module permet d'effectuer la plupart des ajustements automatiquement.

  • La possibilité de guider le floutage d'un masque de fusion, afin de sélectionner précisément un objet avec le minimum d'effort.

Tout ceci vous est ici dévoilé, et bien d'autres nouveautés, dans la suite de cette dépêche.

Comme toujours, le format de base de données est changé avec cette version majeure, vous ne pourrez pas relancer les versions antérieures sur vos photos après avoir lancé darktable 2.6. Pensez à faire une sauvegarde de votre base de données (répertoire ~/.config/darktable/) avant la mise à jour.

Fonctionnalités principales Un nouveau module : retouche

Même si darktable se focalise principalement sur le développement RAW, les dernières versions ont introduit des fonctionnalités habituellement réservées aux éditeurs orientés pixels tel que GIMP, comme le module liquéfier.
Une étape importante de plus dans cette direction est faite avec ce nouveau module retouche, qui remplace essentiellement le module correction des taches, avec séparation des fréquences pour une retouche fine.

Améliorations comparées au module correction des taches

Le module a bien plus d'options que le module correction des taches, mais tout ce que vous pouviez faire avec le précédent reste disponible dans le module retouche.

Comme avec correction des taches, vous sélectionnez une forme (cercle, ellipse, chemin, ou brosse ; cette dernière n'existait pas dans correction des taches) et vous cliquez simplement sur la partie de l'image que vous souhaitez effacer. Le module va copier une autre partie de l'image pour la masquer. Glissez au lieu de cliquer pour choisir la source à cloner, ou ajustez les contrôles ensuite.

De nombreux détails vont vous faciliter la vie :

Outil de correction, de meilleurs résultats en moins d'efforts

Par défaut, la copie utilise un algorithme de correction (heal en anglais) emprunté de l'outil correcteur de GIMP, qui adapte la source au contexte de l'emplacement copié. Vous n'avez pas besoin de copier exactement la bonne partie de l'image. Prenons un exemple classique, un petit défaut dans un ciel pas complètement uniforme :

Une mauvaise tentative pour corriger cela avec l'outil de copie donnerait :

Le morceau de ciel copié pour masquer le défaut est un peu plus sombre que l'endroit où il a été copié. Ce n'est pas évident tant que les outils de contrôle sont affichés sur l'image, mais l'image finale est vraiment mauvaise :

La même retouche avec le nouvel outil de correction [1] donne ceci :

Cette fois, l'image finale est impossible à distinguer d'un ciel sans défaut :

Même en clonant des parties de l'image de couleurs complètement différentes, l'outil de correction réagit étonnamment bien. Poussons le module un peu :

Le morceau blanc est copié vers le t-shirt bleu, le t-shirt bleu vers le rouge, et le rouge vers le blanc. Chaque fois, le contraste local est conservé, mais la couleur générale et la luminance du morceau sont adaptés pour s'ajuster à la destination.

L'outil de copie basique [2] est toujours disponible pour les rares situations où vous en auriez besoin.

Remplir et flouter, quand vous n'avez rien à copier

En plus des outils de copie et de correction (qui fonctionnent seulement quand vous avez une partie de l'image à dupliquer sur celle à effacer), le module retouche fournit un outil de remplissage [3] (remplir une forme avec une couleur) et un outil de flou [4] (appliquer un flou pour adoucir une partie de l'image). Ces outils sont particulièrement utiles pour l'édition par séparation de fréquence (voir plus bas).

Une activation, plusieurs corrections : ajout continu

Les outils peuvent être activés en une fois pour plusieurs corrections. Utilisez simplement la combinaison Ctrl-clic sur l'un des outils cercle, ligne, ellipse ou chemin (au lieu d'un simple clic), et l'outil restera actif jusqu'à ce que vous le désactiviez explicitement.
Ceci est très pratique lorsque vous avez à corriger plusieurs endroits de la même image, comparé à la version précédente qui vous obligeait à re-cliquer sur le bouton de l'outil pour chaque correction.

Visualisation de la source de correction

Pour les outils de copie et de correction, chaque correction consiste à sélectionner une source et une destination. Un simple clic permet de définir la destination et, par défaut, darktable sélectionne une zone arbitraire pour la source. Une autre option est de définir la source et la destination par un glisser-déposer avec le curseur de la destination vers la source.

Le module retouche introduit un mécanisme plus avancé :

  • En déplaçant le curseur sur l'image, la destination à corriger est marquée par une forme, alors que la source est marquée par une petite croix :

  • Pour sélectionner une source, utiliser Maj-clic sur l'image. La croix est alors placée sur l'emplacement du curseur et ne bougera plus jusqu'à ce que vous sélectionnez la destination, via un simple clic. Ceci est particulièrement intéressant combiné à une activation permanente de l'outil mentionné ci-dessus : plusieurs corrections sont ainsi possibles sur l'image, la source restant à des coordonnées relatives à la destination.

  • Une variante : utiliser Ctrl-Maj-Clic au-lieu de Maj-Clic. Ceci définira également l'emplacement de la source, mais cette fois, celle-ci restera fixe, selon des coordonnées absolues et non plus relatives à la destination à corriger.

Édition par séparation de fréquence

Une difficulté classique de la retouche photo, typiquement pour le portrait, est qu'on souhaite souvent masquer certaines taches, et parfois réduire le contraste local afin de rendre la peau plus lisse, tout en conservant sa texture. Un effacement brutal rendrait la peau trop lisse et donnera à la photo, au mieux, un aspect « excessivement post-traité ».

Prenons une image comme exemple (reprise du défi pixls.us PlayRaw « Hillbilly portrait ») :

Une technique commune pour ce type de retouche est de séparer l'image en plusieurs images correspondant à plusieurs niveaux de détails, et de les combiner ensemble. C'est ce que permet le greffon Décomposer en ondelettes de GIMP (article en anglais) par exemple.

Après séparation, cela produit une première image floue aux détails grossiers, et une ou plusieurs images contenant seulement les détails.

Dans notre exemple, nous obtenons les niveaux de détails :

Et l'image dite « résiduelle », c'est-à-dire l'image où tous les autres niveaux de détails ont été enlevés :

Ce type de transformation est utilisé en interne par le module égaliseur, qui permet d'augmenter ou diminuer l'importance de chaque niveau de détails de l'image. Alors que égaliseur travaille globalement sur l'image, retouche permet de sélectionner le niveau de détails et la partie de l'image sur laquelle vous souhaitez travailler.

Dans le module retouche, cela correspond à la partie décomposition en ondelettes de l'interface :

Cette partie montre un rectangle par échelle de décomposition (du grain le plus fin à gauche au grain le plus grossier à droite). Le rectangle noir à gauche correspond à l'image entière, et le blanc à droite à l'image résiduelle. Par défaut, darktable montre toujours l'image finale, mais vous pouvez visualiser une échelle de détails et l'image résiduelle en cliquant sur le bouton affiche une seule échelle de décomposition [5].

L'image actuellement sélectionnée apparaît avec un rectangle rouge. Déplacez le curseur du bas pour modifier le nombre d'échelles de détails à utiliser. Selon le niveau de zoom, certains détails d'échelle peuvent être plus fins que le permet la résolution de l'écran, donc inutilisables. La ligne grise sur le dessus des échelles montre lesquelles sont visibles au niveau de zoom actuel.

En visualisant l'échelle de détails, le contraste peut être trop faible ou trop fort, le module propose donc un ajustement de niveaux (qui s'applique seulement sur la prévisualisation à l'écran, et n'a pas d'impact sur l'image finale) :

Chaque type d'outil présenté ci-dessus (outil de correction, outil de copie, outil de remplissage ou outil de flou) est utilisable sur chacune de ces échelles. Voyez-les comme des calques obtenus d'une image source, et recomposés ensemble, après retouche, afin d'obtenir l'image finale. C'est là où les outils de remplissage et de flou prennent tout leur sens : l'outil de remplissage est par défaut un mode d'effacement lorsque la couleur choisie est le noir, ce qui correspond à supprimer les détails lorsqu'il est utilisé sur les échelles de détails. Il est aussi possible de sélectionner une couleur et de remplir avec celle-ci (particulièrement utile sur l'échelle de l'image résiduelle). Utiliser l'outil de flou directement sur l'image, aboutit à des résultats de post-traitement clairement visibles, mais l'utiliser de manière sélective sur les échelles permet d'aboutir à des effets plus subtils.

Exemple 1: réduction de tâche au lieu de suppression

Concentrons-nous sur le bouton situé sous la branche des lunettes. Si nous souhaitons le supprimer complètement, il est facile de le faire avec l'outil de correction. Maintenant, que se passe-t-il si nous souhaitons le conserver, et seulement le réduire, pour qu'il n'attire plus l'attention ? Nous pouvons simplement le supprimer depuis l'échelle de détails grossiers (échelle 6 dans notre exemple).
Le bouton n'est pas visible sur l'image résiduelle, le supprimer depuis l'échelle de détails est donc suffisant. L'outil de correction permet de le faire proprement. Mais en agissant avec l'échelle de détails, l'outil de remplissage et l'outil de flou peuvent aussi donner de bons résultats. Voici ci-dessous le résultat sur l'échelle 6 (avant à gauche, après à droite).

L'image finale sera transformée comme suit :

Désormais, nous pouvons décider que la correction faite sur l'échelle 6 peut aussi s'appliquer à l'échelle 5. Nous pouvons faire la même chose manuellement, mais nous pouvons également utiliser le curseur du haut, intitulé début de fusion, afin de reproduire automatiquement les formes corrigées sur plusieurs échelles. Toutes les formes créées à droite de ce curseur seront reproduites sur toutes les échelles au-delà de ce curseur de fusion (sauf si le curseur est positionné complètement à gauche (à 0), ce qui signifie que la fusion est désactivée).

Par exemple, en positionnant le curseur à 5, nous appliquons la correction sur les échelles 5 et 6, et obtenons ceci :

Si nous déplaçons le curseur plus à gauche, le bouton disparaît progressivement. Selon ce même principe, nous pouvons effacer les marques sur la peau tout en préservant les poils de la barbe :

(Juste une correction sur l'échelle 7, propagée ensuite jusqu'à l'échelle 5 en utilisant le curseur de fusion)

Exemple 2 : jouer avec la texture de peau

Si vous voulez changer la texture de peau sur la joue, vous pouvez appliquer un flou sur une forme de ce type :

et obtenez le résultat avant/après suivant :

De toute évidence, ce type de retouche doit être pratiqué avec une grande prudence : si la correction est poussée trop loin, cela produira un rendu trop artificiel.

En cas de doute, vous pouvez toujours revenir en arrière sur votre retouche et utiliser un mode de fusion avec une opacité inférieure à 100%, ou modifier l'opacité ou le rayon de flou de chaque forme individuellement.

Exemple 3 : s'amuser avec l'image résiduelle

Juste pour le plaisir (ne reproduisez pas ça chez vous, ou attendez-vous à des images horribles !), nous pouvons obtenir un effet « tatouage » en utilisant l'outil de copie sur l'image résiduelle :

Bien que peu élégant, cet exemple illustre le principe de « séparation de fréquences » : nous avons conservé les détails fins de la joue, et copié des détails grossiers de l'image résiduelle.

Nouveau module : filmique

Le module filmique a été conçu pour reproduire les meilleurs aspects d'une pellicule argentique associés aux contrôles plus aisés de la photographie numérique. Il peut être utilisé sur toute image en remplacement du module courbe de base, et est particulièrement adapté pour les images à grande plage dynamique (high dynamic range - HDR), c'est-à-dire avec un écart important entre les zones les plus claires et les plus sombres de l'image.

Prenons un exemple d'une telle image (extrait du défi pixls.us PlayRaw "Backlit") :

Une approche commune pour agir avec des images à plage dynamique étendue (HDR) est de comprimer le contraste global tout en conservant le contraste local. darktable a plusieurs modules fonctionnant sur ce principe : mappage tonalités, mappage global tonalités, ombres et hautes lumières, et depuis darktable 2.2, le mode fusion d'exposition dans le module courbe de base. Cette compression de contraste fonctionne jusqu'à un certain point, les résultats pouvant donner un aspect artificiel si poussée trop loin. Ce que vous souhaitez typiquement éviter est ceci (le module mappage de tonalités a été utilisé, le curseur de contraste à son maximum) :

Le module filmique montre qu'une autre approche est possible et, généralement, donne des résultats plus naturels. Il considère chaque pixel individuellement, sans faire de distinction entre le contraste global et local. Si filmique comprime trop le contraste, il est toujours possible de récupérer le contraste local avec l'excellent module contraste local par exemple.

Le module filmique est fait pour être utilisé sans le module courbe de base (activé par défaut dans darktable). La courbe de base vient très tôt dans le pipeline graphique et donne une image contrastée, dans laquelle les hautes lumières sont souvent atténuées. Récupérer les détails perdus via courbe de base est difficile. D'autre part, simplement désactiver courbe de base entraîne généralement des images pâles, manquant de contraste et de saturation. D'autres techniques d'amélioration du contraste doivent être utilisées pour compenser cela. Le module filmique vient plus tard que courbe de base dans le pipeline graphique, et donne plus de contrôle pour exploiter correctement la plage dynamique de l'image de sortie.

La première chose que fait filmique est d'appliquer une courbe logarithmique sur l'image, de sorte que les « stops » (puissance de deux de luminance d'un espace linéaire) soient répartis uniformément sur l'histogramme.

La source d'inspiration derrière filmique est la pellicule argentique. Une différence entre les pellicules argentiques et les capteurs numériques est la manière dont ils réagissent à la surexposition. Les capteurs numériques ont un seuil d'écrêtage au-dessus duquel tout est considéré blanc : ils ne peuvent pas faire la distinction entre les pixels légèrement supérieurs au seuil et les pixels fortement surexposés. L'argentique réagit différemment : le contraste est réduit progressivement à mesure que l’image est surexposée, sans cet effet de seuil. Cela permet aux pellicules argentiques de restituer une scène avec une plage dynamique élevée sur un support avec une plage dynamique inférieure, tout en maintenant le contraste et la saturation dans les tons moyens.

Un effet similaire peut être obtenu dans le monde numérique en appliquant une courbe en S à l'image, tant que les hautes lumières ne sont pas écrêtées. Avec le module courbe de tonalités, on peut dessiner une courbe comme celle-ci :

La seconde chose que fait filmique est d'appliquer une telle courbe, mais au lieu de fournir cette courbe manuellement, la courbe est automatiquement calculée depuis un ensemble de paramètres. Cela facilite l'équilibrage des ombres, hautes lumières et tons moyens.

Exemple d'image

Traitons notre image avec ce module. Avant d'appliquer filmique, nous devons d'abord désactiver le module courbe de base, et ensuite ajuster l'exposition. Aucun pixel ne doit être surexposé ou sous-exposé. Dans notre situation, nous devons réduire l'exposition afin d'éviter de surexposer le ciel :

Afin que les paramètres automatiques fonctionnent de leur mieux, il est recommandé d'utiliser le mode AMaZe du module dématriçage. Activer un module de réduction de bruit avant filmique, dans le pipeline graphique (ex. : réduction de bruit (profil)), peut également aider.

Transformation logarithmique

La première chose affichée dans le module filmique est un aperçu de la courbe appliquée à l'image. La courbe n'est pas directement éditable, l'objectif du module étant d'ajuster la courbe via les curseurs situés en dessous.

Afin d'avoir un bon point de départ de travail, filmique fournit une pipette de réglage de niveaux automatiques. Par défaut, ce module considère l’ensemble de l’image et positionne les trois curseurs du dessus en fonction de la luminance moyenne, de la zone la plus lumineuse et de la zone la plus sombre :

À ce stade, l'histogramme doit remplir toute la plage, mais aucun pixel ne doit être sous ou surexposé. Si ce n’est pas le cas, vous pouvez corriger le problème avec le curseur facteur de sécurité : le glisser vers la droite comprime la plage dynamique (l’histogramme doit donc apparaître centré, avec des parties vides à gauche et à droite), et inversement, le glisser vers la gauche l'étend de sorte que les ombres et hautes lumières commencent à s'écrêter. Le curseur noir peut être défini en devinant la plage dynamique de l’image (sur une image suffisamment contrastée, c’est la plage dynamique de la caméra, c’est-à-dire environ 14 EV sur un appareil haut de gamme ou environ 10 EV pour un appareil compact moyen). Le curseur noir peut être défini par la valeur du blanc moins la plage dynamique. On peut aussi déplacer le curseur pour laisser l'histogramme remplir sur son axe horizontal.

Dans notre cas, l'outil niveaux automatiques a fait le travail correctement, nous allons donc conserver les curseurs tels qu'ils sont. L'histogramme est réparti sur la plage dynamique de l'image cible. Aucun pixel n'est surexposé :

C'est ici que la magie opère : la pipette de luminance de gris moyen permet de choisir quelle partie de l'image sera considérée comme gris moyen (50% de luminance). Par exemple, si nous le définissons sur la joue du chien, nous obtenons ceci :

Si nous sélectionnons le nez du chien, qui est plus foncé, nous obtenons une image plus claire :

Attention : on est en train de pousser le module dans ses retranchements vu qu'on lui demande d'exposer l'une des zones les plus sombres de l'image comme un gris moyen, ce qui n'est a priori pas une très bonne idée. Mais même dans des conditions extrêmes, le module ne s'en sort pas si mal.

D'autre part, si nous sélectionnons une zone claire du ciel, l'exposition globale est diminuée afin d'obtenir une exposition correcte du ciel :

Sur toutes ces images, les points blancs et noirs sont conservés, et ne sont pas sur ou sous-exposés. Au final, sélectionner l'herbe derrière le chien est probablement la meilleure option ici, mais c'est une question de goût :

L'utilisation de l'image complète avec le curseur luminance du gris moyen est également un choix sûr. C'est ce que fait niveaux automatiques.

Courbe filmique en S

Allons maintenant découvrir la seconde partie de ce module : la courbe filmique en S. Cette courbe va principalement permettre d'augmenter le contraste dans les tons moyens (le curseur contraste) et comprimer les ombres et/ou hautes lumières. Peut-être ne l'avez-vous pas remarqué, mais le module filmique a déjà initié cela à son activation, le curseur de contraste étant défini par défaut à 1.5. Si nous désactivons la courbe filmique en S (donc définir le contraste à 1), nous obtenons une image plus terne :

D'autre part, nous pouvons définir plus de contraste que l'option par défaut :

Bien sûr, à un certain niveau, augmenter le contraste entraînera une perte d'informations dans les ombres et/ou hautes lumières. La courbe en haut du module permet de voir quelle information est perdue : idéalement la courbe ne devrait pas toucher le bas ou le haut du cadre.

Par exemple, si vous obtenez la courbe ci-dessous, la texture est perdue dans les noirs :

En d'autres termes, ou vous avez détruit vos ombres, ou vous avez volontairement écrêté afin d'obtenir des noirs plus profonds.

Les curseurs sous contraste permettent d'affiner précisément la courbe :

  • latitude définit la gamme de l'image correspondant aux tons moyens sur lesquels le contraste sera augmenté.

  • équilibre ombres-hautes lumières définit la place à donner aux ombres ou aux hautes lumières.

  • Le menu de contrôle rendu contrôle l'interpolation entre les points de la courbe. La valeur par défaut donne généralement de bons résultats, mais peut aussi être totalement fausse (par exemple, produire une courbe non monotone) lorsque vous poussez les paramètres à leur extrême. Essayez d'autres modes lorsque cela se produit.

L'augmentation du contraste produit souvent une augmentation de la saturation dans les ombres, et une augmentation dans les hautes lumières, ce qui peut amener à des couleurs sortant du gamut de sortie. Le curseur saturation permet de diminuer la saturation dans les ombres et hautes lumières extrêmes afin d'éviter cela. D'autre part, dans les hautes lumières, darktable doit habituellement choisir entre la préservation de la luminance et de la chrominance. Par défaut, il préserve la luminance, mais il est possible de privilégier la chrominance par le biais de la case à cocher correspondante. En préservant la chrominance, les images résultantes sont souvent perceptuellement sur-saturées, ce qui demandera plus d'attention plus loin dans le pipeline (par exemple en définissant la saturation de sortie du module balance couleur à 75%).

Il existe une section masquée destination/affichage, peu utile pour la plupart des utilisateurs. Attendez-vous à des images horribles si vous l'utilisez sans lire le manuel et savoir ce que vous faites !

Touche finale et contraste local

Le contraste a été comprimé dans le ciel, mais nous voyons toujours un peu de texture. Si nous voulons augmenter le contraste local du ciel, le module contraste local avec un masque paramétrique sur la partie la plus claire de l'image produit ce résultat :

Il est aussi possible de désactiver l'effet de filmique en utilisant les masques, par exemple en excluant les hautes lumières pour éviter ici la compression de contraste.
Un adoucissement du masque sera en général nécessaire pour éviter les bords abrupts ou halos.

Documentation complémentaire

Cette partie vous donne un aperçu de ce qui est possible avec le module filmique. Bien entendu, il est recommandé de lire le manuel de darktable pour plus de précisions.

Pour de plus amples informations (plus de détails techniques, comparaison avec d'autres techniques, exemples d'images réelles…), vous pouvez également lire l'article suivant (en anglais) : « Filmic, darktable and the quest of the HDR tone mapping », par Aurélien Pierre, le créateur du module.

Gestionnaire de clones dans la chambre noire

Avec darktable, vous pouvez conserver plusieurs historiques différents de la même image. En cliquant sur le bouton cloner dans le module images sélectionnées de la table lumineuse, cela donne un clone de l'image : le fichier RAW n'est pas copié, mais darktable conserve ainsi deux piles d'historique distinctes pour cette image.

De plus, darktable 2.6 facilite le travail avec les clones, grâce au nouveau module apparaissant dans le panneau gauche de la chambre noire :

Première amélioration : de fait, le module étant dans la chambre noire, il est désormais possible de travailler avec les différents clones, sans quitter cette dernière.

Deuxième amélioration : un bref commentaire peut être associé à chaque clone de l'image. Supposons que nous souhaitions comparer notre image développée via le module filmique avec un développement fait via la fonction de fusion d'exposition du module courbe de base. Nous pouvons démarrer avec un ajustement d'exposition basique et conserver cette version pour des développements futurs :

Ensuite, un clic sur le bouton créer un clone avec le même historique [6] donne un clone sur lequel nous pouvons appliquer notre traitement basé sur le module filmique :

Afin d'obtenir une nouvelle version, nous sélectionnons d'abord le premier par un double-clic avant de créer un clone :

Pour comparer les clones, un simple clic prolongé sur un autre montre cette version de l'image à un niveau de zoom ajusté à l'écran. Il vous faudra maintenir le clic jusqu'à ce que l'image soit affichée complètement la première fois. L'opération sera immédiate par la suite, vous permettant de cliquer et relâcher plusieurs fois pour obtenir une comparaison avant/après instantanée.

Notez bien que les miniatures de l'image sont seulement mises à jour lorsque vous quittez l'image. La miniature de l'image en train d'être éditée n'est donc en général pas à jour.

Refonte du module balance couleur

Le module balance couleur a été considérablement amélioré. Bien que son nom contient le mot « couleur », c'est un module plus général que cela. Il peut ajuster les niveaux à peu près comme le module niveaux et peut également ajuster le contraste avec une courbe proche de la courbe en S du module filmique. Bien entendu, vous pouvez également toujours ajuster les couleurs pour ajouter ou supprimer une dominante de couleur dans les ombres, les hautes lumières et les tons moyens séparément.

Le module gagne deux modes de fonctionnement en mode ProPhotoRGB. De plus, vous avez maintenant le choix entre les anciens contrôles des couleurs RGBL (rouge, vert, bleu, luminance) et TSL (teinte, saturation, luminance).

Jouons avec le module sur une image avec plusieurs balances de blancs. Voici l'image d'origine, avec uniquement les modules de base activés et la courbe de base désactivée :

La neige est évidemment blanche dans la scène réelle, mais la neige exposée au soleil reflète la lumière de ce dernier, tandis que celle dans l'ombre reflète la lumière du ciel, beaucoup plus bleue. Le module pipette dans la barre latérale gauche de la chambre noire permet de visualiser et de quantifier ces dominantes de couleurs :

(La valeur négative pour le canal 'b' représente la couleur bleue)

Le module balance couleur dispose maintenant d'une pipette pour neutraliser les couleurs. Sur cette image, l'optimiseur automatique fonctionne plutôt bien. Après un clic sur neutraliser les couleurs, la dominante bleue dans les ombres est réduite :

En regardant de plus près les patchs sélectionnés par la pipette, notez que la valeur 'b' est maintenant beaucoup plus proche de 0 :

Si l'optimiseur automatique se trompe, il est possible de spécifier des patchs de couleur pour les hautes lumières, les ombres et les tons moyens (de préférence dans cet ordre) séparément avec les pipettes de couleurs correspondantes. Et, si nécessaire, de relancer la fonction neutraliser les couleurs (intitulée neutraliser les couleurs à partir des patchs une fois que vous avez sélectionné ces patchs).

De même, les tonalités peuvent être ajustées de la même manière que via le module niveaux, soit avec la fonction optimiser luma, soit avec des sélecteurs individuels.
La section maître en haut permet de régler le contraste et la saturation globale. Les curseurs contraste pivot et contraste appliquent une courbe, centrée autour du pivot et avec une pente donnée par le contraste. En d’autres termes, avec un contraste positif, les parties de l’image situées en dessous du pivot seront assombries et les parties situées au-dessus auront leur luminance augmentée :

Bien sûr, l'étalonnage des couleurs est toujours la fonction principale du module balance couleur. Par exemple, pour obtenir un look ancien, avec des ombres bleues et estompées, nous pouvons utiliser la section ombres : lift / offset. Définissez le curseur facteur sur une valeur positive (afin que les noirs ne soient pas complètement noirs), la teinte sur une couleur bleutée, et utilisez le curseur de saturation afin de contrôler l'intensité de la coloration. Cela peut donner lieu à des images comme celle-ci (image prise du défi RAW de la semaine) :

Dans cet exemple, les curseurs ont été poussés un peu loin afin d'obtenir un résultat clair, mais le module peut également obtenir des effets plus subtils, particulièrement lorsqu'il est combiné avec les masques paramétriques. Voyez par exemple le pré-réglage « virage partiel bleu-sarcelle/orange » ajouté au module dans cette version (avant pour la première image, après l'application du pré-réglage pour la seconde) :


Floutage avec détection de bords des masques de fusion

La fonction de fusion de darktable permet de sélectionner une partie de l'image, appelée un masque, afin d'appliquer la transformation apportée par le module sur cette partie. Après création du masque (dessiné ou paramétrique), il est possible d'adoucir les bords du masque avec un effet de floutage.

Grace à darktable 2.6, vous avez plus de contrôle sur la manière dont le floutage du masque est rendu. Afin d'en comprendre le fonctionnement, regardons les deux principales méthodes de floutage. La plus commune est le flou gaussien, qui donne en gros le même effet qu'une photo avec une mise au point incorrecte. En flou gaussien, la valeur (luminance et chrominance) de chaque pixel est diffusée uniformément aux pixels environnants. L'effet de diffusion s'atténue à mesure qu'on s'éloigne du pixel de départ. Dans darktable, le flou gaussien est disponible dans le module filtre passe-bas :

Un autre type de floutage se base sur le filtre bilatéral (article en anglais), parfois appelé flou de surface (en raison du nom de l'outil correspondant dans Photoshop), ou floutage avec détection de bord. Dans ce mode, la valeur de chaque pixel est diffusée sur les pixels voisins, mais l'influence d'un pixel est réduite quand les pixels ont des valeurs différentes. Par exemple :

Un algorithme de floutage similaire peut être appliqué au masque, mais cette fois le masque est flouté et l'image sur laquelle on travaille sert de guide pour le floutage. Ceci permet de définir grossièrement le masque et de l'affiner ensuite précisément avec les curseurs.

Supposons que nous souhaitions améliorer la couleur du ciel. Dans le module zones de couleurs, nous pouvons sélectionner approximativement le ciel avec un masque dessiné :

Évidemment, le résultat est pire avec un flou gaussien sur ce masque (le seul qui était disponible dans darktable 2.4) :

Cependant, en poussant le curseur du rayon adoucissement, le masque s'ajuste automatiquement au ciel, sans propagation aux montagnes. L'adoucissement réduit un peu l'opacité du masque. Cela peut être compensé avec le curseur d'opacité du masque. Et voilà :

Notez qu'en poussant les curseurs de rayon adoucissement et opacité du masque, cela vous donne un outil similaire à l'outil de sélection contiguë de GIMP, souvent demandé par les utilisateurs de darktable : sélectionnez quelques pixels dans une zone et laissez l'outil sélectionner les pixels similaires environnants.

Par exemple, via un coup de pinceau à l'intérieur de la maison :

Et maintenant en augmentant l'adoucissement :

Améliorations de la table lumineuse et de la carte
  • La recherche d'un lieu depuis la vue carte a été corrigée :

  • L'aspect de la table lumineuse a été amélioré. Le texte de fond de l'image était souvent illisible car masqué par l'image. L'état de la copie locale est désormais affiché dans l'angle haut droit.
    Dans darktable 2.6 :

    Avec les versions précédentes, la même configuration s'affichait comme ceci :

  • On peut maintenant afficher les métadonnées des images sur la miniature dans la table lumineuse et dans les bandeaux en bas de la chambre noire :

    Une fois activé, les informations s'affichent quand on passe la souris sur la miniature :

  • On peut maintenant trier les images selon l'aspect (éventuellement après un recadrage dans darktable) :

  • Il est aussi possible de spécifier l'ordre manuellement, en sélectionnant tri personnalisé puis par un glisser-déposer des images afin de les réordonner :

  • Les collections peuvent maintenant être filtrées par aspect, exposition et copie locale :

    Le filtre aspect permet notamment de sélectionner par format : seulement les images au format portrait (ratio d'aspect < 1) ou paysage (ratio > 1) ou format carré (ratio =1).

  • En sélectionnant un filtre dans filtres de collection, le nombre d'images correspondant à chaque filtre est affiché. Dans l'exemple ci-dessous, 12 images ont été prises à un temps d'exposition d'1/2000" et 6 à 1/1600" :

  • Il est maintenant possible d'avoir des barres de défilement dans les vues table lumineuse et chambre noire. Elles sont désactivées par défaut dans la chambre noire, mais peuvent être activées si nécessaire à partir des préférences globales (au bas de l'onglet options de l'interface) :

    Les barres de défilement apparaissent autour de la partie centrale de l'interface :

    Dans la vue table lumineuse, les barres de défilement sont le seul moyen de se déplacer rapidement dans une très grande collection d’images.
    Dans la vue chambre noire, le déplacement peut s'effectuer sans barres de défilement en faisant glisser la souris sur l'image ou en utilisant l'aperçu en haut à gauche de la fenêtre, les barres de défilement sont donc beaucoup moins nécessaires.

  • La prise en charge des groupes d'images a été améliorée. Des groupes d'images peuvent être créés en sélectionnant des images et en cliquant sur grouper dans le module images sélectionnées. Une fois cela fait, le bouton G en haut de la table lumineuse permet de basculer entre le mode « replié » où seule la tête de groupe est affichée et le mode « étendu ». En mode replié, des actions telles que l'évaluation (étoiles) et les étiquettes de couleur sont appliquées à l'ensemble du groupe.

  • De plus, il est désormais possible de trier par groupe afin que ceux-ci restent ensemble. L'image principale du groupe est affichée en premier. Sinon, l'ordre est identique au tri par numéro.

  • Le module d’impression a été amélioré : il est maintenant possible de choisir le type de papier et, lors de l’utilisation de TurboPrint, la fenêtre d'impression complète de TurboPrint s’affiche avant l’impression.

  • Les filtres de collection de la table lumineuse ont désormais 3 modes permettant d'interagir avec les tags hiérarchiques. Lorsque vous sélectionnez un tag qui n'est pas un nœud (c'est-à-dire un tag avec des sous-étiquettes), donc le tag « parent » :

    • Un double-clic sélectionne seulement les images marquées uniquement avec ce tag. La recherche est définie sur le « parent ».
    • Un Contrôle-double-clic sélectionne seulement les enfants, c'est-à-dire les images taguées avec « parent|enfant » et pas seulement « parent ». La recherche est définie sur « parent|% », où « % » signifie « toute chaîne ».
    • Un Majuscule+double-clic sélectionne les images marquées avec le tag lui-même ou l'un de ses enfants. La chaîne de recherche est définie sur « parent% ».
Autres fonctionnalités importantes Contrôle plus fin sur le bruit pour les modules réduction du bruit (profil) et réduction du bruit RAW

De nouvelles courbes ont été introduites afin de permettre un contrôle plus fin du mode ondelettes des modules réduction du bruit (profil) et réduction du bruit RAW. Ces courbes permettent de contrôler la force du débruitage fréquence par fréquence.
En d'autres termes, vous pouvez adapter la force du débruitage en fonction de l'importance du grain produit par le bruit. La courbe tout permet de changer la force de tous les canaux en même temps, tandis que les courbes R, G et B permettent de changer la force séparément pour les canaux rouge, vert et bleu.
Il était déjà possible de débruiter de manière sélective les canaux rouge, vert et bleu en utilisant ensuite les modes de fusion canal RGB rouge / vert / bleu, mais le nouveau module peut le faire avec une seule instance et sans fusion.

Tout d'abord, regardons un exemple de ce qui peut être fait avec les courbes tout.
Pour commencer, effectuez un zoom à 100% sur l’image. À des niveaux de zoom inférieurs, le résultat est une approximation qui n’est pas toujours précise.
Actionnons ensuite le module de réduction du bruit (profil), en mode ondelettes.
Une force comprise entre 0,150 et 0,3 est généralement un bon point de départ.
Ici, pour mieux voir l’influence de la courbe, nous utilisons une force de 0.5.

Voici ici l'image que nous obtenons avec une courbe plate :

Maintenant, en réduisant la force sur une fréquence spécifique, nous pouvons obtenir des résultats très différents. Voici ce que nous obtenons en abaissant la force sur une fréquence assez grossière :

Le résultat n'est pas agréable pour les yeux, car les bruits de grains grossiers sont très perturbants. Ici, nous réduisons trop la force de débruitage.

Essayons le même test sur la fréquence la plus fine :

On obtient ici une image beaucoup moins gênante que la précédente : le bruit du grain fin est moins dérangeant que celui à grain grossier. Cette image est même sans doute plus naturelle que celle avec une courbe plate.

En jouant avec les différentes fréquences, on peut obtenir de meilleurs compromis entre lissage et conservation des détails.

De plus, de nouveaux préréglages qui exploitent cette courbe sont maintenant disponibles pour le module réduction du bruit (profil) :

  • un pour le bruit de chrominance (fausses couleurs), où le bruit est augmenté pour les détails les plus fins, la couleur ne devant pas trop changer d'un pixel à l'autre ;

  • un pour le bruit de luminance (fausse luminance), où le débruitage est réduit aux détails les plus fins et à certaines échelles grossières. Son objectif est de trouver un bon compromis entre bruit et lissage pour des images peu bruyantes (oubliez les valeurs ISO étendues, par exemple. Pour de telles images, nous devons utiliser des stratégies moins automatiques).

Le préréglage chroma doit être utilisé en première instance et le préréglage luma en deuxième instance.

Vous pouvez utiliser les courbes RGB pour des images plus complexes ou pour obtenir un meilleur compromis. En effet, les capteurs capturent généralement les valeurs R, G et B. En fonction de l'éclairage de la scène, les canaux peuvent présenter différentes caractéristiques de bruit :

  • l'un des canaux peut être plus (ou même beaucoup plus) bruyant que l'autre

  • un canal peut avoir un bruit plus grossier qu'un autre

Vous pouvez essayer d’obtenir un meilleur compromis de débruitage en débruitant les canaux séparément, à l’aide des courbes RGB et d’une instance du mélangeur de canaux permettant de visualiser les canaux :

Une fois que les canaux RGB ont été débruités, vous pouvez utiliser une autre instance en mode de fusion couleurs pour éliminer les problèmes de couleur restants.

Notez que le débruitage des canaux RGB individuellement doit être effectué avant d'utiliser une instance en mode de fusion couleurs, car cela mélangera les canaux et modifiera les caractéristiques du bruit.

Ces explications utilisaient le module réduction du bruit (profil) comme exemple, mais vous pouvez suivre les mêmes étapes avec le module réduction du bruit RAW.

Notez également que l'astuce consistant à utiliser le mélangeur de canaux pour visualiser un canal en particulier pendant qu'on règle le débruitage de ce canal est aussi utile pour définir les paramètres du module réduction du bruit (bilatéral).

Un nouveau mode logarithmique pour le module correction du profil d'entrée

De la même manière que la transformation logarithmique du module filmique, le module correction du profil d’entrée propose maintenant un mode logarithmique, avec les mêmes curseurs et sélecteurs. La différence principale est que correction du profil d’entrée vient avant l’application du profil d’entrée, tandis que filmique vient plus tard dans le pipeline graphique.

L'utilisation du mode logarithmique du module correction du profil d'entrée donne généralement une image pâle, sans contraste. Par exemple, sur l'image Mairi Troisieme, nous obtenons cela :

Obtenir une image pâle est en fait l'objectif : le mode logarithmique du module correction du profil d'entrée est fait pour être utilisé en complément d'un autre module ultérieurement dans le pipeline graphique afin de donner plus de pep's à l'image (par exemple avec le module de balance couleur, particulièrement avec les nouvelles fonctionnalités de cette version).
L'avantage de ce flux est que la majeure partie du pipeline graphique, en particulier l'application du profil de couleur d'entrée, est réalisée sur une image qui s'étend correctement sur l'histogramme, sans valeurs extrêmes. En d’autres termes, nous distinguons une partie technique de l'édition et une partie artistique.

Revenons à notre image où la balance des couleurs permet par exemple ceci :

Notez que dans ce flux de travail, il est obligatoire de travailler dans le même ordre que le pipeline graphique : essayer d'ajuster les paramètres du module correction du profil d'entrée après le réglage des niveaux et du contraste avec le module balance couleur est voué à l'échec.

En pratique, le module filmique peut faire plus ou moins la même chose, mais à l'avantage de tout avoir dans un seul module permettant une édition plus rapide.

Possibilité d'ajuster l'opacité de chaque correction du module correction de taches

Le module correction de taches bénéficie de certaines des fonctionnalités intéressantes du module retouche. Par exemple, il est désormais possible de définir l'opacité des formes individuellement (Contrôle+clic).

Amélioration de la gestion des fichiers RAW monochromes

Bien qu'il soit possible de transformer n'importe quelle image RAW en monochrome, certains boîtiers n'ont pas de filtres de couleurs devant leurs capteurs et produisent des fichiers RAW monochromes. Les versions précédentes de darktable permettaient de désactiver le module dématriçage pour le format RAW monochrome. Cette version améliore encore le traitement de ces images en désactivant la correction des aberrations chromatiques, le module balance des blancs (ne serait-ce que pour éviter les messages d'erreurs parasites), et en ré-activant le traitement de base tel que l'exposition automatique désactivée dans les précédentes versions.

Amélioration de la gestion des instances multiples de modules Possibilité de renommer les instances de module

Lorsqu’on utilise plusieurs instances du même module à des fins différentes, il est souvent difficile de se rappeler quelle instance sert à quoi. Maintenant, darktable permet de donner un nom à chaque instance pour simplifier cela.
Par exemple, si vous utilisez deux occurrences de réduction du bruit (profil), une pour le bruit de chrominance et une pour le bruit de luminance, vous pouvez définir le nom du premier comme « chroma » et le nom du second comme « luma ».

Les étapes pour définir le nom de l'instance de chrominance sont décrites ci-dessous :

  1. tout d'abord, cliquez sur le bouton actions instances multiples ;
  2. cliquez sur renommer ;
  3. entrez le nom ;
  4. appuyez sur entrée sur votre clavier.

Donner un nom à une instance de module n'est pas seulement un moyen pratique de se souvenir de qui fait quoi : darktable utilise aussi cette information pour le copier-coller d'historique, décrit juste après.

Amélioration du copier/coller

L'une des forces de darktable est, grâce à sa nature non destructive, la possibilité d'appliquer l'historique d'une image sur une autre. Un historique peut être enregistré en tant que style ou copié d'une image à une autre (en utilisant contrôle-c/contrôle-v dans la table lumineuse ou la chambre noire, ou en utilisant le module développement dans la table lumineuse).

Une difficulté, cependant, consiste à décider de ce qui doit se passer lors du copier-coller d’un historique contenant un module sur une image cible où le module est déjà utilisé. Par défaut, darktable remplace le module existant par celui copié-collé. Toutefois, lorsque le même module est utilisé à des fins différentes dans les images source et cible, ce comportement n'est pas satisfaisant.
Dans darktable 2.6, le comportement est le suivant : lorsque les modules des images source et cible ont des noms différents, les deux instances sont conservées. S'ils portent le même nom, le copié-collé remplace l'ancien.

Appliquer un style en un clic à une nouvelle instance

Travailler avec plusieurs instances du même module devient de plus en plus facile. Un cas d’utilisation courant consiste à créer une instance pour un réglage prédéfini, par exemple, le module réduction du bruit (profil) est souvent utilisé avec une instance pour traiter le bruit de luminance, et une autre pour la chrominance.

Avec les versions précédentes, cela se faisait en plusieurs étapes :

1) créer une nouvelle instance,
2) appliquer le préréglage (4 clics).

Il est maintenant possible de le faire en une seule étape : ouvrez le menu pré-réglages et utilisez le bouton du milieu de la souris au lieu du bouton gauche pour sélectionner l’entrée :

Notez que la version qui suivra la 2.6 permettra d'ouvrir le menu pré-réglage par un clic du bouton du milieu de la souris, donc on pourra utiliser le même bouton pour les deux clics.

Recadrage préservant le ratio dans le module correction de perspective

Le module correction de perspective permet désormais un recadrage semi-automatique préservant le format original de l'image :

Glissez simplement la souris sur l'image pour sélectionner la portion à recadrer :

L'aire est ajustée automatiquement afin d'éviter d'inclure des parties noires de l'image cible. Ceci évite d'avoir à passer au module recadrer et pivoter.

Améliorations d'ergonomie Aide contextuelle

Le logiciel darktable est une bête complexe à maîtriser, et lire le manuel pour la fonctionnalité que vous essayez d'utiliser est souvent une bonne idée, même si vous avez déjà lu le manuel complet. Cette version introduit une aide contextuelle pour aider les utilisateurs : un bouton ? est disponible en haut à droite de l'interface, à côté du bouton préférences :

Après sélection de ce bouton, le curseur de la souris se transforme en un point d'interrogation dès lors qu'il survole tout élément de l'interface ayant une aide disponible :

En cliquant ensuite sur l'élément, votre navigateur web s'ouvrira sur la section correspondante de la documentation darktable.

Organisation des modules en onglets

La répartition des modules en groupes ou en onglets (modules de base, modules de tonalité, modules de couleur, modules d'améliorations et groupe d'effets) est maintenant personnalisable. La distribution originale dans darktable suit une catégorisation thématique, mais certains utilisateurs préfèrent le regroupement par étapes du flux de travail.

Par exemple, le module dématriçage est actuellement classé dans le groupe modules de couleur parce qu'il traite les couleurs, mais il intervient très tôt dans le pipeline graphique ce qui peut avoir une incidence sur presque tous les autres modules. Il est donc judicieux de le classer dans le groupe de base.

Une nouvelle catégorisation a été proposée, mais les discussions entre les développeurs n’ont pas permis de parvenir à un consensus, car la modification des groupes risque de perturber les anciens utilisateurs habitués à la présentation originale.

Dans darktable 2.6, le compromis trouvé a été de permettre une disposition personnalisée.

Vous pouvez modifier cette disposition manuellement en éditant le fichier .config/darktable/darktablerc, ou utiliser l'un des scripts fournis dans la distribution source de darktable : tools/iop-layout.sh afin d'adopter une nouvelle disposition, et tools/iop-layout-legacy.sh pour revenir à celle d'origine.

Éditez ces scripts si vous souhaitez créer votre disposition personnelle. Ces scripts sont faits pour des utilisateurs avancés qui savent comment en exécuter un. Il n'est pas garanti qu'ils fonctionnent sous Windows. Si un consensus se dégage sur la meilleure présentation possible, celle-ci pourra être adoptée dans les futures versions de darktable afin que tous les utilisateurs puissent en bénéficier.

Notez que ce changement n'affecte que l'interface. Changer la répartition des modules des différents groupes n'affecte pas l'ordre dans lequel les modules sont appliqués, ordre de traitement qui reste fixe (du bas vers le haut de l'interface affichée).

Module Courbe des tonalités

L'interface utilisateur du module courbe des tonalités a été améliorée de plusieurs façons. Premièrement, vous pouvez désormais utiliser une échelle logarithmique sur l'axe X ou l'axe Y, ou sur les deux :

Ceci facilite la manipulation des points proches de zéro, c'est-à-dire affiner plus finement la partie de la courbe affectant les ombres.

Il est également possible de choisir l'algorithme utilisé pour l'interpolation, c'est-à-dire pour calculer la courbe elle-même en fonction des points de contrôle édités par l'utilisateur. Il y avait déjà plusieurs algorithmes disponibles, mais masqués à l'utilisateur. Par exemple, sélectionner le paramètre prédéfini contraste - haut (linéaire) sélectionnait pour vous une spline cubique. Pour les courbes très lisses, l’algorithme d’interpolation ne modifie pas beaucoup le résultat, mais pour les courbes utilisant des points proches les uns des autres, il peut provoquer des modifications importantes.

Par exemple, regardons le même ensemble de points de contrôle à différentes interpolations. Le mode spline cubique donne une courbe très lisse, mais peut donner un résultat non monotone, c'est-à-dire une inversion de contraste sur l'image résultante :

Le mode spline centripète réduit le risque d'obtenir une courbe non-monotone :

Le mode spline monotone, utilisé par défaut, peut être moins lisse mais évite de fait la non-monotonie :

Interface utilisateur plus personnalisable avec les feuilles de style CSS

Plus d'éléments sont personnalisables via CSS. En particulier, certains qui étaient codés en dur avec un avant-plan clair et un arrière-plan sombre, ce qui rendait impossible d'avoir un thème à l'arrière-plan clair.

Il est maintenant possible d'avoir un thème clair avec, par exemple, la CSS suivante (dans un fichier nommé darktable.css dans le répertoire de configuration de darktable, c'est-à-dire ~/.config/darktable/ sur les systèmes unix ; pour plus d'informations et autres systèmes d'exploitation, voir sur darktable.fr) :

/* Remplacer le chemin ci-dessous par le chemin vers le fichier darktable.css de darktable 2.6 */ @import '/usr/share/darktable/darktable.css'; @define-color bg_color #eee; @define-color plugin_bg_color #aaa; @define-color fg_color #333; @define-color base_color #444; @define-color text_color #333; @define-color selected_bg_color #eee; @define-color selected_fg_color #666; @define-color tooltip_bg_color #ddd; @define-color tooltip_fg_color #eee; @define-color really_dark_bg_color #eee; @define-color darkroom_bg_color #fff; @define-color darkroom_preview_bg_color shade(@darkroom_bg_color, .8); @define-color lighttable_bg_color @darkroom_bg_color; @define-color lighttable_preview_bg_color shade(@lighttable_bg_color, .8); tooltip { border-radius: 0pt; } #iop-plugin-ui { border: 1pt solid #aaa; }

L'interface ressemblera alors à ceci :

Attention, une interface claire comme celle-ci donne l'impression que les images sont plus sombres. L'utilisateur sera donc tenté de surexposer ses images. Travailler sur fond clair reste intéressant pour les photographes qui travaillent sur des images destinées à être affichées sur fond clair ou blanc. Pour éviter d'être influencé vers la sur- ou sous-exposition, un thème gris, comme celui dont nous avions parlé l'an passé est bien plus recommandable.

À noter que les miniatures de la table lumineuse utilisent toujours des couleurs codées en dur, mais ceci devrait changer dans la prochaine version.

Autres améliorations
  • Les niveaux de zoom 50%, 400%, 800% et 1 600% sont disponibles dans la chambre noire. Même si la plupart des opérations fournies par darktable ont pour objectif d'améliorer les couleurs et la tonalité de l'image globale, il est parfois intéressant d’obtenir une vue précise au niveau des pixels sur une petite partie de l’image. Le facteur de zoom le plus élevé précédemment disponible (200%) n'était pas toujours suffisant, en particulier sur des écrans à haute résolution. Notez que ces niveaux de zoom sont accessibles dans le menu de la zone d'aperçu, mais pas avec la molette de la souris.

  • Tous les masques sont prévisualisés et peuvent être ajustés avant d'être dessinés. Ceci s'applique également aux formes du module liquéfier.

  • Le fonctionnement de la pipette de couleur a été retravaillé. Par exemple, la pipette du module exposition n'était pas désactivée lorsque le module l'était. Corriger cela est devenu plus important maintenant que de plus en plus de modules utilisent la pipette (filmique, correction du profil d'entrée, balance couleur).

Import depuis d'autres logiciels
  • L'importation depuis Adobe Lightroom a été amélioré (les métadonnées « créateur », « droits », « titre » et « description » sont copiées de Lightroom vers darktable).
  • Un nouveau script est fourni pour importer les collections depuis Capture One Pro (tools/migrate_capture_one_pro.sql dans le code source de darktable).
À propos de cet article

Cet article est sous les termes de la licence Attribution 2.0 Générique (CC BY 2.0) (CC BY 2.0), ou, selon, de la Licence Creative Commons BY-NC-SA 3.0.

Contributeurs : jpg54, Matthieu Moy, Nilvus, rawfiner.

Icône [1]: [2]: [3]: [4]: [5]: [6]: Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

35c3 — 35ᵉ édition du Chaos Communication Congress — Refreshing Memories

mer, 26/12/2018 - 21:03

Le Chaos Communication Congress, rassemblement de hackers organisé par le Chaos Computer Club, revient cette année pour sa trente‐cinquième édition (aussi nommée 35c3 - Refreshing Memories), du 27 au 30 décembre 2018 (soit quatre jours).

Le 35c3 se déroule à Leipzig (comme l'année passée). Cet évènement est l’occasion de nombreuses conférences, ateliers et évènements divers pendant quatre jours sur la technologie, la société, les utopies. Beaucoup de conférences seront retransmises en direct en flux vidéo.

Traductions

Concernant les traductions en direct des conférences du 35C3, le but de l'équipe organisatrice est de traduire 100% des présentations en anglais vers l'allemand, et 100% des présentations en allemand vers l'anglais. Les traductions vers les autres langues, dont le français, dépendent de la disponibilité des traducteurs. Pour des informations complémentaires sur les traductions en français, cf. cette page dédiée.

Messageries instantanées

Pour échanger entre internautes au sujet du 35c3 par messagerie instantanée (canal IRC dédié) et pour permettre aux spectateurs distants de faire relayer leurs questions aux conférenciers (un canal IRC distinct pour chacune des cinq salles principales — également possible par Twitter), il y a une page d’instructions.

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

LinuxMAO — Éditorial de décembre 2018

mer, 26/12/2018 - 20:11

Comme tous les mois, LinuxMAO vous apporte ici son lot de nouveautés et vous permet de vous tenir au courant de l’actualité musicale. Nouveaux projets, nouvelles publications, nouvelles réalisations, dernières mises à jour de logiciels… Allez vite lire la deuxième partie de la dépêche.

Article sous licence CC-By-SA 2.5 (comme l’originel sur LinuxMAO.org).

Sommaire

Autant qu’il m’en souvienne, décembre était le mois des fêtes, des guirlandes et des colifichets dorés.
Les couleurs traditionnelles de ce mois oscillaient d’habitude du vert sombre, couleur sapin, au rouge vif des boules scintillantes et des pères Noël de pacotille, du blanc de leurs toques d’hermine, de celui des neiges réelles ou artificielles, jusqu'à l’argent des guirlandes.

Or, je ne vois que du jaune fluo sur fond de giratoires gris, des abris couverts de bâches bleues, l’ensemble illuminé par les feux de palettes dont le bois de sapin remplit, sur chacun de ces carrefours, une mission toute prosaïque~hs~: réchauffer.

Et je me dis que nous étions peut-être gilets jaunes avant l’heure, lorsque nous avons migré nos informatiques vers Linux, nous affranchissant ainsi de la gabelle prélevée par les aristocrates du système d’exploitation… Comme 2018 disparaîtra, quoi qu’il arrive, le 31 de ce mois à minuit, nous vous souhaitons à tous une bonne fin d’année festive, joyeuse, libre et, évidemment, musicale.

Quoi de neuf ?

Depuis la parution du dernier éditorial, nous ont rejoint : tantilim, olimao, Hephel, mzgh, f00wl, philoudum, tolliac, MisterPhilip, phil43, jojolafrite, Luciffer, beniaak, IsaDJ, Dinosor, danger89, Tylun, stefets, hubert_fr_69, optyrox3266, vincent.azan, vinz09, jameco, djkarlito, mediyann, szvan, Dark X, piteke, AoiHana, ien, petete, pureOL, michelcher et karum.
Bienvenue à vous toutes et tous !)

Musique sur LinuxMAO Musique libre en dehors de LinuxMAO

Liste de lecture des nouveautés pour le mois de Novembre 2018 chez les copains de Dogmazic. Accompagnée de l'édito musical de novembre de Dogmazic.

Nouvelles du monde

L'INSA Rennes organise le Festival des Libertés Numériques du 25 janvier au 9 février 2019. Dans ce cadre, une table ronde "musique et logiciels libres" aura lieu le 31 janvier de 18h30 à 21h00 au Jardin Moderne. Il est à noter qu'il y sera certainement possible de croiser des membres de LinuxMAO (voir le fil de discussion Table Ronde Musique et Logiciels Libres)

Nouveautés sur LinuxMAO

Des chiffres :

Le nombre de visiteurs uniques du mois de novembre 2018 est de 34186. linuxmao.org, c'est à ce jour, 6090 utilisateurs inscrits, 2440 "pages de documentation", les > 89200 messages dans les "forums", et d'autres fioritures.

D'autre part, nous avons eu 33 nouvelles inscriptions depuis la rédaction du dernier éditorial du site c'est à dire en 30 jours.

Nouvelles pages :

Côté administration :

olinuxx a :

Coté logiciel sur LinuxMAO Côté logiciel en dehors de LinuxMAO

Tracktion Waveform ouvre une partie de son code. Voir le fil de discussion Tracktion / Waveform ouvre une partie de son code.

Depuis la publication du dernier éditorial, olinuxx, sub26nico, et r1 ont relevé les mises-à-jour suivantes :

pour ce mois-ci :

pour les mois précédents (mais que nous n'avions pas vu jusque là) :

  • Xwax passe en version 1.7.
Post scriptum

Merci à r1, olinuxx, allany et sub26nico pour l'écriture de cet édito, et on se retrouve le mois prochain pour une revue de l'actualité du mois écoulé !

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

Revue de presse de l'April pour la semaine 51 de l'année 2018

mar, 25/12/2018 - 19:59

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

[Usbek & Rica] Libérons le design et soutenons le libre

Par Bruno Loton, le vendredi 21 décembre 2018. Extrait:

Une réflexion, qu’on peut penser tout à fait légitime, a envahi l'esprit des designers depuis quelques années. Il s’agit de l’éthique dans la pratique et la finalité de notre métier. La question a été massivement diffusée à partir de 2015 par Tristan Harris lorsqu’il quitta Google où il était précisément «Design Ethicist», pour fonder l’organisation Time Well Spent à l’initiative du mouvement du même nom. Un mouvement qui a pour objectif de mobiliser les designers sur la problématique du respect de l’attention des utilisateurs par les produits et services que nous concevons.

Lien vers l'article original: https://usbeketrica.com/article/ce-que-le-design-peut-avoir-d-ethique-est-d-etre-libre

[Developpez.com] L'architecture de processeur MIPS va devenir open source

Par Patrick Ruiz, le mercredi 19 décembre 2018. Extrait:

Depuis le début de cette année, on a beaucoup parlé d’architectures ouvertes avec, notamment, le lancement d’un processeur RISC-V et d’une carte de développement pour le système d’exploitation open source Linux. On poursuit avec les nouvelles de cet univers pour signaler qu’à côté d’OpenSPARC et RISC-V il faudra compter avec un nouvel arrivant. Après avoir racheté la licence d’exploitation des processeurs MIPS en juin dernier, Wave Computing annonce que l’architecture de processeur MIPS va devenir open source.

Lien vers l'article original: https://www.developpez.com/actu/238139/L-architecture-de-processeur-MIPS-va-devenir-open-source-et-pourrait-fragiliser-les-efforts-de-la-communaute-avec-RISC-V

[Developpez.com] France: le Sénat réclame à nouveau le «code source» de chaque projet de loi de finances

Par Stan Adkens, le mardi 18 décembre 2018. Extrait:

Comme l’année dernière à la même période, le Sénat français a adopté cette année encore un amendement obligeant l’administration fiscale à dévoiler, pour chaque projet de loi de finances, le «code source» traduisant les réformes proposées par l’exécutif. Toutefois, comme ce fut le cas l’an dernier, le nouvel amendement pourrait être annulé par les députés sur avis du gouvernement.

Lien vers l'article original: https://www.developpez.com/actu/237975/France-le-Senat-reclame-a-nouveau-le-code-source-de-chaque-projet-de-loi-de-finances-mais-la-requete-semble-encore-impossible-a-satisfaire

[Affiches Parisiennes] Les acteurs de l'open source récompensés

Par Anne Moreaux, le mardi 18 décembre 2018. Extrait:

À l'occasion du Paris Open Source Summit, marqué par les 20 ans de l'association LinuxFr.org, cinq entreprises ou projets du libre, dont la Ville de Paris, ont reçu une distinction pour leurs contributions au développement du logiciel libre et de l'open source.

Lien vers l'article original: https://www.affiches-parisiennes.com/les-acteurs-de-l-open-source-recompenses-8591.html

Et aussi:

[Capital.fr] Taxe Gafa: ce que les géants d'Internet paient en réalité comme impôts

Par Ambre Deharo, le dimanche 16 décembre 2018. Extrait:

Bruno Le Maire entend mettre en place dès 2019 une taxe sur les bénéfices publicitaires réalisés par Google, Apple, Facebook et Amazon, entre autres, en France.

Lien vers l'article original: https://www.capital.fr/entreprises-marches/taxe-gafa-ce-que-les-geants-dinternet-paient-en-realite-comme-impots-1320060

Et aussi:

Télécharger ce contenu au format Epub

Commentaires : voir le flux atom ouvrir dans le navigateur

Catégories: Les actus

2018, l’année de la libération des processeurs ?

dim, 23/12/2018 - 16:43

2018 aura été l’année du RISC-V. Ce jeu d’instructions libre existait bien sûr avant 2018, puisqu’il a été créé en 2010, mais c’est véritablement en 2018 qu’il aura pris son envol.

Entendons‐nous bien, le RISC-V, pour Reduced Instructions Set Computing version V, n’est pas un microprocesseur. C’est une définition du jeu d’instructions ainsi que des registres internes du processeur. Bref, cela doit être vu comme une standardisation open‐source du langage d’un processeur. Libre aux fondeurs de développer leurs architectures de processeur compatible RISC-V. Il définit les instructions assembleur et leurs formats (codage) mais il ne définit pas le nombre d’étages de pipelines, comment est gérée la prédiction de branche ni le format de bus de données et d’instructions. Tout cela relève de l’implémentation.

    Cette standardisation du jeu d’instructions intéresse beaucoup de créateurs de microprocesseurs. En effet, plus besoin d’adapter ou d’écrire les outils logiciels pour son processeur. Comme c’est un standard, il suffit d’utiliser les chaînes de compilation (« toolchains ») classiques comme GCC, OpenOCD ou LLVM, qui, bien sûr, l’intègrent désormais, mais également toutes une série d’outils non libres. Linux n’est pas en reste, puisqu’il intègre complètement l’architecture dans ses versions récentes. C’est également le cas des petits systèmes d’exploitation temps réel comme Zephyr.

    C’est, entre autres, cette disponibilité des outils qui a poussé de nombreux labos à basculer leurs processeurs sur ce jeu d’instructions. On pense notamment à :

    • PULP (Parallel Ultra Low Power), une architecture multicœur pour l’embarqué développée par l’université de Zurich et utilisée par les processeurs GAP8 ;
    • Patmos, le processeur temps réel ;
    • Shakti, de l’université indienne de Madras ;
    • et certainement plein d’autres.

    Il existe une tripotée de processeur RISC-V « soft » que l’on peut synthétiser dans des FPGA. Mais, à ma connaissance, le premier composant silicium sorti des chaînes de fabrication de fondeurs est le E310 de la société SiFive. Ce composant est sorti en 2017 et il est possible d’acheter un kit de développement « compatible Arduino » pour se faire la main dessus.
    Le E310 est un microcontrôleur 32 bits, qui a fait un peu parler de lui quand il est sorti mais qui reste un démonstrateur. La société SiFive souhaitant rester une entreprise « fabless », c’est‐à‐dire sans unité de fabrication.

    Mais c’est véritablement en 2018 que les choses se sont accélérées, avec le ralliement de grands noms de l’industrie électronique à la fondation RISC-V et la sortie de nombreux processeurs « en silicium » bien concrets.

    On pensera notamment aux :

    • U540, le Hifive Unleashed de la société SiFive (encore 😉), un quadricœur RV64G, avec un cœur RV64I supplémentaire pour la supervision temps réel ; SiFive a sorti un kit de développement permettant d’y faire tourner un Linux compatible desktop ;
    • GAP8 de Greenwaves Technologies, un processeur PULP octocœur pour l’Internet de objet ;
    • K210 de Kendryte, un microcontrôleur chinois double cœur RV64I ;
    • RV32M1 de NXP (eh oui, j’en suis le premier étonné !), un microcontrôleur très spécial, puisqu’il contient un cœur RV32I mais également deux cœurs ARM Cortex-M0 et Cortex-M4.

    Il ne manque plus que le MIPS pour avoir un beau pot‐pourri des processeurs RISC du marché. 😉

    Toutes ces sorties ont commencé à faire très peur aux concurrents, et notamment à son concurrent principal : ARM. Ce dernier a tenté une campagne de dénigrement de RISC-V, avant de très vite se raviser et de lancer une timide « riposte » au travers d’un partenariat avec Xilinx pour fournir gratuitement des Cortex-Mx dans les FPGA de Xilinx.

    Mais RISC-V a également fait bouger l’autre concurrent beaucoup moins connu : MIPS, qui, lui, a… libéré son jeu d’instructions !

    RISC-V reste pour l’instant dans le domaine de l’embarqué et du microcontrôleur, mais la fondation a clairement l’intention de couvrir les domaines des calculateurs et autres ordinateurs centraux (mainframes), domaine où MIPS est déjà un peu plus installé.

    RISC-V arrivera‐t‐il à gagner la bataille des supercalculateurs ? La société ARM adoptera‐t‐elle le jeu d’instructions RISC-V ? Intel sentira‐t‐il le roussi quand RISC-V viendra le titiller sur ses plates‐bandes ? MIPS reviendra‐t‐il dans la course avec son ouverture en open‐source ? Des questions auxquelles nous pourrons peu‐têtre répondre en 2019. Un combat qui promet d’être passionnant.

    Mais une chose est sûre, en 2018, l’open‐source a fait une grande avancée dans le domaine des processeurs grâce à ce jeu d’instructions de l’université de Berkeley !

    Comme j’aimerais voir ça dans le domaine des FPGA ! 😉

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Catégories: Les actus

    GCompris sort en version 0.95

    sam, 22/12/2018 - 10:55

    Nous avons le plaisir de vous annoncer la publication de la nouvelle version de GCompris, le logiciel éducatif pour les enfants de deux à dix ans.

    Cette nouvelle version contient entre autres sept nouvelles activités, listées dans la suite de la dépêche. GCompris propose plus de 150 activités, dont des jeux, toujours avec un objectif pédagogique. Lecture, mathématiques, sciences, géographie et découverte de l’ordinateur sont les thèmes abordés par ces activités. Cette nouvelle version rajoute entre autres le portage et l’amélioration des activités musicales de l’ancienne version (faites par un étudiant lors du GSoC).

    Nouvelles activités :
    • Les nombres binaires : pour apprendre à compter en binaire
    • Assemble le train : pour entraîner la mémoire visuelle
    • Le système solaire : pour apprendre des choses sur notre système solaire
    • Donne un nom à cette note : pour apprendre à reconnaître les notes de musique et leur nom
    • Jouer du piano : pour s’entraîner à lire une partition
    • Battre la mesure : pour s’entraîner à suivre un rythme musical
    • Composition pour piano : pour apprendre à composer une partition musicale
    Autres changements :
    • La traduction de l’ensemble du logiciel a été faite en hongrois et en malayalam. Le basque a aussi été ajouté (traduit à 78 %). GCompris est, dans cette version, traduit entièrement dans quinze langues (anglais britannique, catalan, catalan de Valence, chinois traditionnel, néerlandais, français, galicien, grec, hongrois, italien, malayalam, portugais, roumain, suédois et ukrainien). Il est partiellement traduit (plus de 50 %) dans 19 langues (basque (78 %), biélorusse (69 %), portugais brésilien (74 %), breton (54 %), chinois simplifié (69 %), estonien (63%), finnois (61 %), allemand (86 %), indien (77 %), indonésien (84 %), irlandais gaélique (82%), norvégien (89 %), russe (74 %), écossais gaélique (71 %), slovaque (62 %), slovène (57 %), espagnol (95 %), polonais (94 %), turc (74 %)). Pour la prochaine version, nous retirerons les langues qui n’ont pas un pourcentage de traduction assez élevé ou non maintenues.
    • Possibilité de choisir au moment du lancement (ligne de commande) de lancer en mode OpenGL ou rendu logiciel (avant, le choix était fait à la compilation).
    • Le paquet est déjà disponible sous Nix : nix run -f channel:nixos-unstable-small gcompris (merci Guillaum !)
    Prochaine étape :

    En plus d'ajouter de nouvelles activités, nous travaillons également sur plusieurs autres améliorations : ajouter des jeux de données plus spécifiques par activités (l'enfant pourra choisir, selon l'activité, un jeu de données plus adapté à son âge). Cela implique de modifier les activités pour prendre en entrée un jeu de données en JSON.
    Nous sommes aussi sur la génération d'un guide utilisateur à partir du code source. Nous sommes partis sur un script python utilisant PyLaTeX pour générer du latex et ensuite pouvoir générer du pdf ou html.

    Télécharger ce contenu au format Epub

    Commentaires : voir le flux atom ouvrir dans le navigateur

    Catégories: Les actus

    Dons aux associations, épisode 7

    jeu, 20/12/2018 - 20:10

    Cette dépêche est la septième de sa série, après celles de 2011, 2013, 2014, 2015 et 2016 et 2017

    Pour la septième fois, je m’adresse à toi libriste, qui a procrastiné jusqu’aux dernières heures pour faire des dons déductibles des impôts (ou non). Toute l’année (et celle d’avant) on se promet de soutenir telle ou telle action sur tel ou tel sujet qui nous semblait extrêmement important. Citons par exemple quelques associations de promotion et défense du Libre, des droits dans l’espace numérique ou de la liberté d’expression, dont les dons sont déductibles en France : Amnesty France, Debian France, Framasoft, Fédération internationale des ligues des droits de l’Homme (FIDH), Ligue des Droits de l’Homme (LDH), OpenStreetMap France, Reporters Sans Frontières (RSF), Wikimédia France, etc.

      Sommaire

      Et comme tu fais vivre les principes du Libre, que tu contribues à des projets libres et défends des idées, tu soutiens aussi des associations ne bénéficiant pas de la déductibilité des dons en France (par exemple des associations jugées trop dérangeantes ou trop critiques par le gouvernement… ou des associations européennes ou non, voire des associations n'ayant jamais fait la démarche, comme LinuxFr). Citons par exemple AFUL, April, European Digital Rights (EDRi), En Vente Libre, Exodus Privacy, FACIL,FFII, FSF (avec une longue liste de méthodes pour donner), FSF Europe (déductibilité dans plusieurs pays), Internet Archive (déductible aux États‐Unis), GNOME, KDE e.V (déductible en Allemagne), Léa-Linux, LILA, LQDN, Mageia, Nos Oignons, OKFN, Open Food Facts, SlackBuild.org, Tails (déductible en Allemagne), Toile Libre, Ubuntu-Fr, etc. (notez qu’elles peuvent parfois avoir la déductibilité des dons dans d’autres pays, voir la décision C-318/07 mentionnée plus bas).

      Cette dépêche récurrente vit aussi grâce à vos remarques, propositions d’ajouts, de compléments et vos retours sur les systèmes fiscaux et les dons dans vos pays respectifs. N’hésitez pas à la commenter pour l’enrichir. Bien que récurrente, cette dépêche est mise à jour et enrichie chaque année.

      Précision : la dépêche parle bien de « don » (je soutiens sans rien obtenir à titre personnel), pas de « financement participatif avec contrepartie » (je cofinance en échange de goodies ou avantages), les deux étant destinés à des choses différentes. Pour ceux qui ont lu jusqu’ici, un dessin xkcd sur le sujet en récompense (et d’autres images plus loin pour récompenser les libristes patients qui liront jusqu’au bout).

      Pourquoi les associations ayant des permanents ont des besoins récurrents d’argent ? (tiré de l’épisode 3 mais mis à jour)

      Quand une association veut passer de zéro à un permanent ou à un permanent de plus, elle n’a généralement pas en réserve de quoi le payer sur une année complète. Elle prend donc un risque avec une visibilité sur x mois (comme n’importe quel chef d’entreprise), en faisant de son mieux pour que l’argent rentre (le nouveau permanent va « produire », une campagne de communication ou d’appels à don ou autres sera lancée, une subvention sera recherchée, une convention sera signée avec tel ou tel, des goodies seront vendus, etc.).

      Une association qui ne veut pas s’embêter à rechercher des fonds ou qui ne vise pas à passer le cap du premier permanent n’a pas du tout ce souci et peut être très indolente si elle veut.

      Dès qu’il y a un besoin récurrent de payer des salariés, de payer à date les charges de l’employeur — qu’il faut prévoir à trois mois s’il faut gérer un préavis de licenciement économique ou pas, etc., cela devient plus compliqué (comme pour n’importe quel chef d’entreprise). Une association militante qui ne prendrait pas de risque financier du tout, ce n’est pas envisageable à mon avis. Toute la question étant de savoir combien elle réussit à faire rentrer d’argent au moment où c’est nécessaire, si elle peut continuer à embaucher pour grossir/faire plus d’actions/faire mieux, si elle doit licencier ou si elle doit stagner/continuer ainsi dans l’immédiat.

      Donc oui, on a toujours l’impression que les associations ayant des permanents recherchent de l’argent (et décembre est particulier car c’est la fin de l’exercice fiscal et traditionnellement la période des dons défiscalisés, notamment côté humanitaire associé aux bons sentiments des fêtes de fin d’année). Et oui en décembre, la Croix Rouge, April, RSF, LQDN, la FSF, Amnesty, Framasoft (ok c'était en octobre cette fois) et bien d’autres font des appels à don.

      En dehors de la simple mais cruciale question de la trésorerie (pérennité / continuité), il y a bien évidemment aussi les projets / actions futures à financer. Citons par exemple la justification de Framasoft (9 permanent·e·s) en 6 points :

      1. Parce que l’enfermement, c’est maintenant
      2. Pour plus d’alternatives libres.
      3. Parce que les gentils, c’est nous !
      4. Pour décider où vont vos impôts (avec défiscalisation).
      5. Parce que l’économie du don rend indépendant.
      6. Pour changer le monde ensemble.
      Petit rappel pour ceux concernés par les impôts en France (tiré de l’épisode 5 mais mis à jour)
      • l’article 200 du code général des impôts prévoit pour un particulier une déduction fiscale de 66 % (réduction d’impôt sur le revenu dans la limite de 20 % du revenu imposable, reportable sur cinq ans en cas de dépassement de ce plafond) des dons vers les associations d’intérêt général ou reconnues d’utilité publique. Ce pourcentage monte même à 75 % pour les organismes d’aide aux personnes en difficulté (dans la limite de 521 €, au‐delà, on retombe sur les 66 %) ;
      • l’article 238 bis du CGI prévoit une déduction fiscale de 60 % des dons pour une entreprise (réduction d’impôt sur le revenu ou d’impôt sur les sociétés dans la limite de 5 ‰ du chiffre d’affaires hors taxes, reportable sur cinq ans en cas de dépassement de ce plafond) vers les associations d’intérêt général ou reconnues d’utilité publique ;
      • Fiche pratique ServicePublic.fr : « À savoir : les sommes versées à des organismes agréés situés dans un État membre de l’Union européenne, en Islande ou en Norvège ouvrent également droit à la réduction d’impôt. À défaut d’agrément, vous devez justifier que l’organisme poursuit des objectifs et présente des caractéristiques similaires aux organismes situés en France. »

      Exemple pour un particulier : je suis imposable et donne 99 € à l’association XYZ bénéficiant de la déductibilité des dons à hauteur de 66 %. Mon don me coûte en fait (au final) 33 €, j’ai temporairement avancé 66 € qui seront ensuite déduits de mon imposition fiscale (dit autrement, j’ai choisi l’attribution de 66 € du budget de l’État).

      Autres infos :

      En 2018, il semble que les dons soient en baisse, plus de 6% de baisse sur les dons et 6% de baisse sur le don moyen, selon France Générosités / Recherche & Solidarités, et les raisons évoquées seraient principalement l'instabilité fiscale (prélèvement à la source, hausse de la contribution sociale généralisée (CSG), etc.) et le remplacement de l'impôt sur la fortune (ISF) par l'impôt sur la fortune immobilière (IFI).

      En novembre 2018, le Sénat français avait voté une augmentation de 66 à 70% de la réduction d’impôt (le gouvernement étant contre, elle a été annulé par l'Assemblée après la commission mixte paritaire). Le gouvernement voudrait par ailleurs favoriser les legs, mais la plupart des associations ne sont pas forcément en capacité d'en recevoir de part leurs statuts, ou ne souhaitent pas en recevoir.

      Le changement de l'année 2019 en France est le passage au prélèvement à la source : comme l'explique Framasoft, « rien ne change pour votre réduction d’impôt ».

      Petit rappel pour ceux concernés par les impôts hors France (tiré de l’épisode 5)

      Forcément je connais mieux le sujet pour la France, mais voici néanmoins quelques infos glanées pour d’autres pays (et je ne doute pas que les visiteurs compléteront dans les commentaires) :

      Exemple de dons financiers et parfois de temps (tiré de l’épisode 4, mais mis à jour)

      « Sacrifier une partie de son revenu pour faire un don à une association, c’est une affaire sérieuse. » (patrick_g)

      Liste non exhaustive de dons financiers ou de temps à des associations du Libre ou pour libérer quelque‐chose :

      Exemple de dons de matériel ou ressources (tiré de l’épisode 4 mais mis à jour)

      Liste non exhaustive :

      Diffusion des idées et questionnements autour du don (tiré de l’épisode 4 et mis à jour)

      Liste non exhaustive :

      Don à une entreprise ? (tiré de l’épisode 5)

      Une question un peu annexe ici vu le titre « dons aux associations » mais qui a déjà été posée ici ou sur LinuxFr.org : peut‐on faire un don (sans contrepartie) à une entreprise ? Pour prendre deux sites que j’aime bien : il semblerait que Next INpact (SARL de presse) ait opté pour un statut premium (avec contrepartie donc) parce que ce n’était pas possible, mais bénéficie en plus de dons déductibles via la plate‐forme de dons pour la presse en ligne J’aime l’info (l'appel à dons de décembre 2018 par exemple). Tandis que Reflets.info (SAS) accepte les dons.

      Lors d’une recherche rapide précédente, j’avais vu évoquer l’utilisation du compte 7713 « libéralités perçues » du plan comptable, d’un justificatif clair pour la comptabilité (un expert comptable et/ou un notaire sont évoqués), d’une exonération de TVA si aucune vente de bien/service n’est associée ; bref la question des taxes/impôts à payer pour le donateur (60 % entre non‐parents ?) et l’entreprise n’est pas forcément claire. Cela reste assez flou et hypothétique, et ça mériterait une question aux impôts.

      .

      Logiciels libres pour gérer les dons (tiré de l’épisode 5)

      La question avait été posée lors de l’épisode 3 de cette série de dépêches : quel(s) logiciel(s) libre(s) utiliser pour faire les dons ? Ou pour les gérer ? En général pour les faire, un navigateur fait l’affaire : paiement en ligne, réception de l’éventuel reçu fiscal, réception d’un éventuel message de remerciement.

      Pour les reçus fiscaux, il convient de les conserver avec les documents des impôts pendant le temps nécessaire (suivant la législation locale).

      Pour les dons via des intermédiaires, par exemple Liberapay, HelloAsso ou Tipeee, il faut conserver soigneusement les identifiants du compte créé pour l’année suivante.

      Si vous avez opté pour l’adhésion à une structure plutôt que le don, vous allez recevoir des identifiants aussi et probablement une lettre interne ou des choses du genre, ainsi qu’une convocation à une assemblée générale annuelle certainement.

      Et si vous avez opté pour versement régulier (virement ou prélèvement), ça ne change pas fondamentalement les choses ; éventuellement l’organisme qui prélève vous prévient un peu avant chaque prélèvement par courriel.

      Il existe aussi dans le Libre des logiciels ou des événements spécialement prévus pour les dons :

      À ma connaissance, le site HelloAsso évoqué dans un commentaire de 2015 n’utilise pas une plate‐forme libre, contrairement à Liberapay.

      PS: cette dépêche est ma 400e.

      Télécharger ce contenu au format Epub

      Commentaires : voir le flux atom ouvrir dans le navigateur

      Catégories: Les actus

      Libre en Fête 2019 : c’est parti !

      jeu, 20/12/2018 - 10:46

      Pour la dix‐huitième année consécutive, l’April lance l’initiative Libre en Fête. Pour accompagner l’arrivée du printemps, des événements de découverte des logiciels libres et du Libre en général sont proposés partout en France autour du 20 mars, dans une dynamique conviviale et festive. L’édition 2019 du Libre en Fête se déroulera du samedi 2 mars au dimanche 7 avril inclus.

      À l’occasion du Libre en Fête, tous les groupes d’utilisateurs et utilisatrices de logiciels libres, les espaces publics d’accès à Internet, les bibliothèques, les médiathèques, les clubs informatiques, toutes les associations et structures ayant à cœur la promotion du Libre sont invités à organiser des évènements à destination du grand public. Le site du Libre en Fête donne toutes les informations nécessaires pour participer à l’initiative. Bien sûr, un événement peu avant le 2 mars ou peu après le 7 avril 2019 est le bienvenu aussi.

        Les événements organisés dans le cadre du Libre en Fête peuvent prendre de multiples formes : conférence de découverte, atelier d’initiation à un logiciel libre, à un service libre ou à un projet collaboratif comme Wikipédia ou OpenStreetMap, fête d’installation, exposition de panneaux de sensibilisation comme par exemple l’Expolibre, mise à disposition de postes informatiques sous logiciel libre, de jeux vidéos libres… Bien sûr, il est possible de proposer plusieurs activités au sein d’une même journée de découverte. Et si un fond musical est prévu pour les moments les plus informels, le choix des morceaux diffusés sous licence libre est recommandé. Pour cette édition 2019, l’April propose la thématique optionnelle « la priorité au logiciel libre au quotidien ».

        La coopération entre différentes structures au niveau local est vivement encouragée. Les espaces d’initiation à l’informatique et ses enjeux sont des lieux propices à l’organisation d’évènements de découverte des logiciels libres. Les groupes d’utilisateurs et utilisatrices de logiciels libres peuvent notamment apporter leurs connaissances et leurs expertises. Le Libre en Fête est aussi l’occasion de nouer de nouveaux partenariats et/ou de renforcer des liens existants. Des liens utiles pour la recherche de partenaires sont disponibles sur le site de l’initiative.

        Le référencement d’un événement dans le cadre du Libre en Fête se fait via l’Agenda du Libre, en ajoutant le mot‐clef « libre-en-fete-2019 » (sans l’accent circonflexe) lors de sa soumission.

        Proposer un événement pour le Libre en Fête 2019

        Une liste de discussion a été mise en place pour que les structures participant à l’initiative puissent échanger leurs expériences et idées. L’inscription à cette liste est libre.

        Pour toute question sur le Libre en Fête, il est possible de nous écrire.

        Faites circuler cette annonce, merci !

        Télécharger ce contenu au format Epub

        Commentaires : voir le flux atom ouvrir dans le navigateur

        Catégories: Les actus

        Movim 0.14 « Scotty »

        mer, 19/12/2018 - 19:13

        Movim, le réseau social Libre, a été officiellement annoncé le 18 novembre 2018 en version 0.14. Ce qui suit est une traduction libre du blog de Timothée Jaussoin, l'auteur de Movim.

        Movim a dix ans et c'est avec une grande satisfaction que nous vous apportons cette version, après neuf longs mois de développement.

        Sommaire

        Movim est un nouveau concept de réseau social avec des fonctionnalités de messagerie instantanée qui se situent entre #Instagram et #Whatsapp pour l'expérience utilisateur et les réseaux fédérés tels que #Diaspora ou #Mastodon.

        Il a pour but de réunir en une seule application tout ce qu'il vous faut pour communiquer avec votre communauté, votre classe, votre entreprise ou votre cercle d'amis. Movim peut aisément être déployé sur un serveur et repose sur le protocole XMPP pour la fédération. Movim peut donc, de par sa conception, déjà communiquer avec de nombreux clients Jabber/XMPP et ne nécessite pas la création d'un compte si vous avez déjà un compte XMPP.

        Cette nouvelle version vient avec de multiples changements fondamentaux qui améliorent grandement la stabilité et les performances du projet, mais viennent aussi avec des améliorations du design et de la navigation pour fournir la meilleure expérience relative à la publication de contenu et messagerie.

        Movim et PHP 7.3

        Movim souffre actuellement de problèmes pour tourner sur la prochaine version 7.3 de PHP. C'est un problème connu et documenté qui cause des incompatibilités avec une de nos dépendances officielles sur PHP, php-zmq, qui est utilisé en plusieurs endroits dans le cœur du démon. Un ticket a été ouvert pour suivre et donner des informations sur ce problème : Movim is not working with PHP 7.3.

        Changements techniques

        Avant de présenter les améliorations et nouvelles fonctions, parlons un peu de ce qui change sous le capot.

        Base de données

        Le plus gros changement dans cette version est certainement le remplacement de l'ancienne couche d'abstraction de base de donnée, la bibliothèque Modl spécifique à Movim, par Eloquent qui est largement utilisée.
        Ce travail a été détaillé dans un article précédent : From Modl to Eloquent, or how to change a social network database engine. En résumé, il apporte de la cohérence dans la base de données du projet et d'énormes gains de performance sur toutes les pages.

        Sans avoir de cache, Movim charge maintenant les pages en seulement quelques centaines de millisecondes.

        Cette nouvelle structure de base de données maintient aussi de bonnes performances avec de grandes quantités de données (des millions de messages et des milliers d'articles sur nos pods officiels en ce moment).

        Avec Eloquent, Movim est compatible avec #MySQL, #PostgreSQL, mais aussi, depuis cette version, avec #SQLite qui permet de grandement simplifier le déploiement de petites instances. Merci à JKingweb pour son incroyable travail sur ce portage.

        Empaquetage et dépendances

        Scotty sera la première version à être empaquetée pour le projet #Debian. De grosses améliorations ont été faites sur les dépendances du projet grâce au travail de nos contributeurs mirabilos et nik. Plusieurs dépendances ont été retirées et plusieurs remplacées par des alternatives plus stables et fiables (telles que la bibliothèque SASL, utilisée pour l'authentification). Ce paquet viendra un peu plus tard en raison du problème que nous avons avec PHP 7.3.

        Movim 0.14 est aussi la première version à abandonner la prise en charge de PHP5 (maintenant obsolète) pour se concentrer sur PHP7+.

        Quoi de neuf ?

        Après ces détails techniques barbants, voyons ce que vous allez trouver en tant qu'utilisateur dans cette nouvelle version.

        Publications

        La publication d'articles est plus simple que jamais, et a été totalement reconçue. Vous pouvez rapidement publier un lien ou téléverser une photo via la page d'accueil, ou vous pouvez basculer vers le formulaire plus complet pour écrire un long article (comme celui-ci).

        Quand vous partagez un lien qui contient plusieurs images, vous pouvez choisir celle que vous voulez voir dans la publication (ou aucune image).

        Le changement de visibilité d'une publication a été repensé pour être plus clair.

        Articles

        Les cartes contenant un aperçu des articles ont été entièrement revues pour être plus compactes et adaptées aux écrans plus petits.

        La page des nouvelles, les publications de contacts et les communautés sont maintenant paginées pour permettre une navigation plus simple.

        Si vous recevez des articles contenant des images NSFW et que vous avez demandé de ne pas les afficher dans la configuration, Movim affichera désormais une surcouche d'avertissement par-dessus.

        La fonction de recherche a été améliorée et propose maintenant également les recherches par tags.

        La vitesse de chargement des articles et commentaires a été grandement augmentée. Naviguer entre des articles se fait en un instant.

        Notifications

        Toutes les notifications sont maintenant groupées dans un panneau facilement accessible depuis le menu principal à la fois sur le bureau et sur mobile. Grâce à XMPP, les notifications sont reçues et synchronisées en temps réel.

        Ces notifications contiennent les « like », commentaires, et invitations que vous avez reçus.

        Discussions

        Plusieurs problèmes de synchronisation de messages ont été résolus, permettant à Movim de gérer correctement les accusés de réception et de lecture des messages envoyés.

        Salons

        Les salons ont été légèrement revus, les messages des modérateurs sont maintenant indiqués avec une couleur spécifique. Les messages qui vous sont adressés sont également indiqués avec une couleur de bordure spéciale.


        Vous pouvez maintenant aussi publier des Stickers et émojis dans vos salons favoris.

        Quoi d’autre ?

        Vous pouvez utiliser Movim pour vous authentifier auprès de sites tiers qui utilisent des comptes XMPP. Sur les sites qui implémentent cette fonction, vous avez juste à fournir votre compte XMPP et une notification sera affichée dans Movim.

        Vous avez juste à l'accepter, et vous serez automatiquement authentifié sur le site externe. Peut-on faire plus simple ?

        Plus d'information ici : Journal of a Bot - Authentication with XMPP (en anglais).

        Plusieurs petits bugs ont été corrigés dans la fonction Appel Vidéo. Movim est maintenant plus clair sur l'état de la session vidéo et donne des retours appropriés si le contact raccroche.

        Les photos peuvent être prévisualisées dans Movim avant d'être envoyées en lien externe.

        Autour du projet

        La version repensée du site officiel présentera maintenant plus clairement ce qu'est le projet et toutes les fonctions excitantes qu'on peut utiliser dans Movim.

        Vous y trouverez aussi les apps pour bureau (Windows, MacOS, Linux) et Android.

        Et la suite ?

        Nous n'avons pas encore terminé ! Il y a déjà des plans pour la prochaine version.
        La 0.15 se concentrera sur le protocole de chiffrement de bout en bout OMEMO. Le ticket afférent a été réouvert avec plus d'explications. Ce sera un gros projet risqué.

        Plusieurs améliorations sont à venir basées sur les suggestions dans les salons et les communautés qui permettent aux utilisateurs de Movim d'explorer et découvrir du contenu plus facilement.

        D'ici là, nous vous invitons à essayer cette nouvelle version sur nos instances officielles ou à la déployer sur votre serveur. Vous trouverez tout ce dont vous avez besoin sur le site officiel.

        Vous pouvez aussi nous aider avec des dons au projet ou nous soutenir sur Liberapay et Patreon. Donner votre ressenti ou parler de Movim autour de vous nous aide également beaucoup.

        Voilà pour cette fois !

        Télécharger ce contenu au format Epub

        Commentaires : voir le flux atom ouvrir dans le navigateur

        Catégories: Les actus

        Systèmes d'exploitation pour téléphones. Partie 2 : La lignée Maemo 🔒

        mer, 19/12/2018 - 15:49

        Deuxième dépêche sur les systèmes d'exploitation (plus ou moins) libres pour téléphones. Décortiquons les projets Maemo et MeeGo chez Nokia, le rapprochement raté avec Microsoft, la reprise par la communauté avec l'éclosion du projet fédérateur Mer, la continuité Tizen, l'espoir suscité par Sailfish OS, et pour finir le système d'exploitation libre Nemo Mobile. 🔒📱😍

        Les dépêches :

        1. Les premières initiatives ☎😍
        2. La lignée de Maemo à Nemo 🔒   ← Vous êtes ici
        3. Le libre sur la planète Android 🤖💚
        4. La saga Firefox OS 🦊🚀
        5. Ubuntu sur ordi et téléphones 🖥️📲
        6. D'autres projets récents 🌍
        7. Le frein des brevets logiciels 🤓
        8. Conclusion, synthèse des commentaires 🤷

        Tout est réuni dans un seul article disponible sur deux dépôts Git miroirs : Framagit et GitHub.

        Tu peux nous aider pour les dépêches en cours de rédaction. 📳💟
        Une fois publiées, les dépêches LinuxFr.org restent figées.
        Néanmoins, les dépôts Git pourront accepter tes suggestions d'amélioration 🐔 pendant de nombreuses années. \_^-^_/

          Sommaire Maemo

          En 2005, Nokia publie sa première distribution GNU/Linux (dérivée de Debian) dont l’interface graphique Hildon (un GNOME allégé) utilise le gestionnaire de fenêtres Matchbox et utilise GTK+.

          Nokia 770 Internet Tablet OS 2005 (OS2005) | Nokia N800 Internet Tablet OS 2006 (OS2006) | Nokia N810 OS2007 | OS2008 (Maemo4) | Nokia N900 Maemo5

          Nokia stimule la communauté libre avec maemo.org. Son premier produit, le Nokia 770, est même présenté en avant première au JdLL 2005. Des applications GNU/Linux sont facilement portées comme, par exemple, Tux Paint.

          Dates clés:

          • Nov. 2005 – Tablette Nokia 770 (360 €) avec OS2005, puis OS2006 ;
          • Jan. 2007 – Tablette Nokia N800 avec OS2006 ;
          • Nov. 2007 – Ordinateur de poche Nokia N810 OS2007, puis Maemo4 ;
          • Nov. 2009 – Smartphone Nokia N900 (650 €) avec Maemo5 (et un début de Qt).

          Le N900 a tellement été apprécié (bien mieux que les Nokia sous Windows) qu’une entreprise propose de fabriquer son successeur : le Neo900 (480 €).

          MeeGo, le mariage

          MeeGo est la fusion des projets Maemo (Nokia) et Moblin (Intel) afin de mutualiser leurs investissements. Les deux ancêtres utilisent des interfaces graphiques basées sur GTK+. MeeGo bénéficie d’une nouvelle interface graphique, Handset qui est cette fois-ci basée sur Qt. Nokia profite alors de l’expertise Qt Extended acquise deux ans plus tôt. Handset reste aussi compatible avec les applications GTK+ de Moblin. Pour utiliser la centaine d’applications Maemo, une application Hildon doit être installée par l’utilisateur.

          Pour rappel, Moblin avait été développé à l’origine pour le processeur Intel Atom qui équipait de nombreux netbooks, très à la mode à l’époque. Moblin signifie Mobile linux. Cela permettait aussi à Intel de mettre la pression à Microsoft pour que Windows 7 fonctionne sur les processeurs Intel Atom.

          Qtopia → OPIE (Trolltech) (Communauté) | Qt Extended → QtEI → QtMoko (Nokia) (Communauté) \ Maemo \ Moblin (Nokia) \ (Intel) \_____\______/ | MeeGo (Nokia et Intel)

          Les N9 (600 €) et N950 (jusqu’à 2 000 € sur eBay) était considérés largement supérieurs aux téléphones de l’époque. Pour l’occasion, l’application de navigation Ovi Maps (Maemo) avait été renommée HERE WeGo (wego.here.com). Intel et Nokia ont investi un milliard dans MeeGo.

          Dans sa note interne sur la plateforme pétrolière en feu, le PDG de Nokia expliquait que les concurrents ne piquent pas leurs parts de marché avec des téléphones, mais avec un écosystème. Apple et Google ont chacun réussi à créer un écosystème avec un magasin d’applications, des développeurs, du commerce électronique, des revenus, de la publicité, des applications sociales, des services de géolocalisation…

          Mer, descendance communautaire

          Ce projet a débuté en 2011 et correspond à la bifurcation (fork) de MeeGo par la communauté.

          Qtopia → OPIE (Trolltech) (Communauté) | Qt Extended → QtEI → QtMoko (Nokia) (Communauté) \ Maemo \ Moblin (Nokia) \ (Intel) \_____\______/ | MeeGo (Nokia et Intel) | Mer (Communauté)

          Le projet communautaire est toujours très actif, et cherche à faire le pont entre les projets Tizen et Sailfish OS.

          Tizen, descendance industrielle

          Tizen est officiellement un projet issu et soutenu par la Linux Foundation, à l’instar de son prédécesseur MeeGo. C’est principalement Samsung qui porte financièrement ce projet.

          Qtopia → OPIE (Trolltech) (Communauté) | Qt Extended → QtEI → QtMoko (Nokia) (Communauté) \ Maemo \ Moblin (Nokia) \ (Intel) \_____\______/ | MeeGo (Nokia et Intel) / \ Mer Tizen (Communauté) (Samsung)

          Samsung souhaite intégrer Tizen sur ses produits afin de contourner les limitations d’Android, les contraintes de Google et récolter sans doute une part du gâteau de la vente d’applications.

          Tizen est utilisé sur différentes montres de la marque coréenne. Et Samsung commercialise aussi des téléphones bas de gamme sous Tizen, les Z1 (2015), Z3 (2015), Z2 (2016), Z4 (2017) vendus essentiellement en Inde et au Bangladesh. Le Z1 a été vendu à un million d’exemplaires ce qui est une petite percée assez rare pour un système alternatif.

          En 2017, pour doper l’attractivité du système, Samsung organise un concours avec des gains financiers importants pour les meilleures applications produites pour l’occasion.

          Si Tizen est pour le moment discret dans nos contrées, il a le mérite de progresser régulièrement et d’être soutenu par un grand constructeur qui place déjà ce système un peu partout même en Europe (montres et téléviseurs). Le téléphone sera sans doute le dernier, et le plus délicat palier à franchir.

          Sailfish OS, un nouvel espoir

          Sailfish OS est la continuité de MeeGo par des anciens salariés de Nokia.

          Qtopia → OPIE (Trolltech) (Communauté) | Qt Extended → QtEI → QtMoko (Nokia) (Communauté) \ Maemo \ Moblin (Nokia) \ (Intel) \_____\______/ | MeeGo (Nokia et Intel) / \ Mer Tizen (Communauté) (Samsung) | Sailfish OS (Jolla)

          Jolla vend des appareils sous Sailfish OS

          En février 2011, lorsque le PDG de Nokia publiait sa note interne dans laquelle il comparait Nokia à un homme sur une plateforme pétrolière en feu avec le choix de sauter dans l’eau glacée ou de périr dans les flammes, il ne peut empêcher la commercialisation du Nokia N9 à cause d’une obligation contractuelle avec Intel. Mais il annonce, à la surprise générale, l’annulation du projet MeeGo quel que soit son succès. Bien qu’il ait essayé de saborder sa commercialisation avec plusieurs limitations comme le choix de pays dont la population est peu intéressée, le N9 est un vrai succès.

          En octobre 2011, c’est-à-dire à peu près au moment où un haut dirigeant de Microsoft est nommé CEO de Nokia, des salariés de Nokia ont profité de l’aide à la création d’entreprise pour des départs volontaires (25 000 €), et c’est dans ces conditions qu’une partie de l’équipe MeeGo a quitté Nokia pour fonder l’entreprise Jolla, qui signifie dinghy (ou canot de sauvetage), une petite embarcation de quelques mètres, en référence au saut dans l’eau glacée.

          Bien que la direction de Nokia ait définitivement abandonné MeeGo, celle-ci ne permet pas à Jolla de récupérer les composants non-libres : l’environnement graphique Harmattan et ses applications. Par conséquent, une nouvelle architecture est conçue en collaboration avec la communauté Mer. Malheureusement, Jolla a le même comportement que Nokia et ne publie pas le code source du nouvel environnement graphique. Le nouveau système d’exploitation s’appelle Sailfish OS et partage ses composants libres avec le projet Mer.

          Dès 2011, la Sailfish Business Alliance (SBA) est créée pour rapprocher les entreprises souhaitant que Sailfish OS devienne une alternative à Android et iOS (fabricants, revendeurs, opérateurs, développeurs…). C'est dans l'esprit de la OHA (Android) mais sans aucune obligation. Des restos sont même organisés les premiers et troisièmes jeudis de chaque mois, où chacun paye sa part (le budget SBA est minimal).

          La marque Jolla ne décollera pas malgré des points positifs :

          • Le soutien de Nils Torvalds, père de Linus Torvalds, en 2013 ;
          • La totalité de la production du premier smartphone (2013) est vendue, probablement 50 000 exemplaires, mais la masse critique n'est pas atteinte ;
          • Succès du financement participatif pour la tablette, mais les coûts du développement de Sailfish OS et les difficultés de production sont trop importants pour continuer (2015).

          Le Jolla 1 avec le Fairphone sont les deux derniers smartphones grand public conçus en Europe d’un point de vue matériel. Mais en 2016, Jolla qui avait environ 150 employés a dû licencier, notamment dans les équipes en charge de la partie matérielle. Jolla ne conçoit plus d’appareil, mais se concentre sur Sailfish OS avec une cinquantaine d'employés.

          Jolla ne vend plus que Sailfish OS

          Fin 2015, le Fairphone 2 est commercialisé et la communauté arrive à porter Sailfish OS vers ce smartphone. Début 2016, au MWC (Barcelone), Jolla révèle être en négociation avec la société Fairphone pour équiper ces nouveaux téléphones avec Sailfish OS. Le communiqué de presse cite le DSI de Fairphone (Olivier Hebert) : « Nous sommes emballés à explorer les opportunités de collaboration commerciale avec Jolla ». Nous savons aujourd’hui qu’aucun accord n’avait été trouvé (les Fairphones ne sont pas équipés de Sailfish OS), mais nous n’en connaissons pas la raison. Nous pouvons juste supposer que cela coûtait moins cher à Fairphone de développer leur propre Fairphone OS et Fairphone Open plutôt que de payer Jolla pour Sailfish OS…

          Depuis 2017, Jolla collabore avec Sony dans le cadre du programme Sony Open Devices et commercialise Sailfish X, une ROM à installer sur les Xperia X (F5121 et F5122). D’autres appareils Sony devraient pouvoir tourner sous Sailfish OS, notamment avec l'arrivée de Sailfish OS 3.0.

          Jolla mise tout sur Sailfish OS v3

          Pour la sortie de la v3, Jolla a organisé un grand évènement à Helsinki le 8 novembre 2018, l’équivalent d’une keynote ;-) pour Apple. La grande conférence, fut globalement très appréciée par les fans de Sailfish OS. Par contre, il faudra attendre la fin de l’année 2018 pour avoir toutes les fonctionnalités de cette v3.0.

          Deux versions sont proposées au téléchargement (en) :

          • Sailfish X Free trial, gratuit, moins de fonctionnalités ;
          • Sailfish X, 50 €, compatible avec la JVM Android.

          Nicolas Suffys résume la troisième mouture sur son blog JollaFr qui suit l’aventure Jolla depuis le début :

          • Nouveau menu principal : les paramètres rapides et les raccourcis sont désormais accessibles de partout ;
          • Ambiances : nouveau look ;
          • Chiffrement des données : le chiffrement de la carte mémoire est maintenant disponible. Le chiffrement du système de fichiers du périphérique fera son entrée dans les prochaines versions ;
          • Nouveaux gestes du clavier : changez rapidement la disposition du clavier en un seul geste ;
          • Stockage USB On-The-Go : connectez-vous à différents types de périphériques de stockage externes ;
          • Améliorations de l’appareil photo.
          Alien Dalvik pour avoir les applications Android

          Afin de bénéficier des applications Android, Jolla paye la société franco-suisse Myriad (en) pour intégrer Alien Dalvik (en) à ses ROM. Cette compatibilité Android ne se trouve donc pas dans le portage de Sailfish OS par la communauté sur d’autres téléphones.

          D’après l’annonce de la version 3 Lemmenjoki, le Jolla 1 restera actuellement à un équivalent Android 4.1, les autres smartphones (Jolla C, Intex Aquafish et Xperia X) resteront avec un équivalent 4.4. Jolla ne fait désormais plus que quelques opérations de maintenance sur Alien Dalvik pour l’équivalent 4.4. La version 4.1 du Jolla 1 n’est plus maintenue ce qui engendre de plus en plus de problèmes de compatibilité. Par exemple, Trainline refuse toute connexion en provenance de smartphone inférieur à Android v5.

          Les téléphones pris en charge

          Les téléphones pris en charge sont le Xperia X (F5121 et F5122) mono sim et double sim et depuis la v3 de Sailfish OS moyennant encore quelques limitations (pas de NFC, pas de pilote pour la radio FM…) : les Xperia XA2 dans toutes ses déclinaisons.

          Il semblerait que le Xperia XA2 et ses déclinaisons puissent recevoir une nouvelle couche de compatibilité basée sur Andbox, si l’on en croit le post de juhani@jolla.com dans l’une ses réponses dans le blog de Jolla. Il nous faut attendre les prochaines annonces de Jolla sur ce point. Voir également plus loin dans la nouvelle, le point consacré à Andbox.

          Il est assez remarquable de noter que le Jolla 1, sorti il y a plus de 5 ans désormais est toujours maintenu. Il a reçu la dernière mise à jour avec la version 3.0, étant entendu que les limitations matérielles de ce smartphone font qu’il ne pourra certainement pas bénéficier de tous les avantages de Sailfish X sur les appareils Sony (et notamment la couche Alien Dalvik). En tout cas, le Jolla 1, tout comme le Jolla C, l’Intex Aquafish (converti en Jolla C) et les Xperia X, viennent de recevoir la dernière mise à jour en 3.0.0.8. La release note de la version 3 est disponible.

          Actuellement, sous réserve des limitations liées aux versions d’Alien Dalvik mise en œuvre (4.1 pour le Jolla 1, 4.4.4 pour le Jolla C, l’Intex Aquafish et Xperia X), tous les smartphones sous Sailfish OS, à l’exception des portages, bénéficient de cette machine virtuelle Android fonctionnelle. Ils peuvent exécuter les applications issues des dépôts F-Droid, d’Aptoide et du Google Play Store (comme Google Maps ou Firefox par exemple). De quoi étoffer la quantité d’applications disponibles, étant précisé que pour le Google Play Store, il est parfaitement possible de s’en passer en installant l’application Yalp disponible dans le store Jolla ou F-Droid.

          Le Jolla Phone (the first one et malheureusement the last one) vient de fêter ses 5 ans. Le blog de Jolla en profite pour rappeler les principales expérimentations qui furent faites autour du Jolla phone, dont certaines ont même fait l'objet de petites commercialisations : the other half.

          Il semblerait qu'actuellement sur les 50 000 appareils vendus, 10 000 seraient encore actifs.

          Enfin, pour être complet, deux précisions complémentaires :

          • Jolla est très avare de chiffres, mais affirmer que le Jolla 1 demeure encore à ce jour la plus grosse masse des utilisateurs de Sailfish OS pourrait être considéré comme parfaitement plausible ;
          • La communauté a porté et porte Saifish OS sur tout un tas de smartphones et tablettes dont une liste est disponible. Dans ce cas, Sailfish OS ne contient pas Alien Dalvik pour des problèmes évident de licences et les mises à jour ne se feront pas automatiquement.
          Points à améliorer

          Le navigateur fourni dans Sailfish OS est obsolète et doit être mis à jour.

          Pendant un moment, l'application SailSecure permettait des appels en VoIP (chiffrés), mais cela n'a pas duré. SailSecure était basée sur l'application Android LibreSignal, une bifurcation (fork) de Signal sans les dépendances Google Cloud Messaging. Mais Signal a demandé de ne pas utiliser ses serveurs. Du coup, LibreSignal et SailSecure ont dû arrêter. Donc, pour passer des appels en VoIP, une application Android doit être utilisée : Conversations, Signal

          L'application courriel de Sailfish OS ne permet pas de signer ses courriels avec GPG. Par contre, l'application K-9 Mail est parfaitement opérationnelle, et fait d’ailleurs mieux que l’application de courriels native. Du coup, GPG peut être utilisé grâce à OpenKeychain.
          La gestion des protocoles OpenPGP et S/MIME pour la signature des courriels a été implémentée dans le cadriciel de gestion de courriels hérité de Qt : voir le commit introduisant une nouvelle interface et deux greffons permettant de gérer les signatures électroniques. Plusieurs demandes d'inclusions dans Mer sont en cours de revue pour permettre d'utiliser ces nouvelles capacités depuis le QML et donc à terme l'application de courriel native.
          Par ailleurs, le fonctionnement de GnuPG est en cours d'intégration à l'OS. Quand une application (ou la ligne de commande) utilise le cadriciel GnuPG et demande à l'utilisateur d'entrer des mots de passe, c'est un dialogue système qui est affiché, à la façon dont Gnome-shell ou KDE peuvent le faire.

          L’application modRana était une application très appréciée sur Sailfish OS qui permettait d’avoir la navigation GPS en mode déconnecté (les cartes enregistrées sur le téléphone). Mais celle-ci ne fonctionne plus depuis que Jolla a changé son API. Depuis, les deux équipes ne semblent pas coopérer. :-(
          Une alternative est l’application Android OsmAnd, parfaitement fonctionnelle, sous réserve que Jolla corrige le problème relativement récent de notifications Android qui vient quelque peu polluer le haut de l’écran et de fait, vient masquer régulièrement la direction à prendre. Une vraie application native serait cependant préférable. OsmAnd est encore capable de tourner avec le Jolla 1 mais avec son 1 Go de RAM et son petit processeur, faut juste être patient, surtout quand il faut recalculer l’itinéraire. ;-)

          Une demande récurrente des clients est d'améliorer la qualité du magasin d’applications pour Sailfish OS, car il y a trop d’applications abandonnées et de qualité médiocre. Il faudrait que tous ceux qui le souhaitent viennent donner un coup de main. Tel est le cas par exemple de l’excellente application gPodder.

          Le magasin d'applications Openrepos complète le magasin officiel géré par Jolla. Mais les applications que nous y trouvons sont considérées comme instables/expérimentales, bien que certaines finissent par rejoindre le magasin officiel. Les auteurs de cette dépêche ne s’en sont jamais servi, les mises à jours de Sailfish OS pouvant être problématiques. En effet, il semble qu’il faille désactiver Openrepos avant de faire une mise à jour.

          Rappelons que Jolla c’est une petite équipe qui tâche de résister à la pression des GAFAM. Un article sur Engadget, aux titre et sous titre évocateurs, leur a été consacré. Jolla n’a pas la capacité financière de mener tous les fronts simultanément et cherche vraisemblablement à faire évoluer ce qui leur parait prioritaire. Par exemple le forum TJC est toujours dans une ancienne version et Jolla n’a pas encore pu le faire évoluer. La version 3.0.1 de Sailfish OS est désormais sur les rails.

          Russie

          La Russie a maintes fois montré son intérêt pour cet OS, qui a le mérite de ne pas être étasunien (contrairement à Android, iOS et Windows Phone) et sans doute la proximité culturelle et géographique avec la Finlande où est basée Jolla. D’ailleurs, la Poste russe a décidé de faire un appel d’offre pour équiper son personnel avec ce système. Cela permettrait à Jolla de bénéficier d’entrées financières importantes et de développer son activité.

          Depuis 2018, Jolla est manifestement devenue une entreprise détenue d’un point de vue capitalistique « russe ». En suivant le fil de discussion, vous trouverez un schéma permettant de visualiser l’organisation capitalistique de Jolla. En outre, la Russie tache de construire son propre système d’exploitation pour smartphones à partir d’Open Mobile Platform. Pouvons-nous parler d’un fork ? Quel est le degré de collaboration entre Open Mobile Platform et Jolla ? Mais soyons clairs  : ce sont les Russes qui ont permis à Jolla de ne pas sombrer.

          La première tablette russe intégrant un processeur ARM Salyut-EL24PM (en 40nm !!!) et Sailfish OS serait actuellement présentée par une entreprise russe.

          Cela est par ailleurs amusant, si Tizen est soutenu par un grand constructeur, Jolla le serait par un grand État. De quoi garantir à ces systèmes peut-être plus de possibilités de réussir dans ce marché. À suivre…

          Sailfish OS n’est pas 100 % libre

          Notons que Sailfish OS n’est pas un système libre, toute la couche graphique ne l’est pas. Et certaines applications maisons ne le sont pas non plus, même si l’ensemble repose sur les technologies libres.

          Il est peut-être possible de considérer Sailfish OS comme certainement une des alternatives les plus abouties, mais qui reste encore à la moitié du gué. La compatibilité Android n’est qu’un pis aller pour combler les lacunes du store Jolla en applications natives. Il peut être considéré comme regrettable que certaines grosses entreprises en France et en Europe qui se plaignent des positions dominantes du GAFAM ne cherchent pas à promouvoir ce système conçu en Finlande, c’est-à-dire en Europe. Et le basculement « russe » risque de ne pas aider, compte tenu des tensions diplomatiques actuelles.

          Une partie de la communauté semble regretter qu’aucun accord de licence et/ou de collaboration puisse intervenir entre Jolla et l'entreprise finnoise HMD Global, cette dernière étant constituée d’anciens collaborateurs provenant de Nokia et de Microsoft et qui a repris, suite à l’échec de Microsoft sur ce marché, la fabrication sous licence Nokia/Android de téléphones et smartphones sous la marque Nokia. Des regrets que l’on peut retrouver sur TJC ou dans le blog de Jolla.

          Beaucoup regrettent l’abandon par Jolla de la partie matérielle du smartphone. Le Jolla 1 était ouvert aux bricolages de toute nature grâce à des contacts électriques disponibles sous le capot. Il n’avait pas de récepteur FM ? Qu’à cela ne tienne, des hackers s’étaient penchés sur la question. Vous vouliez un clavier intégré ?

          Enfin précisons que l’un des fondateurs et ex-président de Jolla, Antti Saarnio, travaille désormais sur les écosystèmes sur mobile et la blockchain au travers notamment de Zippie OS. Opère-t-il depuis Jolla Honk Kong ? Le site web de Zippie ne contenant pas de mention légale, ne nous permet pas de l’affirmer. A priori non, si l’on en croit la FAQ. Jolla fait partie des partners de Zippie.

          La documentation pour les développeurs se trouve sur le site de Sailfish OS ainsi que le schéma de l’architecture.

          Nemo Mobile, le petit dernier

          Nemo Mobile est un effort de la communauté Mer pour obtenir un équivalent de Sailfish OS complètement libre, notamment avec le projet Glacier UX qui consiste à réécrire sous licence libre, une couche graphique comme celle de Sailfish OS.

          Necuno Solutions a annoncé le 10 décembre dernier une collaboration avec Nemo Mobile puis le 12 décembre avec Replicant. Leur objectif principal est de travailler vers un écosystème mobile plus ouvert, transparent et sûr. Selon leur site internet, l'objectif de Necuno Solutions est de fournir un choix alternatif aux utilisateurs pour qu'ils aient le contrôle de leur appareil mobile. Necuno Solutions est également une entreprise finlandaise. Est elle montée par des anciens de Jolla en charge de la partie matérielle et licenciés en 2016 ? Un nouveau projet à suivre ? En cherchant un peu plus, nous remarquons que Necuno Solutions "collabore" avec beaucoup d'autres projets : KDE/Plasma, Maemo …et peut nous interroger sur la pérennité et la solidité de cette entreprise.

          Niveau Dépôt Git Environnement graphique https://github.com/nemomobile-ux Couches basses https://github.com/nemomobile Qtopia → OPIE (Trolltech) (Communauté) | Qt Extended → QtEI → QtMoko (Nokia) (Communauté) \ Maemo \ Moblin (Nokia) \ (Intel) \_____\______/ | MeeGo (Nokia et Intel) / \ Mer Tizen (Communauté) (Samsung) / | \ Sailfish OS Nemo \ (Jolla) Mobile AsteroidOS (Communauté)

          Un cousin, AsteroidOS est également dans l’arbre généalogique, mais celui-ci n’est pas pour les téléphones. AsteroidOS est une alternative à Wear OS, essentiellement pour les montres connectées, comme ce financement participatif pour une montre connectée française. Notons aussi que depuis 2016, Sailfish OS réutilise des concepts d’AsteroidOS pour le projet Sailfish watch (en).

          Conclusion

          Ceci n’est pas le chapitre conclusion. 😮

          Ah, mais elle est où la conclusion ? 🤔

          Ben… dans les commentaires ! 😜

          Et oui, chacun à son avis : les échecs, les spéculations, les succès, le positif…

          Restons bienveillants dans nos réactions : même si nos arguments sont différents, nous sommes tous globalement d’accord pour avoir davantage de contrôle sur nos téléphones, pas besoin d’utiliser des mots agressifs. 😘 😍

          Appel à participation

          Tu as aimé cette épopée entre logiciels libres et téléphones, cette tumultueuse aventure au travers des articles LinuxFr.org, témoignages à jamais gravés dans le marbre, reflets de nos enthousiasmes, nos déceptions et nos espérances ?

          Tu peux nous aider par différents moyens :

          • Indique-nous dans les commentaires tes idées pour aider ces projets, du moins ceux qui te tiennent à ♥ ;
          • Si tu souhaites améliorer les articles Wikipédia, sache que cette dépêche a été spécialement publiée sous licence CC BY-SA 3.0 car Wikipédia hésite à passer à la 4.0 depuis deux ans ;
          • D’autres dépêches de cette série d’articles sont peut-être encore en cours de rédaction, tu peux nous rejoindre dans l’espace de rédaction ;
          • Une autre ambitieuse dépêche se prépare également : Quel téléphone mobile en 2019 ?

          Note que pour limiter le pourriel (spam), tu dois te créer un compte pour accéder à l’espace de rédaction. Tu peux aussi jeter un œil sur comment participer à LinuxFr.

          Liste des auteurs

          Cette dépêche en plusieurs parties à suivre est une œuvre collective. Mais les coupés-collés entre les parties ne permettent pas de garder automatiquement une trace de toutes les contributions. Que les auteurs soient donc remerciés, en particulier Nicolas Suffys qui nous a autorisé à reproduire un extrait de son article sur Sailfish, mais aussi oliver_h, TuxMips, BAud, teoB, quent57, RyDroid, Christophe Chapuis, Adrien Dorsaz, karteum59, pulkomandy, Trollnad Dump, gle, xev, ZeroHeure, Intendant_zonard, Benoît Sibaud, ʭ ☯ , j, Maderios, palm123, Thomas Debesse, Brndan, raphj, Franck Routier, be_root, Bruno Michel, Goffi, hitmanu, olibre et guitou

          Cette dépêche est sous licence CC BY-SA 3.0.

          Télécharger ce contenu au format Epub

          Commentaires : voir le flux atom ouvrir dans le navigateur

          Catégories: Les actus

          Comparaison de technologies Web pour implémenter une application de dessin basique

          mar, 18/12/2018 - 15:27

          Les applications web actuelles tendent à réaliser une grande part des traitements côté client (frontend) et à réduire au maximum la partie côté serveur (backend). Un exemple classique est l'application mono-page (Single-Page Application), où la gestion de l'interface et des données est réalisée principalement côté client avec, quand c'est nécessaire, des requêtes serveurs (AJAX, websockets…). Pour implémenter ce genre d'applications, on utilise généralement un framework frontend comme AngularJS, Vue.js, React/Redux… Ces frameworks proposent une architecture de base (MVC, flux…) qui permet d'implémenter facilement une application classique de présentation et de manipulation de données.

          L'objectif de cet article est de comparer quelques technologies pour réaliser une application un peu plus interactive : une application de dessin basique. Les technologies considérées ici sont JavaScript (sans bibliothèque), Haskell Miso (framework frontend), C++ Wt (framework fullstack basé widgets) et WebAssembly.

            Sommaire

            code source

            L'application à réaliser

            On veut implémenter une application basique permettant de dessiner à la souris. Des curseurs permettent de régler la couleur et la taille de la brosse de dessin. La brosse est illustrée dynamiquement en fonction de ses paramètres. Enfin un bouton permet de nettoyer la zone de dessin.

            application en ligne

            A priori, cette application ne pose pas de difficulté particulière. Les données à manipuler sont essentiellement les paramètres de la brosse et l'état du canevas de dessin. Pour le dessin en lui-même, il suffit de détecter quand le bouton de la souris est appuyé et de tracer des lignes entre les positions successives du pointeur.

            En JavaScript

            JavaScript possède toute les fonctionnalités nécessaires pour implémenter notre application dans un navigateur web : input de type range pour les réglages de la brosse, canvas HTML5 pour les dessins dynamiques, fonctions de rappels pour gérer les événements. Commençons par créer l'interface en HTML :

            <!DOCTYPE html> <html> <head> <meta charset="UTF-8"/> </head> <body> <h1>Draw</h1> <!-- the range elements (R, G, B and radius) --> <p> R <input type="range" min="0" max="255" value="0" id="input_r"> </input> <span id="span_r"> </span> </p> <p> G <input type="range" min="0" max="255" value="0" id="input_g"> </input> <span id="span_g"> </span> </p> <p> B <input type="range" min="0" max="255" value="0" id="input_b"> </input> <span id="span_b"> </span> </p> <p> radius <input type="range" min="2" max="50" value="10" id="input_radius"> </input> <span id="span_radius"> </span> </p> <!-- the canvas for previewing the brush --> <p> <canvas id="canvas_brush" width="100" height="100"> </canvas> </p> <!-- the canvas for drawing --> <p> <canvas id="canvas_draw" width="640" height="480" style="border:1px solid black"> </canvas> </p> <!-- the button for clearing canvas_draw --> <p><button id="button_clear"> Clear </button></p>

            Ajoutons quelques fonctions utilitaires, en JavaScript, pour récupérer la position de la souris à l'intérieur du canevas de dessin et pour convertir les 3 valeurs RGB des curseurs en couleur HTML hexadécimale.

            <script> // find position in canvas, from mouse event function getXY(canvas, evt) { const rect = canvas.getBoundingClientRect(); const x = evt.clientX - rect.left; const y = evt.clientY - rect.top; return {x, y}; } // convert color from RGB triplet to hex code // for example: 255, 0, 255 -> '#FF00FF' function componentToHex(c) { const hex = Number(c).toString(16); return hex.length == 1 ? "0" + hex : hex; } function rgbToHex(r, g, b) { return "#" + componentToHex(r) + componentToHex(g) + componentToHex(b); } </script>

            On peut alors implémenter les fonctions de rappels pour le dessin proprement dit. Lorsqu'on appuie sur le bouton de la souris (onmousedown) dans le canevas de dessin, on récupère les paramètres actuels de la brosse et on initialise la fonction de rappel onmousemove de façon à effectuer le dessin. Lorsqu'on relâche le bouton de la souris (onmouseup), on enlève la fonction de rappel onmousemove pour arrêter le dessin. Pour le bouton de nettoyage, une fonction de rappel sur onclick suffit.

            <script> // start drawing canvas_draw.onmousedown = function(evt0) { // get brush parameters from range elements const r = Number(input_r.value); const g = Number(input_g.value); const b = Number(input_b.value); const color = rgbToHex(r, g, b); const radius = Number(input_radius.value); // get canvas context and initial position const ctx = canvas_draw.getContext("2d"); let p0 = getXY(canvas_draw, evt0); // set callback function for mousemove event canvas_draw.onmousemove = function(evt1) { // draw a line from previous position to current position const p1 = getXY(canvas_draw, evt1); ctx.beginPath(); ctx.strokeStyle = color ctx.fillStyle = color; ctx.lineWidth = 2 * radius; ctx.lineCap = "round"; ctx.moveTo(p0.x, p0.y); ctx.lineTo(p1.x, p1.y); ctx.fill(); ctx.stroke(); // update position p0 = p1; }; }; // remove callback function when mouse up canvas_draw.onmouseup = function(evt) { canvas_draw.onmousemove = {}; }; // clear canvas_draw when clicking on button_clear button_clear.onclick = function() { const width = canvas_draw.clientWidth; const height = canvas_draw.clientHeight; const ctx = canvas_draw.getContext("2d"); ctx.beginPath(); ctx.clearRect(0, 0, width, height); ctx.stroke(); }

            Enfin, pour réagir dynamiquement aux curseurs de réglages de la brosse, on leur connecte la fonction de rappel updateDom, qui met à jour les valeurs affichées ainsi que l'illustration de la brosse.

            // update HTML elements (RGB span, canvas_brush) function updateDom() { // get values from range inputs const r = input_r.value; const g = input_g.value; const b = input_b.value; const radius = input_radius.value; const color = rgbToHex(r, g, b); // update span texts span_r.innerHTML = r; span_g.innerHTML = g; span_b.innerHTML = b; span_radius.innerHTML = radius; // draw brush in canvas_brush const ctx = canvas_brush.getContext("2d"); ctx.beginPath(); ctx.strokeStyle = color ctx.fillStyle = color; ctx.clearRect(0, 0, 100, 100); ctx.arc(50, 50, radius, 0, 2*Math.PI); ctx.fill(); ctx.stroke(); } updateDom(); // set callback functions on HTML elements input_r.oninput = updateDom; input_g.oninput = updateDom; input_b.oninput = updateDom; input_radius.oninput = updateDom; </script> </body> </html>

            Le fichier obtenu (draw_js/index.html) est assez concis, environ 130 lignes. Pour cette application, il y a peu d'éléments et d'événements à gérer donc le code reste lisible mais on imagine aisément qu'il va rapidement se compliquer si l'application grossit. On notera également que le typage dynamique de JavaScript permet une grande flexibilité mais rend la détection d'erreur assez délicate; la mise en place de tests automatisés devient vite indispensable.

            En Haskell Miso (framework frontend)

            On arrive ici à un point essentiel de l'article, à savoir si l'utilisation d'un framework frontend est pertinente pour une application qui sort un peu du schéma ordinaire « présentation/modification de données ». Comme je ne connais pas bien les frameworks JavaScript, j'ai choisi Miso, qui permet de coder en Haskell et de transpiler vers du JavaScript via Ghcjs. Miso est tout de même assez comparable aux autres frameworks :
            il implémente une architecture classique (inspirée de Elm/Redux), et les frameworks classiques utilisent souvent des extensions à JavaScript voire un autre langage (TypeScript, Elm…).

            Pour implémenter l'application de dessin avec Miso, on définit les composants de l'application : modèle, actions, fonction de rendu de la vue, fonction de mise à jour. Ici, le type Model contient les paramètres de la brosse ainsi que « l'état du dessin » (dessin en cours ou non, position précédente du pointeur). Le type Action définit les événements que peut générer la vue et qu'il faut traiter lors de la mise à jour (nettoyage du canvas de dessin, modification de la brosse ou du canvas de dessin…).

            {-# LANGUAGE OverloadedStrings #-} import Control.Monad (when) import Data.Map (singleton) import JavaScript.Web.Canvas import Miso import Miso.String hiding (singleton) main :: IO () main = startApp App { initialAction = UpdateBrushOp , update = updateModel , view = viewModel , model = Model 0 0 0 10 (0, 0) False , subs = [ mouseSub UpdateDrawOp ] , events = defaultEvents , mountPoint = Nothing } data Model = Model { modelR :: Int -- brush color , modelG :: Int , modelB :: Int , modelRadius :: Int -- brush radius , modelXy :: (Double, Double) -- last position inside drawing canvas , modelDrawing :: Bool -- drawing state } deriving (Eq) data Action = NoOp | ClearDrawOp -- request clearing canvas_draw | UpdateBrushOp -- update canvas_brush | UpdateDrawOp (Int, Int) -- update canvas_draw | UpdateDrawingOp Bool -- update drawing state | UpdateFormOp (Model -> MisoString -> Model) MisoString -- update a range element | UpdateXyOp (Double, Double) -- update last position

            Pour générer la vue, la fonction viewModel suivante crée les éléments de l'interface et connecte les événements aux actions déclarées précédemment. La fonction mkRange permet de créer un curseur pour les réglages de la brosse (le paramètre op est une fonction permettant de mettre à jour la valeur associée au curseur, sans avoir à dupliquer les actions). Les fonctions jsCtx, jsRectLeft, etc interfacent du code JavaScript qui n'est pas géré directement par Miso.

            -- create a range element mkRange :: MisoString -> Int -> Int -> Int -> (MisoString -> Action) -> View Action mkRange title vmin vmax v op = p_ [] [ text title , input_ [ type_ "range" , onInput op , min_ (toMisoString vmin) , max_ (toMisoString vmax) , value_ (toMisoString v) ] , text (toMisoString v) ] -- create view viewModel :: Model -> View Action viewModel (Model r g b radius _ _) = span_ [] [ h1_ [] [ text "draw" ] , mkRange "R" 0 255 r (UpdateFormOp (\ m v -> m { modelR = fromMisoString v })) , mkRange "G" 0 255 g (UpdateFormOp (\ m v -> m { modelG = fromMisoString v })) , mkRange "B" 0 255 b (UpdateFormOp (\ m v -> m { modelB = fromMisoString v })) , mkRange "radius" 2 50 radius (UpdateFormOp (\ m v -> m { modelRadius = fromMisoString v })) , p_ [] [ canvas_ [ id_ "canvas_brush" , width_ "100" , height_ "100" ] [] ] , p_ [] [ canvas_ [ id_ "canvas_draw" , width_ "600" , height_ "300" , style_ (singleton "border" "1px solid black") , onMouseDown (UpdateDrawingOp True), onMouseUp (UpdateDrawingOp False) ] [] ] , p_ [] [ button_ [ onClick ClearDrawOp ] [ text "Clear" ] ] ] -- bind javascript foreign functions for accessing canvas foreign import javascript unsafe "$r = document.getElementById($1).getContext('2d');" jsCtx :: MisoString -> IO Context foreign import javascript unsafe "$r = canvas_draw.getBoundingClientRect().left;" jsRectLeft :: IO Int foreign import javascript unsafe "$r = canvas_draw.getBoundingClientRect().top;" jsRectTop :: IO Int foreign import javascript unsafe "$r = canvas_draw.clientWidth;" jsWidth :: IO Int foreign import javascript unsafe "$r = canvas_draw.clientHeight;" jsHeight :: IO Int

            Enfin, la mise à jour du modèle est implémentée par la fonction updateModel suivante. Pour les actions UpdateBrushOp, ClearDrawOp et UpdateDrawOp, on met à jour les canvas correspondant. Pour les actions UpdateXyOp, UpdateFormOp et UpdateDrawingOp, on met à jour les champs correspondant du modèle. On notera que UpdateDrawOp et UpdateFormOp génèrent des actions à la fin de leur traitement (respectivement, pour mettre à jour la nouvelle position du curseur et pour mettre à jour le dessin de la brosse).

            updateModel :: Action -> Model -> Effect Action Model updateModel UpdateBrushOp m@(Model r g b radius _ _) = m <# do ctx <- jsCtx "canvas_brush" clearRect 0 0 100 100 ctx lineWidth 1 ctx strokeStyle r g b 255 ctx fillStyle r g b 255 ctx beginPath ctx arc 50 50 (fromIntegral radius) 0 (2*pi) True ctx fill ctx stroke ctx pure NoOp updateModel ClearDrawOp m = m <# do ctx <- jsCtx "canvas_draw" w <- jsWidth h <- jsHeight clearRect 0 0 (fromIntegral w) (fromIntegral h) ctx pure NoOp updateModel (UpdateDrawOp (x1, y1)) m@(Model r g b radius (x0, y0) drawing) = m <# do ctx <- jsCtx "canvas_draw" left <- jsRectLeft top <- jsRectTop let x1' = fromIntegral $ x1 - left let y1' = fromIntegral $ y1 - top when drawing $ do lineWidth 0 ctx strokeStyle r g b 255 ctx fillStyle r g b 255 ctx lineWidth (fromIntegral $ 2*radius) ctx lineCap LineCapRound ctx beginPath ctx moveTo x0 y0 ctx lineTo x1' y1' ctx stroke ctx pure $ UpdateXyOp (x1', y1') -- request to update drawing position updateModel (UpdateXyOp xy) m = noEff m { modelXy = xy } -- update the field modelXy updateModel (UpdateFormOp mFunc value) m = mFunc m value <# pure UpdateBrushOp updateModel (UpdateDrawingOp drawing) m = noEff m { modelDrawing = drawing } updateModel NoOp m = noEff m

            Le code obtenu (draw_miso/Main.hs) est à peu près aussi concis que le code JavaScript précédent (environ 125 lignes + le fichier d'appel draw_miso/index.html). En revanche, grâce à l'architecture demandée par le framework, il semble plus lisible et plus adapté aux applications complexes.

            Concernant le langage Haskell et le framework Miso, on notera que le typage statique fort est très appréciable à l'usage car il permet de détecter une bonne partie des erreurs facilement et précocement. Par contre, la transpilation de Haskell vers JavaScript est assez lente et produit du code assez lourd.

            En C++ Wt

            Wt est un framework C++ fullstack basé widgets. Il permet d'écrire des applications web dans un style proche de Qt ou Gtkmm pour des applications desktop. Ceci peut être intéressant pour un développeur déjà habitué à ce style de programmation ou si l'application a également besoin de traitements côté serveur.

            Wt possède des widgets assez évolués, notamment WPaintedWidget pour le dessin. Pour notre application, on dérive une classe Canvas pour ajouter une brosse paramétrable et un chemin en cours de tracé.

            #include <Wt/WApplication.h> #include <Wt/WContainerWidget.h> #include <Wt/WEnvironment.h> #include <Wt/WPaintedWidget.h> #include <Wt/WPainter.h> #include <Wt/WPushButton.h> #include <Wt/WSlider.h> #include <Wt/WTemplate.h> #include <Wt/WText.h> using namespace std; using namespace Wt; // a canvas with a pen for drawing pathes class Canvas : public WPaintedWidget { protected: WPen _pen; // current pen (color + width) WPainterPath _path; // current path public: Canvas(int penWidth, int width, int height) : WPaintedWidget() { resize(width, height); _pen.setWidth(penWidth); _pen.setCapStyle(PenCapStyle::Round); _pen.setJoinStyle(PenJoinStyle::Round); } // set the width of the pen void setWidth(int w) { _pen.setWidth(w); } // set the color of the pen // updateFunc defines how to update color (for example, modify the red channel) void setColor(function<void(WColor & c)> updateFunc) { WColor color = _pen.color(); updateFunc(color); _pen.setColor(color); } // clear canvas void clear() { _path = WPainterPath(); update(); } };

            Pour l'affichage de la brosse, on dérive CanvasBrush de Canvas et on redéfinit la fonction d'affichage de façon à dessiner un point central avec la brosse courante.

            // canvas for previewing the brush class CanvasBrush : public Canvas { public: CanvasBrush(int penWidth) : Canvas(penWidth, 50, 50) {} private: // paint event: draw a point in the middle of the canvas void paintEvent(WPaintDevice * paintDevice) override { WPainter painter(paintDevice); painter.setPen(_pen); _path.moveTo(25, 25); _path.lineTo(25, 25); painter.strokePath(_path, _pen); } };

            Pour la gestion du dessin, on dérive CanvasDraw de Canvas et on définit les fonctions de rappel et d'affichage. On notera les connexions signal-slot, très classiques dans les frameworks desktop.

            // canvas for drawing class CanvasDraw : public Canvas { public: CanvasDraw(int penWidth, int width, int height) : Canvas(penWidth, width, height) { WCssDecorationStyle deco; deco.setBorder(WBorder(BorderStyle::Solid)); setDecorationStyle(deco); // connect event handlers mouseDragged().connect(this, &CanvasDraw::mouseDrag); mouseWentDown().connect(this, &CanvasDraw::mouseDown); } private: void paintEvent(WPaintDevice * paintDevice) override { // draw current path WPainter painter(paintDevice); painter.setPen(_pen); painter.drawPath(_path); } void mouseDown(const WMouseEvent & e) { // start path from current position Coordinates c = e.widget(); _path = WPainterPath(WPointF(c.x, c.y)); } void mouseDrag(const WMouseEvent & e) { // add current position into the path Coordinates c = e.widget(); _path.lineTo(c.x, c.y); update(PaintFlag::Update); } };

            On implémente également un curseur avec affichage de sa valeur, pour les paramètres de la brosse de dessin. La méthode setUpdateFunc permet de spécifier la fonction à appeler, lorsque le curseur est modifié, pour mettre à jour la variable correspondante.

            // slider that prints its value and calls and updating function when moved class Slider : public WContainerWidget { private: WSlider * _slider; WText * _text; public: Slider(const string & title, int vmin, int vmax, int vinit) { addWidget(make_unique<WText>(title)); _slider = addWidget(make_unique<WSlider>()); _text = addWidget(make_unique<WText>(to_string(vinit))); _slider->setRange(vmin, vmax); _slider->setValue(vinit); } void setUpdateFunc(function<void(int)> updateFunc) { _slider->sliderMoved().connect([=](int v) { // call updating function updateFunc(v); // update slider text _text->setText(to_string(v)); }); } };

            Enfin, on crée l'application complète à partir d'un template et des éléments définis précédemment.

            // main template of the application const string APP_TEMPLATE = R"( <h1>Draw</h1> <p> ${slider_r} </p> <p> ${slider_g} </p> <p> ${slider_b} </p> <p> ${slider_width} </p> <p> ${canvas_brush} </p> <p> ${canvas_draw} </p> <p> ${button_clear} </p> )"; struct App : WApplication { App(const WEnvironment & env) : WApplication(env) { auto tmpl = root()->addWidget(make_unique<WTemplate>(APP_TEMPLATE)); auto canvasBrush = tmpl->bindWidget("canvas_brush", make_unique<CanvasBrush>(10)); auto canvasDraw = tmpl->bindWidget("canvas_draw", make_unique<CanvasDraw>(10, 640, 480)); auto clearButton = tmpl->bindWidget("button_clear", make_unique<WPushButton>("Clear")); clearButton->clicked().connect(canvasDraw, &CanvasDraw::clear); // add a slider for the red color channel of the pen auto sliderR = tmpl->bindWidget("slider_r", make_unique<Slider>("R", 0, 255, 0)); // set an updating function that assigns the value v to the red channel sliderR->setUpdateFunc([=](int v) { canvasDraw->setColor([v](WColor & c) { c.setRgb(v, c.green(), c.blue()); }); canvasBrush->setColor([v](WColor & c) { c.setRgb(v, c.green(), c.blue()); }); canvasBrush->update(); }); // add sliders for G and B // ... auto sliderWidth = tmpl->bindWidget("slider_width", make_unique<Slider>("Width", 2, 50, 10)); sliderWidth->setUpdateFunc([=](int v) { canvasDraw->setWidth(v); canvasBrush->setWidth(v); canvasBrush->update(); }); } }; // start the application int main(int argc, char ** argv) { auto mkApp = [](const WEnvironment& env) { return make_unique<App>(env); }; return WRun(argc, argv, mkApp); }

            Le fichier obtenu (draw_wt/draw.cpp) est un peu plus long que le code en JavaScript (environ 180 lignes, soit un tiers de plus). Dans l'implémentation proposée ici, les données sont mises à jour directement depuis les éléments de la vue. Pour une application plus complexe, on implémenterait plutôt une vraie architecture MVC classique.

            En WebAssembly

            Le WebAssembly permet d'intégrer, dans une page web, du code issu de langage comme C, C++ ou Rust, avec des performances plus élevées qu'en JavaScript.

            Première implémentation

            Dans cette première implémentation avec WebAssembly, l'application est principalement codée en HTML/JavaScript. Seuls les traitements « lourds » sont codés en C++ puis compilés en wasm.

            Pour cela, on définit une classe MyCanvas qui implémente les fonctions de dessin et gère sa propre mémoire (attention, l'implémentation fournie, draw_wasm/draw.cpp, n'est pas du tout optimale). La classe et les méthodes nécessaires sont ensuite exportées pour être appelées depuis le code JavaScript.

            #include <emscripten/bind.h> #include <cmath> #include <iostream> struct Color { uint8_t _r; uint8_t _g; uint8_t _b; uint8_t _a; }; class MyCanvas { private: // canvas properties int _width; int _height; std::vector<Color> _data; // pen properties Color _color; int _squareRadius; public: MyCanvas(int width, int height) : _width(width), _height(height), _data(width*height) { clear(); } void clear() { memset(_data.data(), 255, _width*_height*sizeof(Color)); } emscripten::val getData() { // get C++ data for filling a JS array size_t s = _data.size()*4; uint8_t * d = (uint8_t *) _data.data(); return emscripten::val(emscripten::typed_memory_view(s, d)); } void initDraw(int r, int g, int b, int radius) { // set current pen properties _squareRadius = radius*radius; _color = {uint8_t(r), uint8_t(g), uint8_t(b), 255}; } // draw a line from (x0, y0) to (x1, y1) void draw(int x0, int y0, int x1, int y1) { // ... } private: // draw a disc at (evt_x, evt_y) using current pen (_color + _squareRadius) void drawDisc(int evt_x, int evt_y) { // ... } }; // export MyCanvas to JS EMSCRIPTEN_BINDINGS(MyCanvas) { emscripten::class_<MyCanvas>("MyCanvas") .constructor<int, int>() .function("clear", &MyCanvas::clear) .function("initDraw", &MyCanvas::initDraw) .function("draw", &MyCanvas::draw) .function("getData", &MyCanvas::getData); }

            Le code C++ précédent peut alors être compilé par emscripten. On obtient le code wasm correspondant ainsi que l'interface draw.js permettant d'appeler les fonctions wasm dans du code JavaScript. Pour notre application, on peut reprendre l'implémentation JavaScript et remplacer les fonctions de dessin par le code suivant (draw_wasm/index.html).

            ... <script src="draw.js"></script> <script> Module.onRuntimeInitialized = function() { const width = canvas_draw.clientWidth; const height = canvas_draw.clientHeight; // create a C++ MyCanvas const mycanvas = new Module.MyCanvas(width, height); function update() { // update JS canvas using C++ MyCanvas const myarray = new Uint8ClampedArray(mycanvas.getData()); const myimage = new ImageData(myarray, width, height); const mycontext = canvas_draw.getContext('2d'); mycontext.putImageData(myimage, 0, 0); } update(); canvas_draw.onmousedown = function(evt0) { // start drawing const r = Number(input_r.value); const g = Number(input_g.value); const b = Number(input_b.value); const color = rgbToHex(r, g, b); const radius = Number(input_radius.value); const ctx = canvas_draw.getContext("2d"); let p0 = getXY(canvas_draw, evt0); mycanvas.initDraw(r, g, b, radius); // set callback function for drawing canvas_draw.onmousemove = function(evt1) { const p1 = getXY(canvas_draw, evt1); mycanvas.draw(p0.x, p0.y, p1.x, p1.y); update(); p0 = p1; }; }; canvas_draw.onmouseup = function(evt) { // stop drawing -> remove callback function canvas_draw.onmousemove = {}; }; button_clear.onclick = function() { // clear C++ MyCanvas mycanvas.clear(); // update JS canvas update(); } } // update HTML elements (RGB span, canvas_brush) function updateDom() { ...

            Au lieu d'utiliser les fonctions de dessin du canvas HTML5, on utilise ici la classe C++ MyCanvas et on recharge les données de MyCanvas vers le canvas HTML5. Ceci introduit des allocations mémoire et n'est donc peut-être pas la façon optimale de faire.

            Ainsi, si emscripten permet assez facilement de compiler du code C++ en WebAssembly et de l'appeler dans du code JavaScript, il faut néanmoins prendre en compte quelques subtilités. Tout d'abord, le code C++ à interfacer doit être un minimum performant. Ensuite il faut éviter les copies mémoires inutiles (on peut faire les allocations côté C++ et les partager côté JavaScript ou inversement). Enfin, il faut réserver les appels WebAssembly à des traitements peu nombreux mais coûteux.

            Seconde implémentation

            L'implémentation WebAssembly précédente consiste essentiellement en une (mauvaise) réimplémentation des fonctions de dessin des canvas HTML5. La gestion d'événements est toujours faite côté JavaScript et résulte en de nombreux appels à des fonctions wasm peu coûteuses, ce qui n'est pas très intéressant pour WebAssembly.

            Dans cette seconde implémentation, on implémente la majeur partie de l'application du côté WebAssembly en utilisant la bibliothèque SDL. Comme cette bibliothèque possède moins de fonctionnalités de dessin que les canvas HTML5, le dessin sera plus basique.

            SDL est une bibliothèque assez complète pour développer des jeux vidéos. Elle gère notamment l'affichage et les événements. Pour notre application de dessin, le côté HTML/JavaScript se limite donc à réserver un canvas pour le code WebAssembly. Fichier draw_sdl/index.html :

            <!doctype html> <html> <head> <meta charset="utf-8"> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> </head> <body> <h1> draw sdl </h1> <p> <canvas id="canvas_draw" oncontextmenu="event.preventDefault()"> </canvas> </p> <p><button id="button_clear"> Clear </button></p> <script type='text/javascript'> var Module = { canvas: canvas_draw, onRuntimeInitialized: function() { button_clear.onclick = function() { Module.clear(); }; } }; </script> <script async type="text/javascript" src="draw.js"> </script> </body> </html>

            Le code WebAssembly/C++ est très similaire à un jeu SDL classique. Dans le code suivant (draw_sdl/draw.cpp) la fonction display_texture charge, dans le canvas d'affichage, une texture générée par la technique de render-to-texture. La fonction clear permet de nettoyer la texture à afficher. Cette fonction est également exportée pour être connectée au bouton de l'interface.

            #include <emscripten.h> #include <emscripten/bind.h> #include <SDL2/SDL.h> const int WIDTH = 640; const int HEIGHT = 480; SDL_Window * g_window; SDL_Renderer * g_renderer; SDL_Texture * g_texture; // for rendering to texture int g_x0 = 0; // current drawing position int g_y0 = 0; bool g_drawing = false; // drawing state // copy texture to displayed canvas void display_texture() { SDL_SetRenderTarget(g_renderer, nullptr); SDL_RenderClear(g_renderer); SDL_RenderCopy(g_renderer, g_texture, nullptr, nullptr); SDL_RenderPresent(g_renderer); } // clear and display the texture void clear() { SDL_SetRenderDrawColor(g_renderer, 0, 0, 0, 0); SDL_SetRenderTarget(g_renderer, g_texture); SDL_RenderClear(g_renderer); SDL_RenderPresent(g_renderer); g_texture = SDL_GetRenderTarget(g_renderer); display_texture(); } // export function to JS EMSCRIPTEN_BINDINGS(draw_sdl) { emscripten::function("clear", &clear); }

            Enfin le programme principal initialise le canvas et la texture à afficher puis lance la boucle principale, qui gère chaque événement via la fonction iter_one.

            // do one iteration of the event loop void iter_one() { SDL_Event event; while (SDL_PollEvent(&event)) { if (event.button.button == SDL_BUTTON_LEFT) { if (event.type == SDL_MOUSEBUTTONDOWN) { // start drawing g_drawing = true; g_x0 = event.button.x; g_y0 = event.button.y; } else if (event.type == SDL_MOUSEBUTTONUP) { // stop drawing g_drawing = false; } } else if (event.type == SDL_MOUSEMOTION) { if (g_drawing) { // draw a line in the texture, from previous position to current position SDL_SetRenderDrawColor(g_renderer, 255, 255, 255, 255); SDL_SetRenderTarget(g_renderer, g_texture); SDL_RenderDrawLine(g_renderer, g_x0, g_y0, event.motion.x, event.motion.y); SDL_RenderPresent(g_renderer); g_texture = SDL_GetRenderTarget(g_renderer); // display texture display_texture(); // update current position g_x0 = event.motion.x; g_y0 = event.motion.y; } } } } // init SDL and launch the event loop int main() { SDL_Init(SDL_INIT_VIDEO); SDL_CreateWindowAndRenderer(WIDTH, HEIGHT, 0, &g_window, &g_renderer); g_texture = SDL_CreateTexture(g_renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, WIDTH, HEIGHT); emscripten_set_main_loop(iter_one, 0, 1); return 0; }

            Ce type d'implémentation correspond mieux à l'esprit de WebAssembly mais nécessite d'utiliser des outils performants côté WebAssembly/C++. Certaines bibliothèques, comme la SDL, sont incluses dans emscripten. Pour les autres bibliothèques, il faut généralement les porter soi-même, ce qui peut rapidement se compliquer…

            Conclusion

            En conclusion, cette petite application de dessin permet de confirmer les tendances actuelles en développement web, notamment son vaste champ d'application et ses nombreux outils.

            L'écosytème de base HTML/CSS/JavaScript apporte déjà de nombreuses fonctionnalités. JavaScript étant assez haut niveau, développer en pur JavaScript n'est pas complètement déraisonnable et permet d'obtenir un code léger et optimisé. Cependant, comme le typage dynamique et le système de fonction de rappel peuvent être source d'erreurs, il est préférable d'être rigoureux dans sa façon de programmer et d'utiliser des outils de vérification de code et de tests automatisés. Enfin, comme pour tous les langages, il devient vite indispensable de bien architecturer le code lorsque l'application grossit (par exemple selon un schéma MVC).

            Les frameworks frontend apportent justement cette architecture de code pour gérer facilement des applications complexes (MVC, flux…). À l'usage ces frameworks sont très pratiques à utiliser même pour des applications simples. Combinés à un langage typé (TypeScript, Elm…) ou à un style de programmation fonctionnelle, ils réduisent considérablement les sources d'erreurs possibles. En revanche, ils nécessitent une phase d'apprentissage et un écosystème plus lourd et plus complexe.

            Les frameworks basés widgets comme C++ Wt (et également les frameworks d'applications mobiles) utilisent la même approche classique que les frameworks desktop comme Qt ou Gtkmm. Ils permettent notamment de réutiliser et de personnaliser facilement des composants mais nécessitent également d'architecturer soigneusement le code pour des applications plus complexes. À noter que Wt est un framework fullstack, ce qui facilite les communications client-serveur mais peut introduire un peu de latence côté client.

            Enfin, WebAssembly permet d'appeler, dans une page web, du code C/C++/Rust précompilé. Cette technologie est actuellement assez utilisable même si elle peut parfois demander quelques efforts de mise en place (portage de bibliothèques via emscripten). Cependant, elle est à réserver à des applications particulières, par exemple des traitements ponctuels lourds ou, à l'opposé, des applications interactives gérées complètement côté WebAssembly.

            Télécharger ce contenu au format Epub

            Commentaires : voir le flux atom ouvrir dans le navigateur

            Catégories: Les actus

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

            mar, 18/12/2018 - 11:14

            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

            [Techniques de l'Ingénieur] L’Open Source: une alternative économique aux éditeurs américains

            Par Philippe Richard, le mercredi 12 décembre 2018. Extrait:

            De plus en plus d’entreprises françaises se plaignent de l’augmentation des coûts engendrés par les logiciels des poids lourds américains (Oracle, SAP, Microsoft…). L’Open source permet de réduire ces coûts et la dépendance vis-à-vis de ces géants de l’informatique.

            Lien vers l'article original: https://www.techniques-ingenieur.fr/actualite/articles/lopen-source-une-alternative-economique-aux-editeurs-americains-61556

            Et aussi:

            [TV Com] Le Roi et la Reine en visite dans la société Odoo à Ramillies

            Par François Namur, le mardi 11 décembre 2018. Extrait:

            Le Roi Philippe et la Reine Mathilde étaient en visite en Brabant wallon, aujourd'hui, et plus précisément dans l'est de la province. Première étape de leur journée: la société Odoo, implantée dans plusieurs fermes à Ramillies.

            Lien vers l'article original: https://www.tvcom.be/video/info/economie/le-roi-et-la-reine-en-visite-dans-la-societe-odoo-a-ramillies_23114_89.html

            [Developpez.com] Si Linux a de la peine à s'imposer sur le desktop c'est à cause de la fragmentation de l'écosystème

            Par Patrick Ruiz, le mardi 11 décembre 2018. Extrait:

            Linux pointe à la 3e place du classement NetMarketShare (variations de décembre 2017 à novembre 2018) des OS de bureau avec 2,03 % des parts de marché, ce, derrière Windows qui mobilise 87,92 % et Mac OS avec ses 9,46 %. Le système d’exploitation open source créé par l’informaticien finlandais Linus Torvalds a frôlé la barre des 5 % en septembre 2017, mais c’était par erreur; à la réalité, il a rarement dépassé les 3 %. Dans la filière desktop, c’est l’OS de la firme de Redmond qui continue de faire la loi.

            Lien vers l'article original: https://www.developpez.com/actu/237125/Si-Linux-a-de-la-peine-a-s-imposer-sur-le-desktop-c-est-a-cause-de-la-fragmentation-de-l-ecosysteme-d-apres-Linus-Torvalds

            [UP] Comment louer un smartphone éthique et protéger sa vie privée

            Par Héloïse Leussier, le lundi 10 décembre 2018. Extrait:

            Commown propose la location du smartphone éthique Fairphone avec le système d’exploitation développé par le constructeur qui respecte la vie privée.

            Lien vers l'article original: https://www.up-inspirer.fr/45163-comment-louer-un-smartphone-ethique-et-proteger-sa-vie-privee

            [LaptopSpirit] Microsoft se tourne vers Chromium pour son navigateur Edge

            Par Marine, le lundi 10 décembre 2018. Extrait:

            Microsoft l'a officiellement annoncé. Il va adopter le projet open source Chromium dans le cadre du développement de son navigateur Edge.

            Lien vers l'article original: https://www.laptopspirit.fr/230992/microsoft-edge-chromium-navigateur.html

            Et aussi:

            Télécharger ce contenu au format Epub

            Commentaires : voir le flux atom ouvrir dans le navigateur

            Catégories: Les actus

            Unvanquished Zone 51

            lun, 17/12/2018 - 15:06

            Le jeu Unvanquished est sorti ce dimanche 9 décembre en version alpha 0.51, après plus de deux ans de développement. Voici donc une note de version détaillée de cette fournée !

            Note : Ceci est une traduction de la note de version officielle que j’ai écrite pour le projet Unvanquished, un jeu vidéo de stratégie en temps réel à la première personne opposant dans un futur intersidéral une espèce extra-terrestre et l’humanité.

            Sommaire

            Cette traduction est sous Licence CC0 1.0.

            Nous l’avons donc fait ! Voici notre dernière, tant attendue publication, la version 0.51 ! Se servir tant que c’est chaud !

            Il y a eu énormément de changements dans cette version depuis que la précédente a été publiée il y a deux ans et huit mois et le développement ne sommeillant pas il sera difficile de tout raconter.

            Cependant, le code du jeu lui-même est vraiment très stable vu que nous avons été capables de rétroporter presque tout sur la précédente version à travers les années. Je dis « presque tout » parce qu’un bug (désormais corrigé) du système de fichier nous a empêché de surcharger indéfiniment nos paquets avec des nouveaux, ce qui nous a empêché de faire étalage de certains de nos modèles. Mais le gameplay fut entièrement rétroporté et les joueurs étaient en mesure d’y jouer depuis plus d’un an avec leur client 0.50 non modifié, rien qu’en rejoignant des serveurs. C’est un très bon point pour nous et cela démontre la robustesse de l’architecture et prouve que le moteur Dæmon est une solide plate-forme de modification.

            Vous savez déjà que kharnov a quitté le projet, et puisque c’est notre première version sans lui nous lui dédions cette alpha 51. Nous savons combien il a intensément attendu cette version et espérait tant voir celle-ci devenir la première bêta. Ne t’inquiète pas kharnov, la bêta est toute proche. Pour le rappeler à nos lecteurs, nous catégorisons nos versions alpha et bêta non à cause de leur stabilité mais à cause de la complétude de nos objectifs. Celle version est signalée comme une version alpha même si nous aurions voulu mettre dessus l’étiquette bêta, mais jouons la prudence : nous préférons appeler bêta quelque chose que les joueurs ont eu en main. 🙂

            Vous remarquerez probablement que le jeu possède des chaînes de version 0.51.1 à certains endroits, nous avons sournoisement étiqueté une version 0.51.0 quelques semaines plus tôt qui agît un peu comme une candidate à la publication. Après quelques corrections de dernière minute, nous sommes prêts pour distribuer publiquement le jeu à nouveau ! Joie !

            Metteur à jour, lanceur de jeu !

            Le metteur à jour d’Unvanquished

            Donc, accueillons notre nouveau metteur à jour ! Nous le distribuons désormais officiellement et c’est maintenant le moyen officiel de télécharger et mettre à jour Unvanquished. Au fond, c’est un lanceur d’Unvanquished. Vous téléchargez simplement un binaire, vous le lancez, et il récupère ce qui manque avant de lancer le jeu. La prochaine fois que vous le lancerez le jeu sera mis à jour avant d’être démarré si une nouvelle version est disponible.

            Ce metteur à jour donne aussi un aperçu du dernier billet de blog donc pendant que vous attendez pour la mise à jour vous verrez qu’il y a des nouvelles et vous cliquerez juste dessus pour lire l’article complet !

            Même s’il n’était pas annoncé, certaines personnes utilisaient déjà la précédente itération de ce metteur à jour, nous avons donc été en mesure d’écouter les besoins et idées pour le rendre meilleur. Non seulement le comportement fut amélioré pour répondre aux besoins des joueurs, mais le metteur à jour fut entièrement refait en utilisant QML et présente mieux ! Ce metteur à jour est le fruit du travail d’Ishq sur la base d’une maquette de Gireen.

            Changements dans la mécanique de jeu

            Parlons donc de changement de gameplay puisque c’est ce qui fait sens dans le développement d’un jeu !

            Minage de ressource et contrôle de territoire

            Cette version introduit un important changement dans la manière dont les points de constructions sont gérés. Vous connaissez peut-être le drill (foreuse) et le leech (sangsue) si vous avez déjà joué au jeu avant. La foreuse est une machine humaine qui mine des points de construction et la sangsue est l’alter-ego extra-terrestre, un être vivant étant donnée la nature de cette espèce.

            Chaque foreuse ou sangsue construite contribue une certaine quantité de points de construction et de puissance au fond commun de l’équipe qui est désormais global et non rattaché aux lieux. Les autres constructions comme les tourelles, les armureries, tubes d’acides et œufs consomment les points de construction et la puissance fournie par les foreuses et sangsues. Cela signifie que ces foreuses et sangsues doivent être défendues puisque leur destruction laisse non alimentées les constructions dépendantes. De plus, lorsqu’une construction est détruite, cela prend du temps pour les points de construction utilisés d’être réintroduits dans le fond commun.

            Pour être efficace les foreuses et sangsues doivent maintenir une certaine distance entre elles. Ce changement de gameplay encourage les guerres de territoire dans la façon dont les équipes ont besoin de contrôler des territoires extérieurs pour construire des foreuses ou sangsues éloignées comme le requière la construction de leurs base. Puisque le mécanisme rend les constructions dépendantes des appareils de minage cela apporte une alternative à l’ancienne mort subite de Tremulous : plus le jeu dure longtemps plus cela prend du temps de recouvrir les points de construction après la destruction d’une structure, affaiblissant la base la moins bien gérée et accélérant conséquemment sa destruction.

            La foreuse

            Le répéteur est désormais enlevé. Le répéteur était la structure humaine construite pour alimenter les autres constructions dans les bases avancées. Maintenant la foreuse fait aussi le travail du répéteur : minant les ressources, les stockant, et alimentant le tout y compris les bases avancées. Puisque le répéteur avait un modèle plus beau que celui de la foreuse, la foreuse réutilise le modèle du répéteur et le modèle de la foreuse est désormais retirée. Fondamentalement ce modèle ressemble à un petit réacteur ce qui fait beaucoup sens : le réacteur est le générateur principal de puissance et centre nerveux.

            Dretch + Tourelle = 💜

            Les dretchs sont à nouveau capables d’attaquer les tourelles et les rocket pods ! Les dretchs sont l’une des deux formes extra-terrestres qu’un joueur peut choisir pour (ré)apparaître en jeu, l’autre étant la forme de constructeur granger. Le dretch est une petite et faible forme d’attaque que le joueur extra-terrestre utilise avant de se transformer en de plus fortes et meurtrières formes. Le jeu Tremulous original permettait à ces dretchs d’attaquer les structures défensives comme les tourelles, mais cette fonctionnalité avait été désactivée dans la gameplay preview (GPP) de la version 1.2 qui ne fut jamais distribuée. Les joueurs demandaient le retour de cette fonctionnalité et ça faisait beaucoup sens parce que cela semblait assez incohérent qu’un extraterrestre seul ne puisse pas être en mesure de détruire une base humaine quand un joueur humain sans protection et seul pouvait détruire une base extra-terrestre.

            Mouvements des joueurs

            Quelques changements ont été implémentés dans la façon dont les joueurs se déplacent tel que demandés par certains joueurs, en les écoutant et prenant soin des problèmes qu’ils rapportent. Il est désormais possible de sauter sur les murs pour atteindre certaines plateformes plus facilement. Le glissement humain a été un peu modifié et l’esquive humaine a été désactivée.

            Indicateur de dommage

            Enneract a implémenté cet excellent changement ! Les joueurs ont maintenant un retour visuel montrant combien efficace est leur attaque. Cela aidera aussi les joueurs à comprendre naturellement quelle arme ou attaque est meilleure pour chaque situation, et combien leur visée est bien entraînée où s’il y a encore de la place pour du perfectionnement !

            Indicateur de dommage

            Amélioration du spiker

            Le spiker a été amélioré pour le rendre plus utile et efficace. Le spiker est une construction extra-terrestre de défense qui lance des épines mortelles sur les humains insouciants. Désormais le spiker décoche ses épines seulement si les dommages attendus atteignent un certain seuil pour ne pas gaspiller son attaque mortelle (elle se recharge lentement) et il essaie désormais d’éviter le tir ami quand d’autres structures extra-terrestres sont en ligne de mire. Précédemment son comportement par défaut était de ne pas attaquer en cas de tir ami mais cela le rendait inutile quand une autre construction n’était pas correctement positionnée. Maintenant le spiker vise la cible plus précisément pour éviter d’endommager les structures de son équipe. Les épines elle-mêmes ont reçu une compensation de leur gravité.

            Gros travail sur les données de jeu

            Vous l’avez probablement remarqué si vous avez lu les précédents billets : un gros travail a été fait sur le plan de la gestion des données. Elles ne sont pas seulement désormais hébergées dans des dépôts git, nous avons reconstruit leur historique passé lorsque c’était possible, en rejouant les précédents paquets sur l’arbre par exemple.

            Nettoyage

            Un gros nettoyage a été fait, éliminant les laissés-pour-compte et en dédupliquant les choses. Notre système de gestion de paquet nous permettait de surcharger des paquets précédemment publiés mais cela ne faisait qu’ajouter de nouveaux fichiers à ceux existant puisque tous les paquets précédemment publiés devaient être distribués dans tous les cas.

            Quelques corrections ont été faites sur le set texture communes pour renommer ou abandonner des choses obsolètes. Les sets de textures ej01 ont été fusionnés en un seul, le modèle de répéteur a été abandonné comme expliqué, et il y a eu beaucoup de nettoyage dans les shaders. Ici le mot shader est à entendre comme un « shader Quake 3 », un moyen simple de définir des matériaux, pas comme un « shader GLSL ». L’ensemble de la collection de donnée a subit une grande quantité de renommages pour unifier les choses et standardiser plus encore.

            Pour donner quelques nombres, l’alpha 50 pesait 737Mo avec 6322 fichiers quand l’alpha 51 pèse 488Mo avec 4178 fichiers, c’est une économie de 34% !

            Modèles

            Cette publication introduit aussi le nouveau modèle du dragon et le nouveau modèle de l’exosquelette ! Le dragon est un modèle de Raphaël « RXMT » Moreault-Truchon​ et l’exosquelette un modèle de Luiz Henrique « lhdc » de Camargo.

            Le dragon et l’exosquelette

            L’ancienne main a été repeinte. L’ancienne main est le modèle de main à la première personne qui est utilisée avec les anciennes armes qui ne sont pas encore remplacées. Certaines d’entre elles ne sont pas si mal et puisque nous sommes en besoin d’animateur et d’implémenteur il convient de les garder pour un temps. Avec cette main repeinte de manière à ressembler à la nouvelle il y a beaucoup moins d’incohérence affichée à l’écran !

            De gauche à droite : ancienne main avec le fusil à impulsion, ancienne main repeinte, nouvelle main avec le fusil à pompe

            Bien que le moteur soit en mesure de translater, tourner ou redimensionner les modèles à l’exécution en se servant de fichiers de configuration nous le faisons désormais au moment de construire les données et nous les distribuons déjà translatées, tournées et redimensionnées pour que les outils tierce-partie comme des éditeurs de niveaux puissent aussi les afficher correctement. Un bug a été trouvé du côté du moteur concernant le zOffset (translation verticale) donc les modèles ont été corrigés pour être affichés correctement après la correction de ce bug.

            Les sons

            Du travail a commencé du côté de la face cachée du son. Obani en a contribué quelques-uns (le son du jetpack, le son de préconstruction), et quelques-uns ont été repris de dépôts de données libres comme opengameart provenant de divers auteurs quand ces sons étaient suffisamment proches de ce que nous avions déjà (bruit de tir de la mitrailleuse, les pas de l’exosquelette…). Après une vérification des licences certains sons de Tremulous qui ont été vérifiés comme sûrs ont été réimportés.

            Nous distribuons désormais un paquet de ressources nommé res-legacy pour fournir des choses héritées de Tremulous qui ont à être remplacées ou déplacées vers d’autres dépôts quand elles sont vérifiées comme sûres et libres. Ce paquet distribue des substituts qui ont vocation à être entièrement abandonnés un jour donc s’il vous plaît ne mettez pas ce paquet dans les dépendances de vos propres paquets.

            Les cartes

            Un gros chargement de corrections de cartes est apporté par cette version : des lieux où le granger pouvait construire à l’extérieur de la zone de combat dans Antares, Perseus et Spacetracks sont maintenant marqués comme non-constructibles. Un endroit où le spectateur pouvait quitter la zone de combat dans Perseus a été scellé.

            Dans Thunder un mobilier extérieur permettait par erreur aux joueurs de s’y cacher, ce modèle est désormais proprement clippé (NDLA : un clip est une surface spéciale qui découpe l’espace en zones traversables ou non selon la nature de l’objet qui tente de traverser). Dans Spacetracks quelques surfaces avec un « clip complet » ont été reçus un « clip d’arme » à la place pour permette aux projectiles de traverses les portes entrouvertes sans laisser les joueurs sortir de la carte.

            Porte entrouverte sur Spacetracks: les projectiles ne sont désormais plus clippés

            Sur la carte Chasm du travail fut réalisé pour empêcher le granger de construire des œufs au bord du ciel ou bien à l’intérieur du gouffre et des systèmes de particules de flocon de neige ont été ajoutées à un endroit où ça manquait. La carte Chasm a aussi reçu des optimisations de hint (NDLA : un hint est une surface indicative qui permet au compilateur de carte d’optimiser les calculs de visibilité et donc les performances).

            Cela requérait une dextérité vraiment impressionnante mais c’était possible, oups !

            Les cartes comme Parpax, Station15, Spacetracks et Chasm ont fait l’objet d’un travail de caulk (NDLA : un caulk est une surface spéciale qui n’est pas affichée et qui n’a aucun effet en jeu, elle est même généralement supprimée à la compilation, ces surfaces sont utilisées sur les faces invisibles des polygones à des fins d’optimisation), réduisant parfois la taille des cartes de lumières (lightmap) par un quart pour les deux dernières (NDLA : les cartes de lumière sont des textures décrivant les jeux d’ombre et de lumières précalculées pour toutes les surfaces). Thunder a vu certaines textures manquantes corrigées en même temps qu’un gros effort de déduplication : cette carte est antérieure à la plupart des sets de textures mais elle repose sur eux désormais.

            Quelques changements mineurs ont été faits par Viech sur Parpax et EmperorJack a mis à jour sa carte Forlorn en bêta 1. Vous avez tout ça dans cette version.

            Du côté communautaire

            Supertanker a publié une préversion d’une carte urbaine appelée Freeway qui n’est pas encore distribué avec le jeu puisqu’il y a encore beaucoup de travail à faire mais vous pouvez déjà l’essayer sur les serveurs !

            La carte Freeway à venir

            Du côté communautaire certains cartographes on fait de chouette cartes qui vous enjoueront peut-être sur les serveurs. Bien que non-officielles, elles valent le détour et le jeu : Matth a publié une refonte de la bonne vieille carte Tremor sous le nom USS Tremor, une refonte d’UTCS sous le nom CTCS et aussi une carte dans un univers désertique appellée Fortification avec un plan qui rappelle ATCS. Vous remarquerez l’impressionnante carte Hangar28 de tvezet qui raconte tant d’histoires par elle-même. Freeslave a porté sa carte Stalkyard pour Unvanquished et cu-kai fait de même avec sa carte combat-t3. Donc, en même temps que les mises à jour officielles il y a plein de truc nouveaux à apprécier sur les serveurs.

            Amorçage

            Le dossier main/ du dépôt Unvanquished est désormais extrait comme un dépôt à part entière nommé unvanquished_src.dpkdir et réimporté comme sous-module dans le dossier pkg/ du dépôt Unvanquished. Ce dépôt de paquet ne contient pas suffisamment de choses pour jouer au jeu mais en a suffisamment pour démarrer le jeu, rejoindre un serveur et récupérer tout le reste à partir de là.

            Polissage du code du jeu

            Bon il va être difficile de rapporter toutes les corrections, mais essayons tout de même. Pour commencer les données ne sont pas les seules à avoir subit un grand nettoyage, le code aussi et du code résiduel a été supprimé.

            De meilleurs bots

            Les bots peuvent désormais se débloquer eux-mêmes et le remplissage de bot a été implémenté (la commande bot fill) : c’est la méthode de gestion des bots communément implémentée sur les jeux en ligne où une réserve de bots sont introduits sur les serveurs vides puis automatiquement retirés au fur et à mesure que de vrais joueurs rejoignent la partie. Ces deux fonctionnalités étaient attendues depuis longtemps.

            Toujours du côté des bots le code de jeu retire désormais les bots à la fin du jeu quand une carte est redémarrée, et une division par zéro se produisant quand l’habileté d’un bot était de 10 est désormais corrigée.

            Animation de modèle, interface utilisateur, lecture audio

            Quelques interpolations défectueuses d’animation affectant leur fluidité sont corrigées, l’animation par squelette a été refactorisée, les attaques du spiker et de l’overmind ne sont plus interrompues par les animations de douleur. Les joueurs ne s’inclinent plus deux fois dans le sens de leur marche. Comme dit précédemment l’interprétation des dimensions des modèles a été corrigé et les modèles redimensionnés en conséquence.

            Au sujet de l’interface utilisateur le filtrage listmap et son affichage ont été corrigés (c’est une fonctionnalité de console), plus de choses sont redémarrées au redémarrage des cartes pour retirer le tableau des scores de l’écran dans ce genre de situation par exemple, et les longues chaînes de caractères ne déplacent plus les éléments dans les tableaux : avant ça les longs noms d’utilisateur mettaient la pagaille dans le tableau des scores, de même avec les longs noms de serveurs dans la liste des serveurs : c’est désormais corrigé.

            Les longs noms ne déplacent plus les autres éléments

            Les chemins des sons sont désormais indépendants de leur extension. Ceci nous permet de distribuer de nouveaux sons en utilisant un nouveau format sans avoir à se soucier de ce que l’ancien format soit toujours là dans les anciens paquets. Avant ça si un effet sonore obsolète était appelé son.wav et son remplacement utilisait un format plus récent et était nommés son.opus l’ancien aurait été chargé dans tous les cas. Maintenant le fichier le plus récent est prioritaire quel que soit le format.

            Réseau, initialisation, système de composant

            Un vilain bug a été corrigé dans le paquet inforesponse, c’est utilisé par les outils d’interrogation et explorateur de serveur tierce-partie comme qstat ou XQF (dont on a déjà parlé dans ces colonnes) et le bug affichait simplement une quantité erronée de joueurs quand on interrogeait les serveurs.

            Quand le jeu était démarré pour la toute première fois quelques options d’initialisation n’étaient pas faites, menant à un menu de configuration erroné. C’est corrigé. Un plantage se produisant lors des redémarrages avec switchteam est désormais corrigé.

            Le système de composants a été profondément remanié, particulièrement du côté des constructions, et les composants de pensée ont été optimisés.

            Options de développeur

            Une nouvelle triche give bp a été ajoutée pour se donner à soi-même une quantité arbitraire de point de construction en vue de tests, et une nouvelle option de développer appelée g_neverEnd a été ajoutée pour ne pas terminer le jeu même s’il n’y a plus du tout de point de réapparition. Ceci est utile pour les cartographes qui ont besoin de tester leur travail en cours ou pour les développeurs qui doivent ouvrir dans Unvanquished des cartes provenant d’autres jeux alors qu’ils travaillent sur un portage et que leur jeu n’est pas encore complet : ils ont simplement à activer cette option et à charger cette carte avec devmap.

            Une petite bidouille a été introduite pour empêcher le clip de l’arme de l’exosquelette. Du code mort a été retiré, merci à Slipher d’en avoir pris soin. Oh et le jeu peut désormais être construit contre un dossier du moteur Dæmon stocké à l’extérieur de l’arbre des sources Unvanquished.

            De nombreux correctifs ont été apportés grâce à de l’analyse statique. C’est vrai aussi pour le code du moteur.

            Amélioration du moteur

            Cette version casse la compatibilité avec les précédentes versions sous plusieurs aspects : gestion de paquet, stockage des données des utilisateurs, entrée… Puisque la compatibilité allait être cassée dans tous les cas, c’était le meilleur moment pour implémenter tous les autres changements qui cassent la compatibilité et qui attendaient depuis longtemps. C’était le moment de se défaire des vieilleries.

            Le grand débarras des vieilleries

            Nous avons donc basculé vers le format de paquet DPK, comme expliqué dans un article précédent.

            C’est le moment d’annoncer une importante amélioration sur le plan de l’utilisabilité : il faut remercier le travail de Slipher qui permet aux utilisateurs d’associer des caractères non-ASCII et il y a plusieurs manières d’associer une touche, l’une d’entre elle utilisant des identifiants matériels qui sont indépendants de l’agencement du clavier. Cela signifie que nous pouvons dès maintenant distribuer une carte de touche qui fonctionne quel que soit l’agencement du clavier et la langue tout en permettant aux personnes de la personnaliser en utilisant le nom de touche dans leur propre langue. Il faut noter que les anciennes associations de touches sont automatiquement converties depuis les précédents paramètres pour être utilisées dans le nouveau moteur, mais elles ne seront pas utilisables par des moteurs plus anciens après ça. EACFreddy a aussi travaillé à une meilleure prise en charge des manettes de jeu.

            Le stockage des données utilisateurs suit maintenant les recommandations XDG sous Linux. Donc à moins que vous ayez des variables d’environnement personnalisées le moteur utilise désormais le chemin ~/.local/share/unvanquished sous Linux, déplaçant automatiquement l’ancien dossier caché ~/.unvanquished.

            Aller de l’avant

            Nous avons aussi mis à jour le code de Crunch en le rebasant sur l’amont d’Unity… Crunch est un outil de compression et un format d’image à destination des cartes graphiques : les textures peuvent être distribuées dans un format compression qui peut être déchargé vers la carte graphique directement, économisant de l’espace disque, de la mémoire principale, du calcul processeur et de la bande passante et donc du temps de chargement. Crunch est un outil et un format initialement développé par BinomialLLC mais plus tard Unity a mis ses mains dans le code et l’a beaucoup amélioré. Par beaucoup je veux dire beaucoup.

            Les gens d’Unity disent que leur outil crunch modifié « peux compresser jusqu’à 2.5 fois plus rapidement, tout en produisant un meilleur taux de compression de 10% ». Nous avons donc mené un test sur notre propre dépôt de donnée, re-crunchant tous les paquets de ressources et de textures. Le corpus donné au moment où nous fîmes les tests produirent 1797 fichiers .crn. Nous avons comparé notre ancien outil crunch basé sur le code de BinomialLLC et le nouveau d’Unity avec nos modifications apportées. Nous avons recompilé l’exécutable, il n’y a donc pas de biais sur ce plan-là. Et voici les résultats :

            Le crunch de BinomialLLC :

            • temps de compression : 115 minutes et 8 secondes
            • taille des fichiers produits : 269 mégaoctets

            Le crunch d’Unity :

            • temps de compression : 26 minutes et 43 secondes
            • taille des fichiers produits : 239 mégaoctets

            Donc l’outil crunch d’Unity réduit le temps de compression par 4,31 et réduit la taille par 11,15%. Ils disaient « jusqu’à 2,5 fois plus rapide » mais nous avons vu certaines textures être compressées 6 fois plus rapidement et la moyenne de l’ensemble est 4.3 fois plus rapide, et oui l’outil compresse mieux que 10%, plus intensément. Les résultats sont impressionnants et sont beaux à voir.

            Le point noir c’est que ce nouvel outil crunch casse la compatibilité du format pour pouvoir réaliser ces améliorations (en lire plus dans nos forums), cependant le code de BinomialLLC est en dormance tandis que celui d’Unity est non seulement actif mais aussi implémenté dans Unity (c’est une large base d’utilisateur), et même l’auteur original de chez BinomialLLC semble avoir lui-même embranché l’arbre d’Unity, donc nous avons sauté le pas.

            L’amont d’Unity semble ne pas fusionner les demandes de fusion donc si vous êtes un développeur de jeu intéressé par Crunch, jetez un œil à notre fork qui maintient des corrections de compilation pour Linux et macOS, un Makefile corrigé, une intégration avec l’outil CMake (il semble que les gens d’Unity se focalisent uniquement sur Windows et Visual Studio), la personnalisation d’assertion et une normalisation optionnelle de carte normale tout en restant synchronisé avec l’amont Unity

            Traiter avec des pilotes défectueux et corriger nos propres erreurs

            Un plantage se produisant avec du matériel et du logiciel Nvidia spécifique est désormais corrigé. Ce bug était ennuyeux et même la quantité massive de fichiers journaux partagés par les joueurs dans les rapports de bug n’étaient pas suffisants pour circonscrire correctement le problème. Heureusement quelqu’un dans l’équipe de développement réussit à mettre la main sur ce bout de rebut défectueux, nous permettant de reproduire et contourner le problème puisque nous savons que le pilote ne sera plus jamais mis à jour.

            Nous avons corrigé une erreur GLSL qui plantait le jeu sur des pilotes correctes parce que, eh, pas seulement les autres font des erreurs mais au moins nous corrigeons les nôtres. Un bug en rapport avec le light culling est désormais corrigé. Le shader SSAO est désormais corrigé sous OpenGL 2.1 et quelques incompatibilités avec OpenGL 2.x sont corrigées.

            Un méchant bug menant à un crash quand de trop nombreux avertissements étaient imprimés dans le terminal de l’utilisateur est désormais corrigé. Toujours du côté du terminal une mauvaise initialisation causant un problème d’affichage de la console ncurses est désormais une chose du passé.

            Nous avons découvert un problème lié à la gestion des créneaux privés (la quantité de personnes connectées était fausse dans certains cas), désormais corrigé.

            Rendre le moteur plus accueillant

            Ce granger est très accueillant

            Pour améliorer la compatibilité avec d’autres jeux essayant de se porter vers le moteur Dæmon, la prise en charge de DXT3 et BC2 a été ajouté, c’est utilisé dans certains formats d’image comme le DDS (DirectDraw Surfaces). Le moteur prend maintenant en charge le préfixe dds/ que des moteurs de jeu comme celui de Doom 3 ou encore Darkplaces attendent. L’interprétation des shaders n’avorte plus en case d’avertissement (nous parlons toujours de matériau Quake 3), c’était une erreur puisque les avertissements sont pensés pour avertir pas pour avorter, et ce correctif aide aussi les données tierce-parties à être chargées même si elles sont incomplètes ou essaient d’utiliser des fonctionnalités non prises en charge.

            Le moteur ne recompresse plus salement les skyboxes (NDLA : une skybox est une texture spéciale en forme de cube vu de l’intérieur qui représente l’environnement lointain tout autour d’une carte, généralement le ciel). Cela utilisait avant la très inefficace compression OpenGL et nous ne faisons plus ce genre de chose puisque la compression de texture est désormais prise en charge au moment de construire les données, sélectionnant le meilleur format pour un bon affichage, un chargement court, et de haut résultats de compression. Cette recompression inefficace produisait de très laides skyboxes et c’était très problématique puisqu’une skybox dessine une image statique devant les yeux du joueur par conception, remplissant parfois l’écran entier. Ainsi un artefact serait très visible et ennuyant et ce n’est pas acceptable.

            Les shaders GLSL sont désormais embarqués dans le moteur au moment de la compilation. Quelques efforts ont été faits pour rendre le moteur plus autonome, faisant en sorte que certains fichiers de police de caractère soient optionels par exemple. Ce travail n’est pas complet : le moteur a toujours besoin de quelques données pour se charger mais c’est mieux qu’avant. Autonomiser le moteur rend le portage de jeux plus facile.

            Le code de démo a été nettoyé par Melanosuchus (NDLA : une démo est un enregistrement de tous les événements du jeu qui peuvent être rejouée par le moteur), les cvars ont été proprement renommées et des fonctionnalités cassées ont été retirées (NDLA : une cvar est une forme de variable utilisée dans le jeu que le joueur peut configurer depuis la console intégrée). Melanosuchus était celui qui avait déjà importé les codes de couleur RGB depuis Xonotic à l’époque de la version 0.43. Cette fois-ci T4im a apporté des corrections au code de couleur.

            Meilleur code

            Le machin mathématique des quaternions a été remanié, ne comptez-pas sur moi pour expliquer ça en détail. Le moteur utilise désormais des appels non-bloquants pour générer de l’aléa si possible. Quelques modernisations de C++ ont été dirigées par T4im. Gimhael a corrigé un bug se produisant avec des cartes n’ayant pas de lightmap, un bug qui a été découvert par nos amis du projet en chantier UnrealArena.

            Un problème lié à breakpad (outil de rapport de crash) a été corrigé et un problème empêchant de construire le moteur depuis un dossier extérieur à l’arbre des sources a reçu une correction. Le problème de système de fichier nous empêchant de publier des préversions dans certains cas a été corrigé, comme dit précédemment.

            Encore plus

            Il y a eu beaucoup de travail réalisé sur la chaîne d’édition de carte, l’éditeur de carte NetRadiant et le compilateur de carte q3map2 sont désormais pleinement pris en charge. Il y a tellement à dire qu’un billet dédié est requis. Restez à l’écoute !

            Le moteur peut désormais interroger plusieurs serveurs maîtres, et maintenant le jeu le fait : nous avons mis en place un serveur maître secondaire (master2.unvanquished.net), il rend le jeu plus résilient quand de mauvaises choses se produisent.

            Nous attendons toujours la permission restante de dsalt pour basculer le Wiki depuis la licence non-libre CC By-NC-SA vers la licence libre CC By-SA. Nous sommes toujours sans nouvelle de chris807, ses modèles étant les derniers à ne pas être sous la même licence que les autres.

            Comme annoncé dans les précédentes publications, nous avons désormais une page pour suivre l’activité du développement et un salon discord a été ouvert. Les canaux IRC vous accueillent toujours, rejoignez-nous et prenez part à un gros et excitant projet comme Unanquished !

            Nos amis de Smokin' Guns ont annoncé une tentative de porter leur jeu vers le moteur Dæmon, espérons que cela sera un succès parce que ce jeu est vraiment amusant et mérite un rafraîchissement !

            Remerciements

            Il serait difficile de nommer tous ceux qui ont été impliqués dans cette publication, mais nous remercions profondément tous ceux de l’équipe et chacun des contributeurs.

            Contribuer

            Nous avons besoin d’animateur et d’implémenteur pour pouvoir distribuer certains de nouveaux modèles qui sont déjà modelés. Le jeu a besoin d’un écran de vote de carte, avoir des démos côté serveur comme Xonotic serait appréciable, importer l’effet d’eau et les lightmap sRGB depuis le moteur Darkplaces serait excellent, expérimenter avec WebAssembly dans l’intention de remplacer Native Client un jour serait une bonne chose pour notre système de bac à sable.

            Nous avons toujours besoin de nouveaux sons, quelqu’un a dit qu’il travaillait à refaire la bibliothèque sonore donc si vous désirez contribuer sur cette partie c’est mieux de le contacter.

            Et maintenant la meilleure chose à faire : jouons ! 

            Télécharger ce contenu au format Epub

            Commentaires : voir le flux atom ouvrir dans le navigateur

            Catégories: Les actus

            Les meilleures campagnes marketing avec Linux

            lun, 17/12/2018 - 08:30

            J'ai longtemps pensé que l'un des plus gros problèmes qui empêchent les systèmes basés sur Linux de dominer (en termes de parts de marché) dans le secteur des ordinateurs de bureau… est celui du marketing. Notre manque de marketing qui attire l'attention, qui fait battre les cœurs et les esprits, est, à mon avis, l'une des faiblesses les plus flagrantes du monde du logiciel libre et open source.

            Mais, d'une certaine façon, ce n'est pas juste.

            La réalité, c'est que nous avons eu des campagnes marketing vraiment fantastiques au fil des années. Quelques-uns ont même réussi à sortir de notre propre communauté de passionnés de Linux. Allons faire un tour parmi mes préférés…

            De mon point de vue, le meilleur marketing est venu de deux endroits : IBM (qui a racheté Red Hat) et SUSE. Faisons cela par ordre chronologique.

            IBM "Peace. Love. Linux."

            En 2001, IBM a fait un investissement majeur dans Linux. Pour promouvoir cet investissement, il est évident qu'une campagne publicitaire doit être lancée ! Quelque chose d'emblématique ! Quelque chose d'accrocheur ! Quelque chose…. de potentiellement illégal !

            Bon sang, ils l'ont bien fait.

            "Paix. Amour. Linux." Représenté par des symboles simples : un signe de paix, un cœur et un pingouin, tous en petits cercles les uns à côté des autres. C'était visuellement agréable et cela favorisait le bonheur (ou, du moins, la paix et l'amour). Brillant !

            IBM a ensuite payé pour que plus de 300 de ces images soient peintes sur les trottoirs de San Francisco. La peinture était censée être biodégradable et s'enlever rapidement. Malheureusement, cela ne s'est pas produit — de nombreux dessins étaient encore là des mois plus tard.

            Et, selon le maire, "Certains ont été gravés dans le béton, donc, dans ces cas-là, ils ne seront jamais enlevés."

            La réponse de la ville a été… comme on pouvait s'y attendre.

            Après des mois de discussions, la ville de San Francisco a imposé une amende de 100 000 $ à Big Blue, sans compter les frais de nettoyage supplémentaires et les frais juridiques.

            D'un autre côté, ces histoires ont suscité beaucoup de publicité !

            "The Kid" d'IBM

            Vous vous souvenez de l'annonce pour le Linux Super Bowl d'IBM ? Celui avec le petit garçon assis dans une pièce avec une lumière blanche pure ?

            "Il est en train d'apprendre. Absorbant. De plus en plus intelligent."

            Quand ça a frappé en 2004, c'était comme, whoa ! Linux a réussi. IBM a fait une publicité pour le Super Bowl à ce sujet !

            "A-t-il un nom ? Son nom… est Linux."

            Cette campagne a rassemblé Penny Marshall et Muhammad Ali. C'est vrai, c'est vrai. Laverne de Laverne & Shirley ont approuvé Linux dans une publicité pour le Super Bowl. Laissons les choses se calmer un moment.

            C'était époustouflant en 2004. C'est encore époustouflant en 2018.

            Novell "PC, Mac & Linux" de Novell

            Tu te souviens de ces publicités "Je suis un Mac" d'Apple ? Un gars ("Mac") se moque de l'ennui d'un autre gars ("PC") ? Eh bien, Novell — qui, vous vous en souvenez peut-être, avait acheté la société SuSE Linux (à l'époque où le "U" était en minuscule) quelques années auparavant — avait ajouté une jolie dame nommée "Linux" au mélange en 2007.

            Et les résultats étaient plutôt adorables. Les vidéos avaient un caractère résolument "fait maison mais vraiment bien" pour eux. Chaque podcast, blog et magazine Linux parlait de ces petites vidéos pendant un bon mois après leur sortie.

            Vidéos musicales de SUSE

            Ces dernières années, SUSE a commencé à faire régulièrement des vidéos de musique parodique, et certaines d'entre elles sont absolument fantastiques.

            L'aventure du vidéoclip de SUSE a vraiment démarré en 2013 avec une parodie de "What Does the Fox Say ?" d'Ylvis, intitulé à juste titre "What Does the Chameleon Say ? C'était simple, idiot, amusant et charmant.

            (Note : le gars en costume caméléon ? Il ne travaille pas pour SUSE, mais son père est le producteur vidéo derrière toutes ces vidéos, et il s'est fait avoir. Vous remarquerez qu'il joue le caméléon dans un assez grand nombre de vidéoclips. Hourra pour la cohérence !)

            Le plus populaire des vidéoclips de SUSE est une parodie de "Uptown Funk" de Mark Ronson et Bruno Mars — "Uptime Funk". On pense qu'il s'agit de la première vidéo musicale au sujet du patch en direct d'un noyau Linux sur un serveur en fonctionnement. Cette chanson de 2015 a attiré beaucoup d'attention à la fois au sein et à l'extérieur de la communauté Linux.

            Il y en a, bien sûr, d'autres vidéoclips ainsi que des publicités imprimées et des vidéos amusantes qui m'ont marqué au fil des ans. Ceux que l'on ressent comme dignes de mention, comme point de repère, ont été obtenus dans la quête continuelle de faire connaître Linux aux plus grand nombre.

            Cet article est une traduction dont la source se situe ci-dessous.

            Télécharger ce contenu au format Epub

            Commentaires : voir le flux atom ouvrir dans le navigateur

            Catégories: Les actus