Marien Fressinaud

Mes jeux 2025

2026-02-07T14:30:00+01:00

Comme pour 2023 et 2024, voici la rétrospective des jeux auxquels j’ai joué en 2025.

Contrairement aux années précédentes, j’ai joué principalement sur PC, au lieu de la Switch les autres années. J’ai également bénéficié de l’accès à quelques jeux supplémentaires par le biais de la bibliothèque Steam partagée avec ma copine.

Chaque début d’année, je me fais une liste des jeux auxquels je veux jouer pour éviter d’être trop tenté par les sorties du moment et des achats « coup de tête ». La conséquence de la bibliothèque partagée a tout de même été que j’ai joué à sensiblement plus de jeux que les années précédentes. Aucun regret pour autant !

Dans cet article, je ne liste pas nécessairement la totalité des jeux auxquels j’ai joué. J’ai par exemple pas mal joué à No Man’s Sky, comme en 2024, mais je n’ai pas considéré que cette poursuite méritait de le mentionner à nouveau ici.

Je précise aussi que, cette année, j’ai tenté d’ordonner les jeux du moins apprécié au plus apprécié (et non par ordre chronologique de jeu).

Crisis Core - Final Fantasy VII - Reunion

Final Fantasy VII (1997) est un jeu à part dans mon expérience de joueur puisqu’il s’agit de l’une de mes premières et plus marquantes claques vidéoludiques. Le jeu n’est clairement pas exempt de défauts et accuse aujourd’hui son âge… mais ça reste un doudou pour moi.

Crisis Core est une préquelle à FF7, sortie en 2008. Je me méfie toujours des suites, préquelles et autres remakes. En l’occurrence, je suis ressorti de ce jeu très mitigé.

J’ai adoré découvrir l’histoire de ce qui s’est passé 5 ans avant (et qui explique) le jeu initial. Mais j’ai aussi été extrêmement déçu par la narration, son rythme avec les phases de gameplay, le peu de liberté accordée au joueur. Quant au gameplay de combat qui était la chose que je craignais le plus (passage du tour par tour au temps réel), je n’ai pas été aussi gêné que ce que j’imaginais, mais je n’ai pas totalement accroché non plus. J’ai fini le jeu en spammant toujours la même chose ; il n’y avait plus tellement d’enjeux et je n’avais plus qu’une chose en tête : finir le jeu pour passer à la suite.

Page Steam de Crisis Core

Return to Monkey Island

Return to Monkey Island est un jeu point'n click, et le dernier épisode de la série culte des Monkey Island. J’en avais toujours entendu beaucoup de bien, et même si je ne suis pas hyper fan des point'n click, il m’arrive de jouer à certains avec plaisir. J’ai donc abordé le jeu dans un état d’esprit plutôt positif.

J’ai cependant été rapidement rattrapé par ce que je n’aime pas dans ce genre de jeux : combiner à l’aveugle tous les objets de son inventaire pour espérer trouver la combinaison qui fera avancer. Pour être honnête, je n’y ai été vraiment confronté qu’au début du jeu, mais cela m’a suffi à laisser le jeu de côté pendant quelques semaines. Lorsque je l’ai relancé ensuite, je n’avais plus autant envie d’y jouer et la verbosité du jeu a fini par me rebuter. J’ai terminé le jeu de la même manière que Crisis Core : juste suffisamment l’envie de connaitre la fin, mais sans plus.

Mais à l’inverse du précédent, j’ai mieux perçu les qualités intrinsèques du jeu ; disons que je ne suis pas le public !

Site de Return to Monkey Island

Minishoot' Adventures

Minishoot' Adventures est un jeu d’aventure / twin stick shooter. Je n’avais jamais vraiment joué à ce type de jeu, mais après avoir regardé quelqu’un jouer dessus, j’ai été très tenté par celui-ci.

Grand bien m’en a pris : entre précision du gameplay, montée en puissance bien maitrisée, direction artistique sans prétention mais agréable, et boss bien équilibrés ; je trouve que c’est un sans-faute.

De plus, le jeu se termine en une dizaine d’heures, ce qui est souvent un bon argument pour les personnes qui ne veulent pas s’investir corps et âme dans un jeu. Parfait pour découvrir (et apprécier) le genre.

Page Steam de Minishoot' Adventures

Blue Prince

J’aime les jeux d’énigmes, et ça tombe bien.

Dans Blue Prince, l’objectif est d’atteindre la 46^e salle d’un manoir. Or, les salles ne sont pas fixes : c’est à nous, chaque jour, d’agencer les salles une à une, en espérant trouver un agencement qui nous fera atteindre la fameuse salle 46. Pour avancer, il faudra résoudre tout un tas d’énigmes plus ou moins compliquées. En chemin, on découvre peu à peu les secrets et l’histoire du manoir et de ses habitant·es.

La mécanique du jeu est originale, et le hasard qui sous-tend le jeu en fait à la fois son point fort et son point faible. Il apporte de grands moments d’excitation quand on a enfin la salle ou l’enchainement d’évènements dont on rêve depuis plusieurs tentatives. Mais il peut aussi être source de nombreuses frustrations quand on se retrouve bloqué à deux doigts de résoudre un mystère.

Malgré ce défaut, j’ai trouvé l’ambiance du jeu très réussie. Il faut accrocher aux graphismes — ça a été mon cas — et la musique se fait aussi rare qu’appréciable quand elle pointe le bout de son nez.

Blue Prince est extrêmement riche : une fois l’objectif atteint, on se rend compte qu’il reste encore d’innombrables choses à découvrir et explorer. Je n’ai toutefois pas eu le courage de tirer beaucoup plus loin, un peu fatigué par la trop grande part laissée à la chance et un peu intimidé par la difficulté apparente de certaines énigmes. Mais pour les personnes que ça ne rebuterait pas, le jeu est très généreux dans son « end game ». Il n’est pas impossible que je le relance à l’occasion.

À noter que le jeu, étant difficilement traduisible, n’existe qu’en anglais.

Site de Blue Prince

Clair Obscur: Expedition 33

Au-delà d’avoir battu tous les records en décrochant 9 prix sur 12 lors des derniers Game Awards, Clair Obscur est aussi un très bon jeu.

Chaque année, une Peintresse marque un décompte de 100 à 0 sur un immense monolithe. Les personnes dont l’âge correspond au décompte disparaissent alors en poussière. Pour arrêter la Peintresse, la ville de Lumière envoie chaque année une expédition. Dans le jeu, on incarne les membres de l’Expedition 33.

La particularité du gameplay de ce RPG repose sur les actions d’attaque et de défense qui sont timées. Il faut appuyer sur la bonne touche dans un timing particulièrement serré pour, esquiver, bloquer les attaques, voire contre-attaquer si tout se passe bien. J’ai plutôt bien accroché à cette mécanique difficile à appliquer correctement à chaque combat et qui demande pas mal de concentration. Mais quel plaisir quand tout se passe comme prévu !

J’ai surtout particulièrement accroché à la narration. On reste dans le flou jusqu’à la toute fin du jeu, laissant mille interprétations possibles de la réalité. J’ai vraiment un grand affect pour ce genre de narration qui ne nous prend pas par la main.

La musique est à elle seule un petit bijou au milieu de tout ça, même si, avec le recul, elle m’a moins marqué que ce que j’imaginais.

Site de Clair Obscur: Expedition 33

Jusant

Jusant est un jeu d’escalade où l’on incarne une personne à la recherche de l’eau disparue du monde dans lequel on évolue. On passe l’entièreté du jeu à escalader une gigantesque tour où l’on découvre peu à peu l’histoire des personnes qui ont peuplé les lieux par le passé.

J’avais initialement joué à la démo sans être entièrement convaincu… et puis l’ambiance solitaire qu’offre Jusant m’a attrapé. Le fait que le jeu ne soit pas difficile, mais plus centré sur un aspect méditatif est clairement un plus permettant de profiter de ce que le jeu a offrir. Là aussi, c’est la narration — à travers l’environnement, ou des quelques lettres qui trainent ici et là — qui m’a le plus porté. J’ai adoré avoir le sentiment de remonter le temps plus je montais la tour. Aussi, c’est un jeu plutôt court (moins de 10h), ce qui est toujours appréciable.

Je ne pense pas relancer le jeu, mais il m’en reste encore un sentiment de nostalgie qui me le fait entrer sans hésiter dans mon top 3 de 2025.

Site de Jusant

Valheim

Je ne suis pas un grand fan des jeux de survie, mais je crois que Valheim était celui qu’il me fallait. On y incarne un guerrier Viking tombé au combat qui doit se rendre digne d’entrer au Valhalla en tuant les ennemis d’Odin.

La carte immense est générée procéduralement et dispose de différents biomes tous aussi différents les uns que les autres. Le monde est ouvert, mais il est grandement recommandé de bien maitriser le biome dans lequel on se trouve avant d’attaquer le suivant.

C’est un jeu exigeant et difficile, surtout si on ne prend pas son temps. Chaque amélioration d’arme ou d’armure notamment fait la différence dans notre progression.

Les graphismes sont très particuliers et peuvent rebuter au premier abord. Personnellement je les adore : ils apportent une touche vraiment particulière à l’ambiance générale. Combinés à une ambiance sonore réussie, j’ai été totalement happé par Valheim.

On a joué une bonne partie du temps à deux à ce jeu, mais j’ai également fait une longue session solo à côté tellement j’avais envie d’apprécier Valheim à mon propre rythme. Le jeu est aussi très généreux : malgré ma centaine d’heures passée sur le jeu, je ne l’ai toujours pas terminé ! On est clairement sur un jeu qui demande de l’investissement.

Valheim est encore en accès anticipé, mais il devrait sortir en 2026 si tout va bien.

Site de Valheim

Hades 2

Bastion, Transistor, Pyre, Hades, et maintenant Hades 2 : je suis en grand fan du studio Supergiant Games. Mon avis est donc très biaisé !

Si vous avez joué à Hades premier du nom, tout est démultiplié dans cette suite : les décors sont plus nombreux (et plus beaux encore !), les mécaniques de gameplay sont plus variées, les biomes et les boss multipliés par deux, la musique encore plus exceptionnelle, les combos mieux maitrisés. C’est un jeu très généreux en contenu, donc foncez si vous avez aimé le 1 et que vous avez du temps à passer sur celui-ci.

Bon, mais ! Le jeu est aussi plus compliqué à prendre en main, on se sent assez rapidement dépassé par tout ce qu’il y a à apprendre. Il est aussi plus dur dans sa globalité. Personnellement, c’est ce qu’il me fallait, mais cela pourrait rebuter.

Pour moi, le plus gros défaut concerne toutefois la narration. J’ai trouvé qu’il était plus compliqué de s’attacher à l’ensemble des nombreux personnages. Il y a beaucoup de dialogues qui sonnent creux, donnant le sentiment d’être là pour le remplissage, sans rien apporter à l’histoire.

Malgré cela, le scénario global ne m’a pas déçu comme il a pu décevoir d’autres joueurs. Ça aurait pu être mieux, mais ça n’a pas franchement réduit le plaisir que j’avais à jouer.

Puis rappelons que le gameplay principal consiste à tracer sa route à travers des vagues d’ennemis, boostée petit à petit par les bienfaits de notre famille de l’Olympe (et plus encore). Pour le coup, on est rassasié sur ce plan-là !

Il y a tellement de choses à découvrir, expérimenter et apprécier dans Hades 2, que je n’ai aucune hésitation à le considérer comme le meilleur jeu auquel j’ai joué en 2025.

Site de Hades 2

Mise à jour 2026 du site

2026-01-26T22:30:00+01:00

Après plusieurs années à ne plus toucher à ce site, l’envie m’a pris d’en revoir le design pour quelque chose d’encore plus minimaliste. Je dois en être à la neuvième version de ce site depuis ~2010, ça commence à faire une belle longévité !

J’ai viré la mini-couche de JavaScript qui restait. J’ai aussi retiré le mode sombre : pour un site avec si peu à lire, le cout de la maintenance n’en valait pas la peine.

J’ai retravaillé très légèrement le texte de la page d’accueil pour lister les projets principaux sur lesquels j’ai bossés récemment. J’avais initialement envie de faire une page dédiée pour chacun d’eux, mais ça représentait plus de boulot, en contradiction avec mon envie de minimalisme.

En 2023, j’ai décidé d’ensevelir le blog : les articles restent en ligne, mais ils ne sont plus accessibles depuis l’accueil. Je n’ai pas décidé de revenir sur cette décision avec cette version. Elle me satisfait toujours autant en me retirant toute forme de pression 😊

Mes jeux 2024

2025-02-09T11:35:00+01:00

Comme en 2023, j’ai décidé de faire une rétrospective des jeux auxquels j’ai joué l’année passée (voir la rétrospective de mes jeux 2023).

Il faut savoir que je me fais en début d’année une petite liste des jeux auxquels j’aimerais jouer sur l’année. Ça me permet d’être moins tenté par les nouveautés « à la mode », mais aussi de mieux profiter des jeux auxquels je joue. Ça a été une très bonne pioche en 2024.

No Man’s Sky

J’ai commencé l’année en jouant à No Man’s Sky. Il s’agit d’un jeu d’exploration et de survie spatiale dont l’univers (infini ?) est créé de manière procédurale¹.

J’étais resté sur le souvenir d’un jeu hyper attendu mais qui avait énormément déçu à sa sortie. J’avais néanmoins entendu dire qu’il s’était bonifié avec le temps et ses nombreuses mises à jour.

Ça a failli être une déception car je n’ai pas été immédiatement happé par le jeu. Comme tout jeu de survie, je me suis assez vite lassé et je l’ai mis de côté. On discerne en effet assez rapidement certains des artefacts qui permettent au jeu d’être « infini » ; par exemple les dialogues avec les autres personnages scriptés à l’extrême, ou les planètes générées selon un même schéma répétitif. De plus, j’y ai joué sur la Switch qui galère pas mal à faire tourner le jeu (quoique j’estime que le niveau de fluidité global soit un petit exploit pour ce jeu !)

J’ai toutefois décidé de relancer le jeu en décembre, un peu par hasard. C’était l’ambiance parfaite qu’il me fallait pour finir l’année : bien que les artefacts du jeu soient toujours aussi visibles, il y a aussi une ambiance très douce, presque mélancolique, qui se dégage de No Man’s Sky. La musique transporte le joueur à travers l’immensité de l’univers du jeu et j’ai finalement pris plaisir à simplement suivre la quête principale, tout en construisant une base sur ma planète « paradisiaque » (elles ne le sont pas toutes !)

J’ai finalement passé une cinquantaine d’heures supplémentaires sur le jeu 😅 Une très bonne surprise tout compte fait !

Lien vers le site de No Man’s Sky.

Story Teller

Story Teller est un petit jeu d’énigmes. Chaque énigme consiste à narrer une histoire en quelques cases. On agrémente chacune des cases avec une scène (= un lieu) et des personnages qui vont interagir entre eux. Seulement, les interactions changent et évoluent en fonction des cases précédentes. Par exemple, si on a fait se marier deux personnages à la première case, si la seconde case représente le décès de l’un des deux, l’épous·e sera triste.

C’est un bon jeu pour se creuser les méninges, sans perdre trop de temps (quelques minutes pour chaque énigme). Il a l’avantage d’être très simple à prendre en main. La difficulté des énigmes est toutefois assez inégale et le jeu plutôt court (je l’ai terminé en environ 4h). Cela n’empêche pas Story Teller d’être un jeu malin, bien pensé et agréable à jouer.

Lien vers le site de Story Teller.

Sea of Stars

Sea of Stars est un RPG « à l’ancienne » mais avec des mécaniques de gameplay remises au goût du jour. On y incarne deux enfants du Solstice, élevé·es en guerriers pour botter le train des monstres d’un alchimiste malfaisant : le Fleshmancer.

Le scénario est bien mené, parfois un peu simpliste sans que ce soit trop gênant puisque porté par des personnages très attachants². Quelques twists dans l’histoire permettent de rester accrochés. J’ai particulièrement aimé les petites énigmes qui parsèment le jeu, jamais bien compliquées, mais bien dosées. Les quêtes secondaires rajoutent du contenu agréable et pas rébarbatif, ce qui permet d’en profiter quelques heures de plus. Enfin, pour ne rien gâcher, le jeu est très beau avec son look rétro et sa musique soignée.

Je rangerais Sea of Stars dans la catégorie de mes jeux un peu « doudous ». Peut-être pas mon jeu de l’année, mais j’ai pris du très bon temps dessus, au point que je veuille terminer l’ensemble des quêtes secondaires pour ne rien manquer. Je conseille vivement !

Lien vers le site de Sea of Stars.

Return of the Obra Dinn

Il s’agit là encore d’un jeu d’énigme. On débarque sur un bateau, l’Obra Dinn, pour enquêter sur la disparition mystérieuse de son équipage. On est pourvu pour cela d’une montre à gousset un peu spéciale puisqu’elle permet de revivre les scènes qui ont mené à la mort des membres de l’équipage. On dispose également d’un livre de bord que l’on renseigne au fil de nos déductions. Le principe est de déterminer la cause du décès de chacun·e des membres du bateau.

Au premier abord, les graphismes du jeu sont assez déstabilisants et la boucle de gameplay se révèle plutôt répétitive. Il faut toutefois passer les premières appréhensions pour apprécier le jeu à sa juste valeur. Il y a notamment un côté très addictif à découvrir ce qui est arrivé à l’ensemble de l’équipage du bateau.

Ce n’est clairement pas un jeu facile — les déductions tiennent parfois à pas grand-chose —, mais il sait bien rétribuer le ou la joueuse quand elle finit par trouver la solution. De plus, il n’y a pas de mécanique punitive (pas de mort ou de chronomètre pour mettre la pression par exemple), ce qui permet d’apprécier tranquillement le jeu. J’ai fini par adorer les quelques heures passées dessus, et je pense que je retournerai sur l’Obra Dinn une fois que je l’aurai un peu oublié.

Lien vers le site de Return of the Obra Dinn.

Celeste

C’est un retour puisque Celeste faisait déjà partie de ma liste de jeux 2023 !

Il s’agit d’un jeu de plateforme en deux dimensions particulièrement exigeant. On y incarne Madeline, une jeune fille qui veut gravir une montagne : le Mont Celeste. C’est finalement sa dépression et son anxiété qu’on finit par affronter au fil de l’ascension.

Je concluais dans mon précédent article ainsi :

Mon avis est (un peu) mitigé vis-à-vis de ce jeu. Je pense que j’en attendais beaucoup, mais que le fait d’avoir atteint la « première » fin du jeu relativement rapidement ne m’a pas laissé le temps de l’apprécier à sa juste valeur. Pour autant, j’ai beaucoup aimé y jouer. J’ai de toute façon encore beaucoup de choses à faire, notamment les « faces B » des chapitres (des versions beaucoup plus ardues des cartes). […] Je pense que je l’apprécierai de plus en plus avec le temps.

Vous vous en doutez : ça n’a pas raté 😁

Je ne pensais pas passer autant d’heures supplémentaires dessus (une centaine d’heures, oui oui…) Pour autant, je me suis pris au jeu des défis supplémentaires qui m’attendaient après avoir gravi le Mont Celeste une première fois.

Le défi qu’a représenté la « vraie » fin du jeu a mis mes nerfs à l’épreuve, mais m’a aussi apporté un plaisir que je n’avais encore jamais vécu en jouant. Il faut vraiment prendre les défis que proposent Celeste comme des marches que l’on grimpe une par une. Dès qu’on butte un peu, alors c’est qu’il est temps de revenir un peu en arrière pour assurer toujours un peu mieux ses pas. C’est vraiment cette progression (et sa difficulté) qui porte tout au long du jeu.

Une mention spéciale pour le DLC qui m’a énormément touché. Il est non seulement absurdement dur, mais aussi très touchant et extrêmement généreux dans sa récompense finale. Terminer le DLC a probablement été l’une de mes meilleures expériences vidéo-ludiques de ces dernières années. J’ai rarement vu un gameplay aussi bien porter le message qu’il veut transmettre. Rien qu’à me le remémorer, j’ai envie de relancer le jeu !

J’ai poussé le bouchon encore un peu plus loin en visant de terminer la première fin du jeu en moins d’une heure. Défi relevé, mais je ne crois pas avoir envie de m’y replonger toutefois 😅

Bref, vous comprendrez que je recommande Celeste les yeux fermés. Si la difficulté assumée du jeu vous fait peur, sachez qu’il est possible d’ajuster la difficulté afin de profiter du jeu en fonction de son niveau.

Lien vers le site de Celeste.

De façon unique et aléatoire si vous voulez. ↩
Mention spéciale au personnage de Garl, évidemment ♥️ ↩

Mes jeux 2023

2023-12-24T10:00:00+01:00

Début 2023, je me suis fait une liste de jeux à jouer durant l’année. Je suis heureux d’avoir fait ça, car ça m’a permis d’être moins dans la « consommation » et de mieux apprécier mes découvertes. Petite mise en avant des jeux qui m’ont le plus marqué.

Hollow Knight

Dans Hollow Knight, on incarne un chevalier insecte muni de son aiguillon. On ne nous dit pas grand-chose, et c’est à nous de comprendre l’intrigue. On y explore une immense carte en deux dimensions, tout en combattant tout un tas d’ennemis. Les boss sont particulièrement velus.

C’était l’un de mes défis de l’année car le jeu est connu pour sa difficulté. De fait, j’ai eu du mal à me plonger dans le jeu, et il s’en est fallu de peu pour que je le laisse trainer dans un coin. Au final, je me suis remotivé et j’ai fini par me prendre au jeu. Et une fois le jeu fini une première fois… j’ai immédiatement lancé une seconde partie. Je voulais jauger ma progression, et je n’ai pas été déçu : le sentiment de facilité sur les premiers niveaux est grisant. J’ai rarement aussi bien ressenti le fait d’être devenu meilleur à un jeu.

Zelda Tears Of The Kingdom

Comme dans tout bon Zelda qui se respecte, on incarne Link qui doit sauver la Princesse Zelda, et tout le royaume d’Hyrule tant qu’à faire. J’avais adoré le précédent opus (Breath of the Wild), donc je ne pouvais pas passer à côté de celui-ci.

La particularité de Tears of the Kingdom réside dans la possibilité de fabriquer des outils. J’avoue avoir relativement peu joué de cette mécanique, sauf à recréer un peu toujours les mêmes objets (notamment le scooter volant, très pratique dans les sous-terrains).

J’ai trouvé le jeu un peu moins maîtrisé sur certains aspects comme les sanctuaires ou les pouvoirs. En revanche, la mise en scène et l’ambiance sont folles, et j’ai savouré chaque minute sur ce jeu. Mention spéciale à l’arrivée dans le Temple du Vent, incroyable.

Outer Wilds

Outer Wilds est une magnifique aventure d’exploration spatiale. On est balancé aux manettes d’une navette et muni d’un traducteur capable de déchiffrer d’étranges symboles laissés par une civilisation disparue il y a longtemps. À partir de là, on va devoir résoudre un puzzle à l’échelle de l’univers, en explorant chaque planète de notre système solaire une à une.

La puissance du jeu réside dans la découverte des mécaniques du jeu. Tout est sous nos yeux dès le début du jeu, et on pourrait résoudre le jeu en moins d’une heure (avec beaucoup de chance toutefois). Il en faut toutefois une bonne vingtaine pour réussir à recoller tous les morceaux.

Bon, clairement mon coup de cœur de l’année <3

Je guettais ce jeu depuis plusieurs années. Il était annoncé sur Switch, mais a été repoussé sans qu’une nouvelle date ne soit donnée. On me l’a finalement offert sur Steam. J’ai donc pu y jouer sur PC… juste avant que le jeu ne sorte sur Switch cette fin d’année !

En revanche, une fois le jeu terminé, pas moyen d’y rejouer puisqu’on connait désormais les mécaniques. Ce qui m’amène à ce conseil : ne vous spoilez pas le jeu ! Ne regardez pas la bande-annonce, ne recherchez pas d’informations en ligne, et suivez simplement le conseil de tous les joueurs et joueuses qui sont passés avant vous : ne vous spoilez pas (oui je me répète).

Et si vous aimez le jeu, n’hésitez pas à jouer à son DLC, Echoes of the Eye (dans une ambiance plus angoissante, vous êtes prévenu⋅es !)

Celeste

Celeste est un jeu de plateforme en deux dimensions particulièrement exigeant. Il raconte l’histoire d’une jeune fille qui veut gravir une montagne. C’est finalement sa dépression et son anxiété qu’on finit par affronter au fil de l’ascension.

C’est le dernier jeu auquel j’ai joué cette année et c’était mon deuxième défi de l’année. En effet, je ne joue pas trop aux jeux de plateforme, mais Hollow Knight m’avait déjà redonné un peu goût au genre.

Mon avis est (un peu) mitigé vis-à-vis de ce jeu. Je pense que j’en attendais beaucoup, mais que le fait d’avoir atteint la « première » fin du jeu relativement rapidement ne m’a pas laissé le temps de l’apprécier à sa juste valeur. Pour autant, j’ai beaucoup aimé y jouer. J’ai de toute façon encore beaucoup de choses à faire, notamment les « faces B » des chapitres (des versions beaucoup plus ardues des cartes).

Je continue donc d’y jouer et, comme Hollow Knight, le jeu sait faire progresser et nous en faire prendre conscience. Je pense que je l’apprécierai de plus en plus avec le temps.

Quelques jeux en rab’

J’ai joué à plusieurs autres jeux en plus de ceux listés ci-dessus, je les balance ici en vrac :

Powerwash Simulator, un simulateur de lavage à haute-pression, c’est très de niche, mais il procure une satisfaction énorme à laver des surfaces encrassées.
Brotato, un jeu de survie (à la Vampire Survivors pour celleux qui connaissent) où l’on équipe notre patate de divers armes pour survivre à des vagues d’ennemis ; c’est un gameplay très bête et méchant, mais ça peut détendre.
Superflu Riteurnz, le jeu d’enquête développé par l’ami Gee, on y incarne Harpagon Lonion (aka Superflu), assisté de Sophie, pour débusquer un mystérieux voleur de pommes ; c’est idiot, c’est fun, c’est coloré, c’est très chouette, jouez-y !
F-Zero 99, jeu de courses de voitures à l’ancienne, mais sauce battle royale ; chouette de jouer contre 98 adversaires, et assez exigeant, mais un peu répétitif à la longue (il y a peu de cartes).
Minetest, un clone de Minecraft, on mine des cubes, on construit des bâtiments, et on occit des monstres ; bref, la routine.

Conclusion

Je recommande chacun des 4 premiers jeux cités sans hésitation (aux amateurs de ces genres de jeux en tout cas). Et s’il ne devait y en avoir qu’un, ce serait Outer Wilds sans hésiter ! Je considère que cette année 2023 a été celle où je me suis le plus amusé d’un point de vue vidéoludique.

Je suis particulièrement heureux de m’être fait cette liste de jeux en début d’année. Ça m’a laissé le temps de m’impatienter pour chacun d’eux, un peu comme un cadeau de Noël qu’on attend de plus en plus à l’approche du 25 décembre. J’ai aussi davantage apprécié chacun de ces jeux en faisant en sorte que ce ne soit pas des jeux achetés sur un coup de tête. D’ailleurs, j’ai été beaucoup plus « consommateur » des jeux qui sortaient de cette liste ; j’ai moins pris le temps de les apprécier.

En 2024, je compte réitérer l’expérience de manière élargie : je compte me faire une liste de livres, musiques, films, et bien sûr jeux vidéos à acheter.

De l’ensevelissement de ce blog

2023-11-16T17:55:00+01:00

Depuis que je suis petit, j’ai toujours aimé écrire.

J’ai retrouvé récemment des écrits dans de vieux cahiers (CE2 et CM1) dont j’avais été particulièrement fier à l’époque. Au collège, je m’amusais à écrire de courtes histoires qui mettaient en scène mes pions de l’époque et que je distribuais ensuite à mes copains d’internat et de classe. Le jour où ma prof de français est tombée dessus, j’avoue avoir ressenti un mélange de honte et de fierté (elle m’a encouragé, merci à elle !) Au lycée, j’ai débuté un blog sur lequel je publiais aussi bien des billets d’humeur, que des poésies ou encore des tutos HTML et CSS.

Ce blog-ci existe depuis au moins 2011. J’y ai parlé de mes premières tentatives de projets Web, tout comme de mes projets plus aboutis, comme FreshRSS. Je n’ai jamais été extrêmement prolifique, mais j’ai toujours espéré trouver l’énergie de m’y mettre « vraiment ». En fait, c’était l’envie qu’il me manquait surtout.

La « ligne éditoriale » ne m’a jamais trop plu : j’aurais plutôt eu envie de publier de courts textes, peut-être plus expérimentaux. J’aurais pu la faire évoluer, mais je n’étais pas à l’aise avec ça sur mon site personnel. De plus, j’ai toujours eu du mal à voir attaché mon nom aux articles. Je suis bien plus à l’aise sous une forme d’anonymat.

Il y a quelques jours, j’ai donc décidé de supprimer la page principale du blog (celle qui listait les articles). Mon site se réduit donc à la page d’accueil pour me présenter et une page expliquant comment me contacter. Je suis plus à l’aise avec ça.

En revanche, pour l’instant, j’ai décidé de conserver les articles et le flux Web. Les personnes qui suivent ce blog depuis un agrégateur pourront donc continuer de le faire. En effet, je ne me ferme pas non plus la porte à l’écriture d’autres articles à l’avenir. Seulement, je n’ai aujourd’hui plus aucune pression pour le faire, et c’est bien mieux !

Quant à mes envies d’écrire, je compte éventuellement ouvrir un blog ailleurs. Mais ça, je n’en parlerai pas !

Refuser 10 000 dollars

2023-05-03T18:30:00+02:00

Aujourd’hui, j’ai refusé 10 000 dollars.

J’ai reçu un mail en provenance d’un bureau d’enregistrement de noms de domaine — transmis par OVH — me proposant de me racheter un nom de domaine. Voici le message (après traduction) :

Je vous contacte au nom d’un de mes clients qui est très intéressé pour vous acheter votre nom de domaine lessy.io et je voulais savoir si vous étiez prêt à le vendre. Nous aimerions vous faire une offre de 10K USD.

Pour ce que j’en ai vérifié, la demande me semble légitime et honnête. Quand bien même il s’agirait d’hameçonnage, ça ne change pas la principale raison de mon refus : je n’ai pas envie d’aider une boîte ou une personne qui a les moyens de mettre 10 000 dollars dans un nom de domaine. On ne fait pas partie du même monde.

Alors non, ce choix n’est pas rationnel. En revanche, il est politique.

Écrire une syntaxe de recherche

2023-05-02T18:10:00+02:00

J’aime plutôt bien la syntaxe de recherche de GitHub. Elle permet à la fois de rechercher à partir de texte « brut », tout en ciblant des propriétés particulières (ex. is:open label:bug).

Ça faisait un moment que j’avais envie de développer un parser pour ce type de syntaxe. Et ça tombe bien, j’ai eu l’occasion récemment d’en développer un !

Je l’ai écrit pour le projet Bileto (un gestionnaire de tickets et de parcs informatiques). J’en ai profité pour documenter le fonctionnement du moteur de recherche à destination des développeurs et développeuses. La documentation de la syntaxe, quant à elle, est directement intégrée à l’interface.

Le projet est écrit avec Symfony, et une partie du moteur de recherche dépend de l’ORM Doctrine. Ceci dit, il devrait être assez facilement adaptable. Toute une partie est générique, tandis que la partie « génération des requêtes DQL » (langage propre à Doctrine) est très proche du SQL.

JdLL 2023

2023-03-30T19:00:00+02:00

J’avais déjà fait une première annonce le mois dernier sur le blog de Flus : je serai présent aux JdLL, ce weekend à Lyon.

J’y donnerai deux conférences.

La première se nomme « Bileto : un produit & une philosophie ». Elle aura lieu samedi 1^er avril de 11h à 11h55, atelier du mouvement. J’y présenterai le logiciel que je développe depuis l’an dernier au sein de Probesys : Bileto. Il s’agit d’un logiciel de gestion de tickets et de parc informatique. Le projet est encore jeune, mais on avance bien ! Ce sera l’occasion de faire le point sur où on en est et de parler un peu de communauté.

Ma seconde conférence se nomme « Jouons avec les flux Web ». Elle aura lieu dimanche 2 avril de 13h à 13h55, salle des cultures. Je la donnerai avec ma casquette Flus. J’y présenterai trois prototypes de logiciels qui utilisent des flux Web : Hitchhiker (un planet), Flus Actualités / Hermès (une alternative collaborative à Google News) et Loquace (un réseau social). L’objectif est de montrer d’autres manières d’utiliser les flux Web que les traditionnels agrégateurs.

Le reste du weekend, je serai présent majoritairement sur le stand de Framasoft, et un peu sur le stand de Probesys. N’hésitez pas à venir faire coucou !

Réflexions autour des IA spammeuses

2023-03-26T20:30:00+02:00

À l’inverse d’autres technos comme les NFT ou le Metaverse, j’ai le sentiment que nous n’échapperons pas au raz-de-marée des technologies basées sur de l’Intelligence Artificielle. Nous n’échapperons pas non plus aux dégâts qu’elles occasionneront. Je note ici quelques réflexions que j’ai partagé en interne sur le Framateam de Framasoft.

J’ai observé depuis quelques semaines du côté de FreshRSS une recrudescence de tickets faisant des demandes à priori légitimes. Ces tickets ont été créés par des utilisateurs dont le compte GitHub a disparu quelques jours plus tard (exemples 1, 2, 3, 4). Certains ont clairement des comportements bizarres, voir notamment celui qui m’a amené à me poser ces questions. Le ticket se trouve dans le mauvais dépôt, le titre semble répondre à un autre ticket du dépôt principal, mais le contenu est incohérent. D’autres tickets sont plus cohérents, mais restent « étranges ». Quoi qu’il en soit je n’avais encore jamais vu autant de comptes différents disparaître aussi vite qu’ils sont apparus. Je me demande si ce n’est pas GitHub qui les a supprimés.

J’ignore si ces comptes étaient gérés par des bots. Le problème est que cela aurait pu l’être. Quoi qu’il en soit, ça m’a amené à penser que les technologies comme GPT vont ouvrir grandes les portes au spam dans le moindre interstice d’Internet. Avec l’évolution de la technologie, ça va devenir de plus en plus compliqué de faire la distinction entre un compte légitime et un compte de spammeur. Au point, j’imagine d’épuiser les mainteneurs de projets communautaires (dans le cas qui m’intéresse en l’occurrence, mais potentiellement toute personne amené à lire / réfléchir / réagir à du contenu posté par une autre personne).

J’ai également de gros doutes sur la capacité des anti-spams actuels (ex. Rspamd, Akismet) à détecter du spam généré par une IA.

Enfin, je pressens une perte de confiance dans le contenu posté par autrui : si je ne sais pas si je fais face à une véritable personne intéressée par mes propos ou à un bot qui veut me faire tourner en bourrique, combien de temps vais-je tenir avant de me désintéresser des interactions sur le Web ?

Sonktionary

2023-03-04T15:18:00+01:00

Dans la catégorie « projets bêtes », je vous présente Sonktionary. Il s’agit d’une table de sons (aussi appelée « sound board ») avec des mots issus du Wiktionnaire. Le principe est simple : vous cliquez sur un mot, Sonktionary prononce le mot.

Là où il devient marrant, c’est qu’il est également capable de lire le « hash » de l’URL (i.e. ce qui se trouve après le #). Par exemple, si vous ouvrez l’URL marienfressinaud.frama.io/sonktionary/#on veut la retraite à soixante ans et cliquez sur « Jouer », Sonktionary vous lira la phrase « on veut la retraite à soixante ans ». Vous pouvez évidemment créer vous-même vos propres phrases en changeant les mots dans l’URL. Les mots doivent être les mêmes que ceux de la page, mais vous pouvez les finir avec des virgules, des points et des point-virgules pour marquer les pauses.

Précision utile : Sonktionary ne sert à rien¹ (j’avais seulement envie de m’amuser avec).

Pour accéder au code source, c’est sur Framagit. Vous pouvez également ouvrir le code source de la page : tout tient dans l’unique fichier index.html (à l’exception des fichiers sons). Par contre, je n’ai pas fait d’effort sur la propreté du code ; vous êtes prévenu‧es.

C’est pourquoi c’est un chouette projet. ↩

CSS minimale pour des sites moins moches

2023-03-01T08:15:00+01:00

Je suis retombé récemment sur les sites satiriques motherfuckingwebsite.com et bettermotherfuckingwebsite.com¹. Ce qui m’intéresse sur ce dernier, c’est qu’il se contente de 7 lignes de CSS pour rendre le site beaucoup plus lisible. En me basant dessus, je vous propose une variante légèrement améliorée :

body {
    max-width: 60ch;
    margin: 3rem auto 10rem;
    padding: 0 0.5rem;
    color: #444;
    font-size: 120%;
    line-height: 1.6;
    background-color: #f9f9ff;
}

h1, h2, h3 {
    line-height: 1.2;
}

img {
    max-width: 100%;
}

Quelques explications vis-à-vis de mes adaptations :

j’utilise des unités relatives (rem, ch) pour que les tailles/marges s’adaptent au contenu ;
la taille de la police est déclarée en pourcentage pour s’adapter aux préférences du navigateur de l’utilisateur ;
l’espace en bas du contenu est élargi car il est moins agréable de lire le texte collé au bas de l’écran ;
le fond de l’écran est légèrement grisé pour atténuer la luminosité de l’écran (et tire vers le bleu pour que ce soit moins terne) ;
les images sont limitées à 100% de la taille maximale du contenu afin qu’elles ne dépassent pas de l’écran.

Notez que ces deux sites « minimalistes » ont réussi l’exploit d’intégrer Google Analytics. Sérieux ? ↩

C’est quoi un bon langage Web ?

2023-02-22T09:00:00+01:00

Pour m’amuser, je me suis mis en tête d’inventer un langage Web côté serveur. Mon objectif est d’en faire un langage pédagogique pour enseigner la programmation de sites et d’applications Web.

Jusque-là, le langage de prédilection pour cela est PHP. Deux raisons principales à cela selon moi :

il est à la fois un langage de programmation et un mini-framework (lecture directe des entrées via les variables globales $_GET, $_POST, etc. ; sortie avec de simples echo ; c’est aussi un langage de templates)
une fois bien configuré, un site en PHP peut s’installer très facilement sur un serveur : déposez les fichiers et ouvrez le site directement dans le navigateur

PHP s’est amélioré avec le temps, mais il possède toujours de gros défauts issus de son histoire.

Quelques qualités pour un meilleur langage Web :

très peu de concepts et de mot-clés à apprendre ;
une seule manière de faire les choses ;
une syntaxe claire et non ambigüe ;
un ensemble cohérent.

Je pense m’inspirer de langages comme Python et Ruby pour le côté programmation, tout en simplifiant ; de Jinja2 pour le côté template.

La question majeure que je me pose : à quoi ressemblerait un langage intuitif pour des personnes qui n’auraient jamais codé ? Dit autrement : comment appliquer des concepts d’expérience utilisateur (UX) à la conception d’un langage informatique ?

Je précise enfin qu’il s’agirait, pour moi, de (ré-¹)apprendre à développer un langage de zéro. Je cherche à tâtonner et à faire mes propres erreurs. Et je veux m’amuser à le créer.

Mais je sais pas quand je le ferai !

J’ai quelques souvenirs de mes cours en école d’ingé, mais tout cela est bien loin ! ↩

Farandole de projets

2023-02-10T08:30:00+01:00

Je multiplie les projets ces derniers jours. Exploratrices dont j’ai parlé ici. Hitchhiker dont j’ai parlé sur le carnet de Flus. Sonktionary dont je n’ai pas encore parlé. Hermès sur lequel je travaille actuellement. Sans compter Farandole que je n’ai pas encore commencé.

Ça fait franchement du bien d’expérimenter autant de choses.

Pour Exploratrices, c’était la spécification complète du projet avant de démarrer, ainsi qu’une approche technique très différente de ce dont j’ai l’habitude.

Pour Hitchhiker, c’était la contrainte minimaliste : faire autant que possible avec aussi peu de lignes de code que je pouvais me permettre.

Sonktionary : un projet rigolo et fonctionnel démarré en milieu de soirée sur un coup de tête.

Avec Hermès, je découvre les attributs PHP et je complète largement mon framework, Minz. Je compte aussi explorer avec ce projet la dimension collaborative (et ses difficultés).

Je fais tout ça sans la contrainte de maintenance, car je ne développe que des prototypes de logiciels. C’est une sorte d’exutoire pour se libérer l’esprit des projets qui me traînent dans la tête.

Libre à vous de vous en emparer.

Exploratrices, un prototype de jeu vidéo

2023-01-26T11:17:00+01:00

J’ai créé un prototype de jeu vidéo.

Il s’agit d’un jeu narratif qui se joue avec des commandes textuelles. C’est-à-dire que c’est un jeu qui se « lit » et il vous faut écrire des commandes pour jouer. Ce gameplay est inspiré des « Multi-user dungeon » (aussi appelés MUD). J’étais curieux d’en créer un dans un navigateur.

Il se nomme « Exploratrices » et vous y incarnez une Exploratrice qui arrive dans le village de Sylvaluna. Le but est simplement de vous balader pour en apprendre plus sur le village en observant ses habitantes.

~~Vous pouvez y jouer sur exploratrices.yuzu.ovh.~~

~~Information importante : ce prototype ne restera en ligne qu’au maximum pendant 2 mois.~~

Mise à jour : le prototype n’est plus en ligne !

Il est extrêmement court.
Il est extrêmement simple.
Il est extrêmement rudimentaire.
Mais il est terminé, et c’est le plus important.

Je ne compte pas continuer ce prototype. Taper des commandes n’a pas beaucoup de sens en termes de gameplay dans un jeu dont ce n’est pas le thème. C’est même assez vite chiant dans un navigateur Web. C’était ce que je voulais tester et je sais désormais que je veux une expérience de jeu différente.

Cela étant dit, les quelques lignes de code que j’ai pu écrire pour ce projet m’ont donné plein de perspectives, y compris du multi-joueurs. Je ne sais pas si je passerai beaucoup de temps là-dessus cette année, mais je sais que ce ne serait pas si compliqué de faire quelque chose de chouette.

Et puis je me suis attaché à l’univers, j’aimerais l’explorer un peu plus à l’occasion.

Si vous voulez en apprendre plus sur le projet, j’ai tout détaillé dans le fichier README du projet. Vous le trouverez ici : framagit.org/marienfressinaud/exploratrices

J’y parle des mécaniques de jeu, de la technique et même du processus d’écriture avec… ChatGPT.

Le tout premier serveur Web

2023-01-25T17:35:00+01:00

Il y a quelques jours, je suis allé à Genève et j’y ai visité le CERN. Outre des accélérateurs de particules, on y trouve cet ordinateur dans une vitrine (désolé pour la qualité de la photo) :

Une photo du tout premier serveur Web. Un autocollant est apposé dessus où l’on peut lire (en anglais) : « Cette machine est un serveur. NE L’ÉTEIGNEZ PAS !! »

Un écriteau explique en dessous : « Cet ordinateur NeXT a été utilisé par Tim Berners-Lee, l’inventeur du World Wide Web (WWW) en 1989 lorsqu’il travaillait au CERN. Ce fut le premier serveur Web. À côté se trouve une copie du document dans lequel Tim Berners-Lee proposait le Word Wide Web : "Information management: A proposal". »

Le document lui-même est illisible, mais on peut y lire une appréciation (en anglais) : « Vague mais excitant… »

Ça n’a pas fait immédiatement « tilt » dans ma tête, mais c’est vertigineux de se dire que ce petit machin est si proche de nous aussi bien en termes de lieu que de temporalité. Le Web est à peine plus vieux que moi.

Publier sa veille Flus sur Mastodon

2022-09-19T18:15:00+02:00

Aujourd’hui, je vous explique comment publier automatiquement un flux RSS (ou Atom) sur Mastodon. Cet article pointe quelques particularités liées à Flus¹, mais la majorité des informations peuvent s’appliquer à n’importe quel flux.

Pour publier un flux sur Mastodon, vous avez besoin de 3 ingrédients :

un flux RSS (ici je vais prendre comme exemple le flux de mon profil Flus : https://app.flus.fr/p/1670839367044869607/feed) ;
un compte Mastodon (forcément) ;
et un outil qui va lire votre flux pour publier sur votre compte Mastodon : feediverse².

feediverse étant un outil en ligne de commande, vous devrez vous sentir suffisamment à l’aise avec cette dernière. Eh oui, cet article est un peu technique.

Installer feediverse

Pour installer feediverse, vous aurez besoin de Python et de la commande pip. Vérifiez que pip est bien installé avec la commande :

$ python -m pip --version

Si tout va bien, il vous affichera son numéro de version. En principe pip est disponible par défaut dans les dernières versions de Python. Si ce n’est pas le cas, vous pouvez suivre la documentation pour l’installer.

Une fois cela fait, installez feediverse :

$ python -m pip install feediverse

Puis configurez-le :

$ feediverse

Il va vous demander un certain nombre d’informations ; notamment votre instance / serveur Mastodon, de quoi générer un jeton d’authentification et… l’adresse de votre flux RSS.

Configurer le format des messages

Une fois cela fait, c’est presque terminé ! Vous aurez toutefois peut-être envie de configurer le format des messages postés sur Mastodon. Ouvrez le fichier de configuration ~/.feediverse dans un éditeur de texte et adaptez la propriété template à votre convenance. Par exemple :

feeds:
- template: "{title} {link} #veille"
  url: https://app.flus.fr/p/1670839367044869607/feed

Les liens (i.e. {link}) pointeront vers la page de vos commentaires Flus. Si vous préférez toutefois que les liens pointent directement vers les sites, vous pouvez modifier l’URL de votre flux en ajoutant le paramètre ?direct=true (exemple : https://app.flus.fr/p/1670839367044869607/feed?direct=true).

Exécuter feediverse

Il ne vous reste plus qu’à lancer feediverse pour qu’il poste sur Mastodon :

$ feediverse

Pour l’exécuter automatiquement à intervalle régulier, créez une tâche Cron (crontab -e) :

*/15 * * * * /home/USER/.local/bin/feediverse

Vous devrez probablement mettre le chemin absolu vers la commande (comme dans l’exemple ci-dessus). Vous le trouverez avec cette commande :

$ whereis feediverse
feediverse: /home/USER/.local/bin/feediverse

Bonus : Publier les liens Flus ET directs

Si vous voulez publier à la fois les liens vers vos commentaires Flus et vers les articles pointés, il existe une méthode. Mais attention, il va falloir se relever les manches du clavier et traficoter directement dans le code de feediverse³.

Commencez par trouver où il a été installé :

$ python -m pip show feediverse | grep Location
Location: /home/USER/.local/lib/python3.10/site-packages

Ouvrez ensuite le fichier /home/USER/.local/lib/python3.10/site-packages/feediverse.py dans un éditeur de texte.

Trouvez la ligne def get_entry(entry): (ligne 85 chez moi), puis, quelques lignes plus bas, le return { … }. Entre les accolades, ajoutez cette ligne :

return {
    # ...
    "links": entry.links,
}

Éditez maintenant le format de votre message (dans ~/.feediverse) :

feeds:
- template: "{title}\nLien : {links[1].href}\nCommentaires : {links[0].href}\n#veille"
  url: https://app.flus.fr/p/1670839367044869607/feed.atom.xml

Veillez à bien supprimer le paramètre ?direct=true de l’adresse du flux.

Normalement, les prochains messages postés par feediverse sur votre compte Mastodon devraient contenir un lien vers Flus et un lien vers les articles pointés.

Je pensais initialement publier cet article dans le carnet de Flus. Finalement, la méthode que je présente ici étant trop technique à mon goût et nécessitant l’utilisation de la ligne de commande, je me rabats sur mon blog perso. ↩
Il existe aussi feed2toot, mais je trouve son installation beaucoup plus compliquée. ↩
J’ai ouvert une pull request pour que la modification soit intégrée directement dans feediverse, mais le projet semble en sommeil. ↩

Du plaisir de publier

2022-06-22T20:14:00+02:00

Depuis quelques mois, j’écris tous les jours. C’est parfois seulement un ou deux paragraphes ; souvent des notes écrites à la va-vite. L’exercice est quotidien et je m’y applique sans grand effort.

J’ai en revanche abandonné mes publications journalières. J’ai essayé un rythme moins soutenu, mais je n’étais pas plus assidu. Le plaisir n’y était pas.

Je n’ai jamais pris le sujet de la publication très au sérieux. Ça n’a toujours été qu’une étape pénible entre l’écriture et le fait d’être lu. Publier est une étape exigeante. C’est en la considérant comme telle que j’y trouverai du plaisir.

Supprimer ses comptes

2022-05-13T17:11:00+02:00

J’ai entrepris depuis quelques semaines de supprimer les comptes en ligne que je n’utilise plus.

Pour cela, je pioche dans ma liste d’identifiants stockés dans mon gestionnaire de mots de passe (Bitwarden), je me connecte, je trouve l’endroit pour supprimer mon compte et je confirme.

Ça, c’est quand ça se passe bien. À la louche, je dirais que c’est ce qu’il se passe deux fois sur trois. Le reste du temps, il me faut :

passer par un formulaire de contact ;
fouiller dans les mentions légales pour dénicher une adresse de contact (idéalement le DPO) ;
abandonner, tout simplement.

Lorsque je fais une demande, je mets à jour l’enregistrement dans Bitwarden pour préciser « (suppression demandée le XX/YY/ZZZZ) ». Souvent, je n’obtiens pas de réponse.

On n’insistera jamais assez : si vous proposez ou imposez la création d’un compte en ligne, permettez également sa suppression dans des conditions satisfaisantes (un bouton dans une section « profil » ou « compte » fait l’affaire).

Questions d’entretien

2022-05-11T10:23:00+02:00

J’ai passé un entretien il y a quelques jours. Je liste ci-dessous quelques questions que j’ai posées :

quel est le modèle économique de l’entreprise ?
par qui / comment les clients sont-ils choisis et démarchés ?
arrive-t-il de travailler avec des clients parce que l’entreprise n’a pas le choix de faire autrement ?
combien de personnes travaillent dans l’entreprise ?
quelle est l’ancienneté moyenne des salarié·es ?
quels sont les métiers exercés dans l’entreprise ?
comment les personnes communiquent-elles entre elles ?
vais-je travailler en équipe ?
un mi-temps est-il possible ?
combien serai-je payé ?
de quelle convention collective dépend l’entreprise ?
quels sont les avantages apportés par l’entreprise ?
le télétravail est-il possible ?
y a-t-il une flexibilité sur les horaires de travail ?
comment sont organisés les entretiens annuels ?

Par ailleurs, on m’a parlé de societe.ninja qui permet de retrouver toutes les informations publiques des entreprises, incluant notamment les comptes et les actes officiels. Ça peut aider à préparer son entretien. L’outil derrière est libre, sous licence AGPL.

Routines

2022-04-25T20:15:00+02:00

L’année dernière, j’ai commencé à m’organiser avec des routines. Le principe est de me donner de courtes tâches à faire de manière régulière. Cela m’a permis de m’assurer que mes tâches administratives étaient bien faites, ou mes plantes bien arrosées par exemple.

Au début, tout était stocké dans un wiki. Il y a 2 mois et demi, j’ai poussé le principe un peu plus loin en les organisant dans un tableur. Ce changement m’a permis principalement d’ajouter la date de la dernière fois à laquelle j’effectue chaque tâche. Cette information, combinée à la fréquence (ex. 1, 7, 30 jours), permet d’afficher chaque jour les routines que j’ai à faire, ou celles qui prennent du retard.

Par rapport au wiki, ce système a plusieurs avantages :

présentation plus adaptée, je vois toutes les routines en un coup d’œil, c’est plus agréable ;
facile d’accès (2 clics) et accessible hors-ligne, je l’ai donc toujours sous les yeux et je ne l’oublie pas ;
facile de modifier, je peux ajouter (ou supprimer) plus aisément de nouvelles routines, j’y gère donc plus de choses ;
le tableur me demande d’être actif pour modifier les dates, je suis donc amené à l’utiliser quotidiennement ;
en récompense visuelle, le tableur me montre en vert ce que j’ai fait dans la journée, ça me motive à réaliser mes routines.

Je ne crois généralement pas aux solutions magiques d’organisation, mais je suis particulièrement content de ce système. En revanche, il ne permet pas de se motiver à faire les choses pour lesquelles on traîne des pieds (comprendre « ça ne m’a pas motivé à publier tous les jours »).

En bref, je n’aurai jamais autant pris soin de mon dos, nettoyé mon appartement ou appelé mes parents que ces derniers mois. C’est pas mal, non ?

Lessy est terminé

2022-04-12T10:18:00+02:00

Lessy ~~est~~ était un gestionnaire de temps mettant à disposition une liste de tâches et un gestionnaire de projets.

Il y a un an, j’écrivais :

En l’état, Lessy m’est en fait relativement peu utile. […] Ma manière de gérer mes tâches a évolué et j’arrive la plupart du temps à me contenter d’un bout de papier […].

Lessy, dans sa version actuelle, correspond en fait pas mal à ce que je souhaitais avoir quand j’ai commencé son développement. […]

Tout bien pensé, je crois que Lessy est terminé.

Depuis, rien n’a vraiment changé. Je gère toujours mes tâches sur un bout de papier, aidé en plus par un mécanisme de routines qui ne nécessite que d’une feuille de tableur (je vous en reparle prochainement). Je continue également de penser que Lessy, dans sa forme actuelle, correspond à ce que j’imaginais initialement et qu’il n’a plus besoin de changer.

Le problème, c’est que je ne savais pas trop quoi faire de lui. En octobre dernier, j’ai décidé de fermer les inscriptions sur lessy.yuzu.ovh. C’était déjà un petit soulagement.

Mais que faire alors du code existant ? Initialement, je pensais terminer Lessy proprement en n’ajoutant plus de fonctionnalités, mais en continuant de mettre à jour les dépendances logicielles afin d’éviter des failles de sécurité. Mais je dois vous avouer que je n’en suis plus capable. Les dépendances JavaScript sont une véritable plaie à maintenir avec des trucs qui pètent dans tous les sens à chaque mise à jour. C’est une charge que je n’ai pas envie de gérer.

Finalement, j’ai décidé de clore et archiver le dépôt de code un peu plus sauvagement. Le fichier README a été mis à jour pour expliquer que le projet n’est plus maintenu. Je continuerai de maintenir le service lessy.yuzu.ovh ouvert tant que des gens l’utiliseront (et il y en a !) ; les inscriptions, elles, resteront fermées.

Je suis très heureux d’avoir bossé sur Lessy avec lequel j’aurai appris plein de choses. Mais je suis encore plus content de pouvoir annoncer qu’il est terminé et ainsi de ne plus avoir à m’en soucier 🙂

Courriel et page de contact

2022-04-11T18:15:00+02:00

Il y a 2 mois, une entreprise travaillant dans le RGPD m’a informé avoir collecté mon adresse courriel personnelle.

Je les ai donc contactés pour savoir pourquoi et comment ils l’avaient collectée. Ils m’ont répondu créer un annuaire de sociétés françaises à partir de données publiques à des fins marketing. Ils m’ont également précisé que « [mon] adresse commençant par le mot "contact", cette dernière rentre dans le cadre des adresses email génériques ».

Mon adresse se terminant en "@prénomnom.fr", elle n’est évidemment pas du tout générique. De plus, le concept d’adresse générique ne s’applique que dans un cadre B to B ; jusqu’à preuve du contraire, je ne suis pas une entreprise¹.

Pour m’assurer que les choses soient claires, j’ai donc créé une page de contact qui indique mon adresse tout en précisant que je refuse le démarchage commercial et que je refuse qu’elle soit stockée. J’ai également pris soin de virer l’adresse de toutes les autres pages du site afin qu’elle ne soit pas séparée de mes conditions.

Je ne suis pas naïf : ce genre d’entreprises collecte les adresses automatiquement et ne vérifient rien du tout manuellement. Mais je pourrai au moins leur mettre le nez dans leur caca désormais.

En revanche ma micro-entreprise porte mon nom, ce que je trouve hyper relou. D’un point de vue RGPD, c’est naze. ↩

Logiciel libre et gratuit

2022-03-29T15:33:00+02:00

On lit ou entend régulièrement¹ qu’il y a confusion entre logiciel « libre » et « gratuit ». Il est alors généralement précisé qu’un logiciel libre n’est pas forcément gratuit, que cela viendrait du double sens en anglais du terme « free » (signifiant à la fois « libre » et « gratuit »).

Si je comprends la confusion dans le monde anglophone, cela ne l’explique pas ailleurs où le double sens n’existe pas.

Hypothèse toute bête : si le grand public se méprend souvent sur le caractère nécessairement gratuit du logiciel libre, c’est tout simplement que les logiciels libres le sont dans leur très grande majorité.

Réflexion supplémentaire : la gratuité ne facilite-t-elle pas la liberté en garantissant l’accès aux logiciels pour les budgets les plus serrés ? Ne ferait-on pas mieux de revendiquer ce caractère plutôt que de s’en défendre ?

J’abuse un peu parce que je ne le lis plus tant que ça. Je l’ai seulement revu récemment — je ne sais plus où – et ça me trotte dans la tête depuis. ↩

Préparer les 10 ans de FreshRSS

2022-03-28T11:53:00+02:00

FreshRSS va avoir 10 ans en octobre. J’aimerais célébrer ça d’une manière ou d’une autre, mais j’ai peur de me lancer dans quelque chose de trop grand pour moi. Je pensais simplement revoir le site pour le rendre plus attractif et ajouter des informations manquantes.

J’ai ouvert une discussion sur GitHub pour que d’autres personnes puissent s’exprimer et éventuellement faire des choses ensemble.

Boop! 1.0

2022-03-17T11:50:00+01:00

Il était temps de le faire : je viens de sortir la version 1.0 de Boop!, mon générateur personnel de sites statiques.

Si je dis qu’il était temps de le faire, c’est que je considère qu’il est terminé depuis octobre dernier. Terminé, cela signifie que je ne compte plus ajouter de grosses fonctionnalités et limiter le polissage au strict minimum. Les bugs et failles de sécurité continueront d’être corrigées. Comme je l’ai dit dans un article plus ancien : s’il manque des choses, ce sont pour d’autres besoins que les miens.

Bref, Boop! est stable.

Depuis la version 0.4 sortie en novembre 2019 (!), peu de choses ont été ajoutées :

la possibilité d’exclure des articles de la page principale du blog (et de son flux) ;
l’activation de toutes les extensions Markdown « extra » ;
le support des hubs Websub pour les flux Atom ;
la génération d’une page « sitemap » ;
l’ajout d’un warning si aucun UUID n’a été précisé dans la configuration ;
et la vérification que plusieurs pages/articles ne s’écrasent pas les uns les autres.

S’agissant d’un projet pensé par et pour moi, je ne vous invite pas à l’utiliser : les chances sont grandes pour qu’il ne vous convienne pas. S’il vous prenait toutefois l’envie de jouer avec, la documentation devrait désormais être complète.

Vous trouverez le code et la documentation de Boop! sur Framagit.

Projets secondaires

2022-03-15T10:42:00+01:00

J’accumule les projets secondaires depuis des années, principalement des bouts de code. J’ai expliqué il y a quelques semaines avoir commencé à « terminer » ces projets, mais je n’avais pas de recul sur ce qu’il me restait à faire. Je me suis donc créé un document synthétique :

13 sont déjà terminés / archivés ;
10 pourraient l’être assez rapidement ;
3 de plus seront amenés à l’être à moyen terme.

Il me resterait, en gros, 3 projets à maintenir (dont GDPR.txt), auxquels s’ajoutent la maintenance de différents sites ainsi que… tout ce que je fais dans le cadre de Flus et Framasoft, voire FreshRSS dans une moindre mesure. Bref, ça représente encore un peu de taf.

J’ai (quasiment) tout déplacé de GitHub vers Framagit, vous trouverez donc (quasiment) tous ces projets sur ce dernier. Une fois que j’aurai fini d’archiver ce qui peut l’être, je pense que je créerai une page dédiée sur ce site : certains projets mériteraient mieux qu’un dépôt de code perdu dans un coin.

Sur l’objectif du GDPR.txt

2022-03-10T12:10:00+01:00

J’ai publié un article sur le Framablog pour présenter le fichier GDPR.txt (présenté ici il y a quelques jours). Les premiers retours n’ont pas tardé, ainsi qu’une incompréhension majeure : celle de l’objectif même de ce fichier… c’est embêtant ! Cette incompréhension s’exprime sous la forme de deux suggestions :

que le fichier soit placé sous une URL de type /.well-known/ ;
que le fichier utilise un format structuré existant (ex. YAML).

In fine, il est demandé à ce que ce fichier soit facilement accessible à un navigateur — ou autre logiciel — afin d’exposer les informations de conformité RGPD des sites. Je le redis ici : ce n’est pas la proposition que j’ai faite.

Ma proposition est de mutualiser le travail de recherche des informations en laissant aux développeurs et développeuses le soin de déclarer les données et finalités de leurs logiciels. C’est un fichier écrit par des humains, à destination d’autres humains ; de la documentation en somme.

Cela étant dit, je trouve qu’un fichier standardisé sous /.well-known/ serait une excellente idée : c’est celle que j’avais en tête en commençant à travailler sur le RGPD à Framasoft d’ailleurs 😊 Pourquoi ma proposition est différente alors ?

dans l’immédiat ça ne nous aide pas à Framasoft et on a décidé de viser la conformité en priorité ;
je ne veux pas proposer un tel format sans l’avis d’un ou une juriste spécialisée ;
je n’ai pas l’énergie de m’occuper de ça (pour l’instant).

Ça viendra donc peut-être un jour, surtout si d’autres personnes s’emparent du sujet (et je vous y invite fortement !) Je veux d’ailleurs bien servir de relais entre ces personnes.

Pour creuser l’incompréhension, j’ai identifié trois raisons :

les personnes qui se sont intéressées au fichier sont des personnes qui cherchent elles-mêmes à se conformer au RGPD, pas nécessairement des développeurs et développeuses (qui sont ma cible principale) ;
le nom même rappelle le fichier « robots.txt » qui est un fichier à destination de machines et non d’humains ;
j’ai proposé un format pseudo-structuré, alors qu’un format libre aurait été largement suffisant (puisqu’on est plus sur de la documentation qu’autre chose).

Ma proposition serait donc de virer toute la partie structuration du fichier et de concentrer mes explications sur comment bien remplir le fichier. Je pense également laisser libre le format du fichier (GDPR.md serait tout aussi bien par exemple).

→ Je suis preneur de vos suggestions et remarques sur le sujet.

Spam 2

2022-03-07T12:55:00+01:00

Je découvre une nouvelle forme de spam :

le spammeur s’inscrit sur un site random avec mon adresse courriel ;
il met son message de spam avec un lien vers son site dans le champ nom d’utilisateur (ou autre) ;
je reçois le courriel de confirmation de compte, incluant un récapitulatif des infos, donc le message de spam.

J’imagine que ce mécanisme permet de passer à travers un certain nombre d’antispams puisque l’envoyeur du courriel est légitime (bon, en l’occurrence le serveur d’envoi semble mal configuré et le message a quand même été marqué comme spam).

Finalement, ce qui me saoule le plus c’est que je me trouve inscrit de force sur un site allemand « spécialiste de la fourniture d’embrayages, de freins et de disques » dont je n’ai que faire.

Sélection d’articles

2022-03-06T19:00:00+01:00

J’ai fait le choix de ne pas lister tous mes articles sur la page du blog. La liste est limitée à un maximum de 20 articles et remonte jusqu’à 6 mois en arrière.

Certains articles plus vieux méritent tout de même de rester en première page, parce que je les aime bien, ou parce qu’ils marquent une étape importante dans mon parcours. Je veux garder cette sélection à un maximum de 10 articles.

Jusqu’ici, tout allait bien. Mais depuis que je publie plus souvent, je me demande si je ne vais pas avoir besoin de critères supplémentaires… ou être plus souple sur la limite ?

Joué, vu, écouté, publié, lu (février 2022)

2022-03-04T14:39:00+01:00

Joué à Hadès en pointillé. J’ai quelque 340 heures de jeu dessus, mais je continue d’y trouver du plaisir (et de nouvelles lignes de dialogues !) Vraiment un très bon jeu. Officiellement le jeu auquel j’ai le plus joué sur Switch, devant Zelda Breath of the Wild.

Vu « Media Crash, qui a tué le débat public ? » de Mediapart. Je n’ai pas l’impression d’avoir appris grand-chose, je ne sais pas si j’étais le public visé. Ça reste une analyse indispensable sur la concentration des médias.

Écouté Dido, Coldplay, Muse et Pink une bonne partie du mois : l’impression d’être retombé dans mes années lycée. C’est l’effet Lollypop et c’était pas désagréable.

Publié « Pour bâtir un morceau de Web ». C’est un article qui me trottait dans la tête depuis un moment et j’en suis content. J’ai malgré tout eu du mal à l’écrire, avec notamment une réécriture de zéro.

Lu « Contributing to BookStack (And Open Source) » (en anglais). C’est un bon guide qui fait le tour des différentes contributions possibles autour d’un projet open-source.

Publier un README sous forme de site Web

2022-03-02T23:49:00+01:00

J’ai parlé l’autre jour de mon initiative de fichier GDPR.txt. J’ai publié un site ce soir pour présenter tout ça : gdpr-txt.org. J’ai saisi l’occasion pour réfléchir à la manière la plus simple que j’avais de publier ce site. En trois mots : un fichier README, Pandoc et GitLab.

Le fichier README contient le contenu de mon site au format Markdown. C’est donc un site simple qui ne contient qu’une seule page. Pour commencer, ça me suffit amplement.

Pour le mettre en ligne, j’ai besoin de le transformer en HTML. Il existe des tas de solutions à base de générateur de sites statiques, mais je voulais un truc encore plus simple. J’ai un petit faible pour Pandoc, le couteau-suisse des convertisseurs de documents. La commande est simple :

$ pandoc --output=index.html README.md

Pandoc va lire le fichier README.md et générer un fichier index.html. On peut également préciser un template à Pandoc, afin qu’il génère un HTML plus complet :

$ pandoc --output=index.html --template=template.html README.md

Le fichier template.html n’est pas très compliqué à écrire¹ :

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>GDPR.txt</title>
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <style>
            html {
                color: #2b0e44;
                font-size: 24px;
                line-height: 1.3;
                background-color: #fefcfe;
            }

            main {
                max-width: 700px;
                margin-right: auto;
                margin-left: auto;
                padding-top: 5rem;
                padding-bottom: 5rem;
            }

            a {
                color: #8445bc;
            }

            a:hover {
                color: #793aaf;
            }
        </style>
    </head>

    <body>
        <main>
            $body$
        </main>
    </body>
</html>

Notez que j’ai décidé d’embarquer un peu de CSS directement dans mon template pour éviter de m’encombrer d’un fichier supplémentaire. Ce sera un choix à revoir si le style devient plus complexe.

Il ne reste plus qu’à mettre ce HTML en ligne. Mon dépôt de code se trouve sur Framagit, une instance de GitLab. Celui-ci met à disposition un système pour publier facilement des sites statiques en ligne : GitLab Pages. Il suffit de créer un fichier .gitlab-ci.yml et de lui faire générer le site dans un répertoire nommé public/ :

---

pages:
  stage: deploy
  script:
    - apt-get update -y && apt-get install -y pandoc
    - mkdir public
    - pandoc --output=public/index.html --template=template.html README.md
  artifacts:
    paths:
      - public
  only:
    refs:
      - main

À partir de là, le site est automatiquement publié sur marienfressinaud.frama.io/gdpr-txt. Il ne me reste plus qu’à configurer mon nom de domaine pour le faire pointer vers Framagit. Mon enregistrement DNS ressemble à ça chez Gandi :

@ 10800 IN ALIAS marienfressinaud.frama.io.
_gitlab-pages-verification-code 10800 IN TXT "gitlab-pages-verification-code=90dff6058cf863ecb357ab2279e144fb"

Pas d’inquiétude : les informations sont bien entendues fournies par Framagit².

Je suis plutôt content de cette solution. Elle ne révolutionne rien et reste technique, mais elle se met rapidement en place et m’a demandé peu de connaissances supplémentaires. J’aurais pu me passer de la partie DNS, voire également de Pandoc en écrivant directement le fichier HTML (ça m’arrive), mais j’aime le confort de rédaction du Markdown.

Je l’ai tout de même légèrement simplifié par rapport à mon fichier d’origine pour des raisons de clarté. ↩
Attention toutefois à l’enregistrement de vérification (le deuxième) qui est légèrement erroné dans Framagit : il faut soit ajouter un point à la fin de _gitlab-pages-verification-code.gdpr-txt.org, soit virer la dernière partie (ce que j’ai moi-même fait). Il y a moins de risque d’erreur en passant par l’interface graphique de Gandi (pour une fois). ↩

Lollypop

2022-03-01T12:34:00+01:00

Comme je l’ai expliqué précédemment, je passe plus de temps à travailler hors-ligne. Comme j’écoute également beaucoup de musiques, je redécouvre celles qui traînent sur mon disque dur. J’ai longtemps été satisfait par Rhythmbox pour écouter ma musique, mais j’ai fait face à pas mal de bogues gênants en le rouvrant dernièrement. On m’a suggéré de jeter un œil à Lollypop ; c’était exactement ce que je cherchais.

Non content d’être moins bogué, son interface est plus intuitive et plus pratique. L’interface ne ressemble pas à un gestionnaire de base de données, mais à une application dédiée à l’écoute de la musique. La navigation se fait notamment par albums, artistes, voire par années ou genres de musique. Il y a également un système de suggestions ; j’apprécie tout spécialement la suggestion de l’« album du jour ».

Il y a toutefois parfois de petites frictions à l’utilisation comme des incertitudes sur comment accéder à l’écran de l’album actuellement joué par exemple. Le plus gênant à mon sens est la synchronisation initiale des musiques : l’interface reste vide tant que la synchro n’est pas terminée, ce qui peut durer plusieurs minutes. J’ai cru que Lollypop ne fonctionnait pas, jusqu’à apercevoir une (discrète) barre de chargement en bas de l’écran. Mais malgré ces quelques petits défauts, je tiens à souligner la très grande qualité de Lollypop.

Mention spéciale à son auteur qui considère Lollypop comme « terminé », signe de maturité du projet. J’en ai profité pour lui faire un don de 10 €.

Le fichier GDPR.txt

2022-02-23T19:28:00+01:00

Dans le cadre de mon bénévolat pour Framasoft, je suis amené à travailler sur la conformité de l’association au Règlement Général sur la Protection des Données (RGPD). Ça fait des années qu’on essaye d’avancer sur le sujet, mais il faut bien reconnaître que, vu le nombre de services et d’activités qu’on gère, c’est la grosse galère. D’ailleurs, si ça vous étonne, on a une entrée claire dans la FAQ.

On a quand même bien avancé depuis octobre dernier, accompagné‧es que nous sommes par stella.coop. Notre liste des traitements est sur pied, mais il nous reste à compléter les fiches des différents traitements (on en documente d’ailleurs l’avancement publiquement). Il nous faut donc passer sur chaque service, déterminer les finalités des traitements, lister les données récupérées, vérifier si elles sont obligatoires, leur visibilité, etc.

Face à cette montagne, une idée me trotte dans la tête depuis un moment : ce serait pratique (et bien sympa de leur part) que les développeurs et développeuses de logiciels proposent elles-mêmes un document synthétisant les informations utiles dans le cadre du RGPD. Ça faciliterait le travail de celles et ceux qui proposent des instances de leur logiciel, ça mutualiserait le travail ingrat et ça limiterait les erreurs.

Comme on n’est jamais aussi bien servi que par soi-même, je teste actuellement un format dans le dépôt de flusio : le fichier GDPR.txt.

Le format est simple : un système clé: valeur organisé par blocs, chaque bloc étant séparé des autres par une ligne vide. Il existe deux types de blocs : celui pour indiquer les finalités et celui pour indiquer les données collectées.

Une finalité est décrite par les clés suivantes :

purpose : la finalité du traitement de données (champ libre) ;
lawfulness : la base légale du traitement (consent, contract, legal, public interest, legitimate interest, vital, cf. le site de la CNIL).

Une donnée est décrite par les clés suivantes :

data : le nom de la donnée collectée (champ libre) ;
required : si la donnée est obligatoire ou non (true ou false) ;
visibility : par qui est accessible la donnée au sein de l’application (champ libre, ex. private, public, administrators) ;
description : pour expliquer comment est utilisée la donnée (champ libre) ;
mitigation : pour détailler les mécanismes qui rendent la donnée moins vulnérable (champ libre facultatif, ex. « données supprimées après X jours », « pseudonyme autorisé »).

Si le format vous intéresse, j’ai créé un dépôt Framagit pour en discuter et améliorer les choses publiquement. Je crois que ce fichier est plus qu’utile et faciliterait la conformité RGPD pour beaucoup de monde.

Mise à jour du 02 mars.

J’ai finalement publié tout ça sous la forme d’un site dédié, gdpr-txt.org et d’un dépôt sur Framagit pour contribuer.

Publier souvent

2022-02-22T12:20:00+01:00

Ça va bientôt faire un mois que je me suis fixé l’objectif de publier un billet par jour. Le rythme était totalement arbitraire et je ne l’ai — évidemment — pas tenu : je ne tiens jamais ce genre de choses.

Le résultat est tout de même positif puisque j’ai publié 20 billets-articles : 17 ici et 3 dans le carnet de Flus.

Certains jours, j’ai également rédigé des billets sans les publier : soit pour le faire plus tard, soit parce que je n’avais plus envie de les publier.

Quelques billets rédigés à l’avance se trouvent dans un état intermédiaire : je ne sais pas quoi en faire. Dans ce genre de cas, il m’est arrivé de les réécrire de zéro. Ça a été le cas de mon billet « Pour bâtir un morceau de Web ».

J’ai réalisé que, même pour de très courts billets, je pouvais passer beaucoup de temps de relecture. Après rédaction, j’ai encore corrigé et reformulé le billet concernant Apostrophe pendant 30 minutes ; il fait quatre paragraphes. J’adore cette étape, mais j’ai parfois l’impression d’y perdre en spontanéité.

En partageant des choses, on bénéficie également des lumières des autres. Je connais François depuis longtemps, mais je ne savais pas qu’il me lisait : il m’a corrigé ma requête SQL infernale (confer la mise à jour en bas de page). Quant à lui, il devrait désormais utiliser l’attribut lang sur les balises HTML <i> pour indiquer les mots de langues étrangères 🙂

Publier, c’est utiliser son site. Le faire de manière régulière a été l’occasion d’améliorer un certain nombre de choses dessus : l’optimisation des images, l’ajout d’un thème sombre et de Turbolinks, le support de technos issues de l’IndieWeb et d’autres trucs qui n’ont pas eu le droit à un article.

Dans l’ensemble j’ai pris du plaisir à rédiger. Je suis également content d’avoir publié certaines choses sans me poser la question de savoir si ça intéresserait d’autres personnes : je publie pour moi avant tout.

Je vais conserver cet objectif d’un billet par jour, toujours sans le tenir. J’ai envisagé de viser un billet par semaine, mais je sais que rater un objectif atteignable me démotiverait bien plus que de rater un objectif que je sais inatteignable.

Spam

2022-02-13T23:59:00+01:00

Je ne sais pas ce qu’il se passe en ce moment, mais ça semble être la foire aux spams.

Ça a commencé avec les appels d’arnaque au Compte Personnel de Formation à partir de fin décembre.

Ça a continué avec des boîtes qui m’envoient de la pub à mon domicile sous couvert que mon adresse postale est une adresse professionnelle. Fonctionne évidemment aussi avec mes adresses courriel liées à Flus, même celles qui sont purement techniques.

Sont venus d’autres numéros qui m’appellent régulièrement. Cette semaine, un numéro a tenté de me joindre quasiment tous les jours. Je l’ai bloqué.

Aujourd’hui, ce sont 260 courriels que mon serveur a rejeté (contre 45 sur l’ensemble du reste de la semaine). Ce sont les quelques faux négatifs qui m’ont mis la puce à l’oreille. Heureusement que j’ai mis sur pied un blocage par nom de domaine il y a quelques semaines.

Je ne sais pas ce qu’il se passe en ce moment, mais ça commence légèrement à m’agacer…

IndieWeb

2022-02-12T13:15:00+01:00

Ça faisait quelques années que je gardais le site de l’IndieWeb dans un coin. Parfois il disparaissait de mes signets, mais il y revenait systématiquement. Comme je passe plus de temps sur mon site ces derniers temps, j’ai enfin saisi l’occasion de me pencher dessus le weekend dernier.

Déjà, c’est quoi l’IndieWeb ? Voilà ma traduction de la définition donnée sur leur site :

L’IndieWeb est une communauté de sites Web personnels individuels, connectés par des standards simples, basés sur les principes de posséder votre nom de domaine, de l’utiliser comme identité principale, de publier sur votre propre site (éventuellement en syndiquant ailleurs) et de posséder vos données.

Plus concrètement, il s’agit d’une démarche qui vise à fédérer des sites Web personnels indépendants à travers des formats et des protocoles simples à mettre en place. Par exemple, le protocole Webmention permet de notifier un site lorsque vous le mentionnez sur votre propre site ou sur un réseau social. Le mécanisme de réponse ou de « likes » n’est ainsi plus restreint à une plateforme en particulier mais est entièrement décentralisé.

Pour démarrer, la page Getting started de leur wiki est plutôt bien faite, bien que légèrement intimidante au premier abord. Voici les étapes que j’ai suivies :

publier mon propre site derrière un nom de domaine que je possède (ça, c’était bon 👍) ;
déclarer mon identité au format h-card ;
relier mon site à mes comptes de réseaux sociaux à coup de liens rel=me ;
déclarer mon contenu au format h-entry et h-feed ;
syndiquer automatiquement mon contenu ailleurs (je pourrais éventuellement le faire vers Mastodon, mais je ne suis pas sûr de le vouloir ; par contre c’est le cas vers Flus) ;
partager ma démarche (c’est maintenant fait !)

C’est un peu plus simple si vous utilisez un CMS comme Wordpress. Dans mon cas — un site statique généré à la main —, il a fallu plonger les mains dans le HTML. Heureusement, les formats sont très simples à mettre en place : seulement quelques attributs class à ajouter par-ci par-là.

La page ne suggère pas de mettre en place Webmention, mais ça me grattait et je m’en suis occupé ce matin grâce à webmention.io. Les échanges sur Mastodon autour du sujet m’y ont largement encouragé. Mon but est d’être tenu au courant — via un flux Atom généré par webmention.io — lorsque mon site est mentionné ailleurs. Je ne sais pas encore si j’afficherai les mentions directement ici par contre.

Maintenant se pose la question de l’intérêt d’avoir fait tout ça. Pour être honnête, ça ne me saute pas immédiatement aux yeux en l’absence d’un écosystème riche autour de ces technologies. L’écosystème ne se mettra toutefois pas en place de lui-même, sans adoption par celles et ceux qui font le Web¹.

Je le chuchote en fin de page, mais j’aimerais creuser ce qu’il est possible de faire avec Flus. J’imagine déjà des choses avec les formats h-entry et h-feed, ou encore avec Webmention. Tout cela reste hypothétique car j’ai encore bien d’autres choses à faire avant ! ↩

git revise

2022-02-09T19:58:00+01:00

J’utilise très peu de surcouches ou de commandes additionnelles à Git. Il y a toutefois une sous-commande qui m’est devenue indispensable : git revise.

Si vous êtes du genre à réécrire l’historique de vos branches de travail — ce qui est une bonne chose à apprendre pour garder un historique clair —, vous devez connaître git rebase. Cette commande permet de réappliquer des commits par-dessus une nouvelle base. Je l’utilise principalement avec l’option -i qui permet de réécrire l’historique de manière interactive (pour fusionner ou éditer des commits à la volée par exemple).

git revise est sa petite sœur en plus intuitive et plus rapide. Elle permet notamment d’appliquer un patch sur un commit précis sans avoir à se fader la création d’un commit temporaire et la réorganisation des commits.

Technique de décrochage : débrancher Internet

2022-02-08T20:25:00+01:00

En ayant quitté Twitter le mois dernier, j’avais déjà bien diminué les distractions numériques. Il en subsistait toutefois encore : le tchat avec les copain‧es, Mastodon, les courriels qui arrivent, etc. Je n’allais quand même pas tout couper ! Quoique…

Il y a environ un mois, j’ai commencé à m’accorder des sessions de travail hors-ligne. C’est-à-dire que, selon les cas, je coupe la connexion dans les paramètres réseaux, voire je débranche littéralement mon câble RJ45. C’est un peu radical, je vous l’accorde, mais l’expérience est intéressante pour le changement opéré dans ma manière d’aborder le numérique.

Le premier impact, celui que je recherchais, est que je ne vérifie plus frénétiquement si j’ai de nouvelles choses à lire sur Mattermost ou Mastodon. C’est bête, mais c’est très efficace. Comme je ne suis plus happé par ces plateformes, mon cerveau se tourne plus facilement vers de l’écriture, ou vers des améliorations pour le site.

Ensuite, il faut s’adapter. J’écoute beaucoup de musique via des plateformes de streaming quand je travaille. Désormais, je redécouvre la musique en local et j’ai commencé à utiliser Lollypop depuis peu¹. Heureusement, ma musicothèque est relativement fournie. Lollypop, via sa fonction de suggestions, me permet de redécouvrir des titres que je n’ai pas écoutés depuis longtemps ; c’est plutôt chouette.

Côté pro, c’est un peu plus embêtant, mais on s’en sort. J’utilise DevDocs pour avoir de la documentation technique hors-ligne. Ça ne permet pas de répondre à tout, mais c’est souvent suffisant. Je me dis parfois qu’il manque l’équivalent pour StackOverflow, mais ça me paraît plus compliqué à mettre en place. D’un côté, ça permet de passer plus de temps à se creuser les méninges et c’est peut-être pas plus mal.

D’autre part, comme Flus est avant tout un outil qui se connecte à d’autres sites, il a fallu ruser. J’ai créé un petit serveur de « mock » auquel je peux indiquer « pour telle requête HTTP, renvoie telle réponse ». Je l’utilise avant tout pour les tests — qui passent désormais (quasiment) tous en hors-ligne —, mais il peut aussi fonctionner en phase de développement lorsque j’en ai besoin. C’était moins compliqué à faire que ce que je pensais.

Ça ne fait qu’un mois que j’ai commencé à travailler ainsi. Je ne prétends pas que c’est la panacée ; c’est une manière de faire évidemment très limitée. En revanche, l’effet est globalement positif sur ma capacité de concentration et sur ce que je suis en mesure de produire. Expérience en cours donc.

Après de longues années de bons et loyaux services de la part de Rhythmbox, beaucoup trop bugué ces derniers temps. Je ne regrette pas à vrai dire : je trouve Lollypop bien plus agréable à utiliser au quotidien. ↩

Pour bâtir un morceau de Web

2022-02-07T21:40:00+01:00

Je me souviens très bien de la toute première page Web que j’ai écrite¹. Elle ressemblait à ça :

C’était incroyable : il m’avait suffi d’écrire une et une seule ligne de texte dans un fichier texte pour qu’elle puisse s’afficher dans mon navigateur². Je venais d’apprendre la leçon la plus importante de ma carrière : le Web, ce n’est jamais que de bêtes fichiers textes.

J’aimerais faire passer ce message aux personnes qui voudraient apprendre à faire du Web — et même aux plus expérimentées — : ce n’est pas plus compliqué que ça. Vous vous sentez peut-être intimidé‧e par la complexité des outils qui permettent de faire du Web « moderne³ » ; la vérité, c’est que vous avez seulement besoin d’un éditeur de texte et d’un navigateur Web.

Pour débuter, vous n’avez pas besoin de Webpack ou autre outil de build. Vous n’avez pas besoin non plus de framework React/Angular/Vue (surtout pas !) En fait, vous n’avez même pas besoin de JavaScript.

Pour bâtir un morceau de Web à vous, vous avez seulement besoin d’apprendre à écrire du HTML et — un tout petit peu — de CSS.

Ouvrez un éditeur de texte (Notepad sur Windows, ou gedit⁴ sur Linux par exemple), collez-y le code suivant :

<!DOCTYPE html>
<html lang="fr">
    <head>
        <title>Mon site Web</title>
    </head>

    <body>
        <p>Vous pouvez modifier le fichier pour commencer à apprendre <abbr>HTML</abbr></p>
    </body>
</html>

Enregistrez ça dans un fichier nommé test.html, n’importe où sur votre PC, puis cliquez dessus pour l’ouvrir dans votre navigateur. Voilà, vous avez devant vous votre première page Web⁵ !

Pour la suite, il existe des cours en ligne. La référence semble toujours⁶ être le cours « Apprenez à créer votre site web avec HTML5 et CSS3 » de Mathieu Nebra sur OpenClassrooms (ex Site du Zéro pour les nostalgiques).

Un conseil avant tout : créez-vous un site personnel pour expérimenter des choses par vous-même. C’est pas grave s’il ne marche qu’à moitié, c’est pas grave s’il est moche. Ne vous souciez pas trop non plus — pour le moment — d’éventuelles « bonnes pratiques ». Allez-y tranquillement.

Si vous êtes plus expérimenté‧es, je vous invite à considérer un outillage minimaliste lorsque vous débuterez votre prochain projet. Réfléchissez à comment vous pourriez limiter votre dépendance à des outils externes. Le gain offert par ces outils ne vaut pas toujours le temps passé à les configurer et tenir à jour. Limiter les dépendances, c’est aussi faciliter l’accès à votre projet à d’autres personnes. Est-ce que vous avez vraiment besoin de ce framework frontend ? Et rappelez-vous que, le Web, c’est du HTML avant d’être du JavaScript.

Je m’en souviens tellement bien que je serais prêt à parier que mon voisin de bureau était en train de jouer à Dofus à ma droite tandis que je découvrais le Site du Zéro. Ça n’a pas beaucoup d’intérêt de se souvenir de ça, mais ça reste un jour important pour moi :) ↩
Probablement Firefox 3.0 à l’époque, ça devait être en 2008 ou 2009. ↩
Oubliez ce terme, il est généralement utilisé par des personnes qui aiment se compliquer la vie avec beaucoup trop d’outils. Il n’y a pas plus moderne qu’un site qui fonctionne. ↩
On en dira ce qu’on veut, mais j’ai codé avec gedit pendant plusieurs années et il me convenait très bien. Une autre leçon tiens : ne vous souciez pas trop de ce que les autres pensent de vos outils. Les guerres de chapelles, c’est fatigant. ↩
Bonus : elle est valide HTML5, accessible, extrêmement rapide à charger et s’affiche correctement sur mobile ! On fera difficilement plus moderne. ↩
En recherchant un peu, j’ai été surpris qu’il n’existe pas tant de ressources supplémentaires. Les quelques cours que j’ai trouvés me semblent moins bons que celui d’OpenClassrooms. C’est un peu dommage si vous voulez mon avis. ↩

Turbolinks

2022-02-06T21:25:00+01:00

Je continue de faire des améliorations sur le site et je viens d’y ajouter Turbolinks. Le but est d’accélérer le chargement des pages et d’éviter les petits glitchs visuels en les chargeant intelligemment en JavaScript. La navigation était devenue gênante dans certaines situations¹ avec le thème sombre.

Turbolinks n’est plus maintenu, remplacé par Turbo depuis 2021. Je n’avais toutefois besoin que de la partie « Drive » qui correspond plus ou moins à Turbolinks. J’économise ainsi quelques kilo-octets.

J’en ai également profité pour activer la compression de certains fichiers côté serveur, histoire d’accélérer un peu plus le chargement des pages. Ça devrait être suffisamment rapide pour avoir la sensation de naviguer en local :)

Lorsque vous naviguiez sur une nouvelle page, si votre navigateur déclarait préférer le thème clair mais que vous forciez le thème sombre, la page « clignotait » rapidement. ↩

Thème sombre

2022-02-05T22:36:00+01:00

Je viens d’ajouter un thème sombre à ce site. Par défaut, il s’affichera en suivant les préférences de votre système, mais vous pouvez forcer le thème à partir du sélecteur qui se trouve dans le pied de page du site.

La peinture est fraîche, il est possible que des soucis d’affichage subsistent. N’hésitez pas à me faire signe si vous vous en apercevez !

C’était l’occasion pour moi de découvrir comment m’y prendre. Je ne suis pas encore satisfait de ma technique, donc j’aurai l’occasion de creuser encore.

YOGA Image Optimizer

2022-02-02T10:00:00+01:00

J’ai découvert il y a quelque temps un utilitaire pour optimiser ses images en local : YOGA Image Optimizer (via LinuxFr).

Je sais qu’il existe des tas d’applis qui font ça en ligne et d’autres qui le font en ligne de commande ; je suis juste content d’avoir une interface simple pour le faire en quelques clics sur mon ordi. J’en ai profité pour filer 5 balles au développeur pour le remercier de son travail (à noter que le développement semble actuellement être en pause).

J’ai passé les quelques images du site à la moulinette, ainsi que celles du carnet de Flus. J’estime avoir réduit en moyenne de 25 % le poids des images.

Template de pull requests

2022-02-01T22:56:00+01:00

Je partage ici le template de pull requests (PR) que j’utilise pour flusio, légèrement adapté et traduit. Son but est de me faire vérifier plusieurs points critiques avant de fusionner mon code dans la branche principale. Son contenu est rempli automatiquement lorsque j’ouvre une PR et je m’interdis de l’intégrer tant que chacun des points n’a pas été validé. Elle m’est d’autant plus importante que je travaille seul : je n’ai personne pour vérifier derrière moi que je n’oublie rien. J’imagine qu’elle pourrait être utile à d’autres.

Liste de vérifications :

[ ] le code a été testé manuellement
[ ] l’interface fonctionne sur mobile et grands écrans
[ ] l’accessibilité a été testée
[ ] les tests ont été mis à jour
[ ] la traduction française a été synchronisée
[ ] la documentation a été mise à jour (incluant les commentaires, messages de commit, notes de migrations…)

Si l’un de ces points n’est pas applicable à la PR, merci de quand même cocher la case et d’ajouter (N/A) à la fin de la ligne.

Pour ajouter un template de PR à votre dépôt de code, vous pouvez suivre les instructions officielles pour GitHub ou pour GitLab.

Redirections

2022-01-31T17:40:00+01:00

J’ai migré en 2016 mon blog de PluXml vers Pelican (avant une nouvelle migration vers Boop! en 2019). Si j’avais bien pensé à rediriger les adresses des flux RSS à l’origine (ex. /feed ou /feed.php), les redirections ont fini par se perdre au gré des mises à jour. Je viens de les remettre en place. Re-bienvenue aux personnes qui découvriront une ribambelle de nouveaux articles 👋

En plus des flux RSS, j’ai eu un Shaarli pendant un certain temps. Celui-ci a fini par disparaître, mais je continuais à recevoir quelques visites à son ancienne adresse (en erreur 404 depuis longtemps). Désormais, cette adresse sera redirigée vers mon profil Flus.

Enfin, j’ai pris le temps de rediriger les sous-domaines www. et next. (utilisé durant la conception de cette version du site) vers le nom de domaine de base.

Vu, lu, joué (janvier 2022)

2022-01-30T19:25:00+01:00

Vu Belle de Mamoru Hosoda, réinterprétation de La Belle et la Bête au sein d’un monde « virtuel ». Magnifique pour les yeux et les oreilles, la fin m’a scotché malgré quelques grosses ficelles scénaristiques.

Lu Bolchoi Arena — tome 3 — Révolutions qui explore, ici aussi, un monde « virtuel ». Peut-être 2 – 3 moments où j’ai eu du mal à suivre l’intrigue, mais on retombe sur nos pattes. J’aime tellement le style du dessin ♥️

Joué à Animal Crossing: New Horizons sur Switch une bonne partie du mois. C’était ce dont j’avais besoin en ce début d’année. J’ai découvert au passage le terme de « wholesome » pour décrire ce type de jeux.

Exploration SQL

2022-01-29T12:00:00+01:00

Article technique aujourd’hui. Lorsque j’ai développé la page des profils de Flus, j’ai fait face à un bug qui m’a bien occupé. Pas le genre de bug très grave, mais suffisamment pénible pour que je veuille le corriger.

Contexte : un profil liste les six liens publiés le plus récemment par une personne. Pour qu’un lien soit publié, il doit faire partie d’une collection publique et ne pas être masqué. Un lien peut faire partie de plusieurs collections et une collection peut contenir plusieurs liens ; on a donc une relation « many-to-many ». La date de publication est associée à une collection ; il peut donc y avoir plusieurs dates de publication pour un même lien. Mon problème : les liens publiés dans plusieurs collections pouvaient apparaître plusieurs fois.

Je vais vous illustrer tout ça par des requêtes SQL. Pour simplifier le problème, on va considérer que toutes les collections sont publiques et les liens tous visibles.

CREATE TABLE links (
    id SERIAL PRIMARY KEY,
    url TEXT NOT NULL
);

CREATE TABLE collections (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL
);

CREATE TABLE links_to_collections (
    link_id INTEGER NOT NULL REFERENCES links,
    collection_id INTEGER NOT NULL REFERENCES collections,
    published_at TIMESTAMP NOT NULL
);

INSERT INTO links (url)
VALUES ('flus.fr'),
       ('marienfressinaud.fr'),
       ('framasoft.org');

INSERT INTO collections (name)
VALUES ('Mes favoris'),
       ('Mes partages');

INSERT INTO links_to_collections (link_id, collection_id, published_at)
VALUES (1, 1, '2022-01-17'),
       (2, 2, '2022-01-18'),
       (3, 2, '2022-01-19'),
       (1, 2, '2022-01-20');

Que fait-on dans ces quelques lignes de SQL ? On commence par créer les trois tables qui vont contenir les données (links, collections et la table faisant la jonction links_to_collections). On insère ensuite trois liens et deux collections. Enfin, on fait le lien entre les liens et les collections :

flus.fr dans « Mes favoris » le 17 janvier ;
marienfressinaud.fr dans « Mes partages » le 18 janvier ;
framasoft.org dans « Mes partages » le 19 janvier ;
enfin, à nouveau flus.fr dans « Mes partages » le 20 janvier.

Commençons par récupérer les trois liens les plus récents avec leur date de publication :

SELECT l.id, l.url, lc.published_at
FROM links l

INNER JOIN links_to_collections lc
ON lc.link_id = l.id

ORDER BY lc.published_at DESC, l.id
LIMIT 3;

Cette requête nous retourne le résultat suivant :

id	url	published_at
1	flus.fr	2022-01-20
3	framasoft.org	2022-01-19
2	marienfressinaud.fr	2022-01-18

On a donc les lignes que l’on souhaite. Seulement, qu’arrive-t-il si on change la limite de trois à six ?

id	url	published_at
1	flus.fr	2022-01-20
3	framasoft.org	2022-01-19
2	marienfressinaud.fr	2022-01-18
1	flus.fr	2022-01-17

Mince, flus.fr apparaît désormais deux fois car il se trouve dans deux collections, avec deux dates de publication différentes. On ne le veut qu’une seule fois à sa date la plus récente ! Essayons d’ajouter une clause DISTINCT :

SELECT DISTINCT l.id, l.url, lc.published_at
FROM links l

INNER JOIN links_to_collections lc
ON lc.link_id = l.id

ORDER BY lc.published_at DESC, l.id
LIMIT 6;

id	url	published_at
1	flus.fr	2022-01-20
3	framasoft.org	2022-01-19
2	marienfressinaud.fr	2022-01-18
1	flus.fr	2022-01-17

Même résultat : normal, DISTINCT s’applique à toutes les colonnes de la sélection, published_at inclus. Heureusement, PostgreSQL propose une autre syntaxe :

SELECT DISTINCT ON (l.id) l.id, l.url, lc.published_at
FROM links l

INNER JOIN links_to_collections lc
ON lc.link_id = l.id

ORDER BY lc.published_at DESC, l.id
LIMIT 6;

Aïe, cette fois on obtient une erreur : « ERROR: SELECT DISTINCT ON expressions must match initial ORDER BY expressions ». Elle indique que la colonne du DISTINCT ON (l.id) doit se trouver à gauche dans la liste de l’ORDER BY. Mais si l’id se trouve à gauche, nos liens ne seront plus triés dans le bon ordre !

À ce niveau-là, j’arrive au bout de ma créativité en termes de SQL et il me faut faire appel à StackOverflow. Heureusement, je ne suis pas le premier à m’être posé la question. La piste était bonne¹, mais il nous faut maintenant déplacer tout ça dans une sous-requête qui sera triée à nouveau :

SELECT l2.* FROM (
    SELECT DISTINCT ON (l.id) l.id, l.url, lc.published_at
    FROM links l

    INNER JOIN links_to_collections lc
    ON lc.link_id = l.id

    ORDER BY l.id, lc.published_at DESC
) l2

ORDER BY l2.published_at DESC, l2.id
LIMIT 6;

Et…

id	url	published_at
1	flus.fr	2022-01-20
3	framasoft.org	2022-01-19
2	marienfressinaud.fr	2022-01-18

Tadam ! C’est ce qu’il nous fallait !

Maintenant ajoutez à ça toute la complexité d’un vrai système, avec le calcul du nombre de commentaires par lien, l’état de lecture pour l’utilisateur courant, d’autres trucs à calculer dynamiquement, etc. et vous obtenez une requête des plus agréables (non). N’hésitez pas à me faire savoir si vous avez une solution plus élégante ! 😄

Mise à jour du 12 février.

Heureusement, j’ai des copains plus malins que moi et qui apprécient particulièrement le SQL. Merci à François pour cette solution bien meilleure à base de MAX — pour récupérer le published_at le plus récent — et de GROUP BY, tout simplement.

SELECT l.id, l.url, MAX(lc.published_at) AS published_at
FROM links l

INNER JOIN links_to_collections lc
ON lc.link_id = l.id

GROUP BY l.id
ORDER BY published_at DESC, l.id
LIMIT 6;

Notez que la réponse StackOverflow propose une seconde approche qui n’est pas propre à PostgreSQL. Je la trouve personnellement un poil moins facile à relire, donc je suis resté avec la solution présentée dans cet article. Ce ne sera pas forcément votre cas ! ↩

Terminer ses projets

2022-01-28T10:22:00+01:00

L’année dernière, j’ai commencé à clore un certain nombre de logiciels que j’ai écrit dans le passé. C’est le cas de Boop!, mon générateur de sites statiques, ou encore mon sélecteur de couleurs Sweet Colors.

Pour l’instant, j’ai adopté deux stratégies pour les clore. La première consiste à simplement prévenir que le logiciel n’est plus du tout maintenu ; c’est simple et explicite. La seconde stratégie consiste à annoncer qu’aucune nouvelle fonctionnalité ne sera ajoutée au logiciel, mais que je continuerai de le maintenir en cas de faille de sécurité ou de bug. Je pourrais également être amené à mettre la documentation à jour si je la trouve incomplète.

J’aimerais diffuser l’idée que terminer un logiciel peut être un signe de maturité du projet. Dans le cas de Boop!, par exemple, je considère que le projet a atteint le niveau fonctionnel que je lui souhaitais en le démarrant. Ça ne signifie pas qu’il répond à tous les besoins, seulement qu’il est tel que je veux qu’il soit. Il n’a pas besoin d’être amélioré parce qu’il répond aux besoins auxquels il était censé répondre. C’est un logiciel fonctionnellement stable.

Terminer un projet est un acte positif.

Veille

2022-01-27T20:49:00+01:00

Les pages de profil commencent à arriver dans Flus. C’était ce qu’il me manquait pour me mettre à partager ma veille.

Ma page de profil : app.flus.fr/p/1670839367044869607. Vous y trouverez la liste de mes derniers liens partagés, ainsi que les collections dans lesquelles je les place. En ce moment, je range mes liens majoritairement dans la collection « 📣 Partages en vrac », qui n’a donc pas de thème particulier.

Les pages de profil disposent également d’un flux : app.flus.fr/p/1670839367044869607/feed (à ajouter dans votre agrégateur de flux RSS).

Apostrophe, éditeur Markdown

2022-01-26T20:10:00+01:00

Depuis quelques mois, j’utilise un éditeur Markdown pour rédiger mes articles et autres notes : Apostrophe.

Pour éditer du texte, j’utilise (Neo)Vim depuis des années, mais je ne l’ai jamais trouvé agréable pour rédiger des articles. C’est un feeling global que je n’arrive pas entièrement à expliquer.

Apostrophe me fournit une interface épurée. Le peu de menu se masque dès lors que je commence à taper du texte. De plus, les quelques options de configuration sont très peu nombreuses, ce qui est parfait pour mon usage. Enfin, j’apprécie fortement le mode focus qui permet de se concentrer sur la phrase que l’on écrit. Son plus gros défaut est peut-être qu’il ne permet d’ouvrir qu’un seul document à la fois… mais, à l’usage, ça en fait une fonctionnalité plutôt intéressante.

C’est en tout cas un éditeur de texte au parti pris très assumé, il ne conviendra certainement pas à tout le monde. Moi, je l’aime bien :)

Technique de décrochage : le fichier hosts

2022-01-25T09:00:00+01:00

Certains sites mal conçus ont tendance à trop facilement voler mon attention à l’instar de Twitter et Twitch. Comme je suis très sensible à ce type de mauvais design, j’ai tenté plusieurs approches pour décrocher de ces sites. Le plus efficace à ce jour repose sur un détournement du fichier /etc/hosts.

Pour faire court, il s’agit d’un fichier Linux permettant de faire correspondre des noms de domaine avec des adresses IP sans passer par un serveur DNS. Pour ma part, je fais pointer les noms de domaine des sites que je veux bloquer vers mon adresse IP locale (127.0.0.1). Ainsi, lorsque j’ouvre Twitch par exemple, je me retrouve avec une belle page d’erreur, me rappelant que j’avais pris la décision de ne plus y mettre les pieds.

La technique fonctionne bien car elle génère une friction importante pour la contourner, c’est-à-dire : ouvrir un terminal, taper la commande pour éditer le fichier et rentrer mon mot de passe. Par contre, elle ne fonctionne pas bien pour Twitter dans mon cas : j’ai besoin d’y accéder régulièrement pour Flus. Ça fait partie des raisons qui m’ont poussé à y fermer mon compte personnel.

Billets courts

2022-01-24T12:05:00+01:00

J’ai pris la bonne résolution d’écrire plus souvent sur ce blog. Comme je suis plutôt mal parti en ce début d’année, j’ai pris la seconde bonne résolution de publier un billet — court — par jour¹, histoire de ne pas faire dans la demie-mesure. Pour me faciliter la tâche, j’en ai préparé quelques-uns à l’avance. J’emprunte le terme de « billet » à Nicolas ; j’aime bien le terme.

Comme je risque de parler de Flus, il y a des chances que certains billets soient publiés dans son carnet plutôt qu’ici.

Je vois de plus en plus de blogs personnels apparaître dans mes lectures. Ça me fait plaisir de voir les usages revenir doucement vers ce format, alors autant y participer !

Remarquez que je ne parle pas de durée :) ↩

Quitter Twitter

2022-01-06T18:16:00+01:00

En ce début d’année 2022, j’ai décidé de fermer mon compte Twitter. J’avais beaucoup de bonnes raisons de le garder, mais j’en avais également pour le fermer.

Mon usage de Twitter consistait essentiellement à retweeter des choses, sans apporter de contenu supplémentaire ; parfois à « aimer » un contenu ; très rarement à balancer un commentaire rapide. Deux choses me gênaient là-dedans : la manière superficielle d’aborder le contenu, et le fait que mes partages ne bénéficient qu’aux personnes inscrites sur la plateforme. En 2022, j’ai envie de prendre plus de temps pour digérer ce que je lis, écoute ou regarde. J’ai également envie de m’assurer que ce que je partage est accessible à toutes et tous : via le blog, Flus, ou leurs flux RSS respectifs. Pour suivre ce blog, vous pouvez d’ailleurs vous abonner à son flux.

À cela s’ajoute que le contenu que je lisais sur Twitter était souvent négatif, voire énervé. Mon mental, déjà ébranlé par la période pandémique qui traîne en longueur, n’arrive plus à suivre. Je préfère prendre soin de moi en coupant ce moteur à énergie négative.

Mais ce qui aura eu raison de mon compte Twitter, c’est une fatigue accrue en fin d’année 2021 face à mon usage du numérique (j’en parle dans mon article précédent). J’ai réalisé à contre-temps que je croulais sous les articles de presse — souvent déprimants — et j’ai fini par me désabonner de quelques sites d’actualités que je suivais, bien que j’en apprécie le contenu. Le problème était similaire sur Twitter, mais je pensais réussir à m’en prémunir en limitant le nombre de comptes auxquels j’étais abonné. Mais le réseau social est fourbe et incite constamment à suivre plus de monde : lutter contre l’outil pour garder un fil d’actualité léger ne me convient plus.

Certaines de mes critiques peuvent par ailleurs s’appliquer de manière similaire à Mastodon. J’ai songé y supprimer mon compte également, mais je me laisse encore quelque temps pour me décider. Il est plus probable que je passe d’abord le compte en privé afin d’expérimenter une autre forme d’échanges.

À côté de ça, je vais tout de même conserver les comptes Twitter de Flus et FreshRSS, car ils servent à faire connaître les projets. Je n’y consomme de toute façon que très peu de contenu, et me contenterai à l’avenir de relayer les informations accessibles ailleurs.

Enfin, j’aime l’idée que quitter Twitter me redonne l’envie d’écrire sur ce blog, espace qui me correspond mieux en terme rédactionnel — je n’y ai aucune limite de taille, waouh ! — et de design — du fait-maison de A à Z ❤️

2022

2022-01-04T19:30:00+01:00

Les deux dernières années, j’ai trouvé plaisir à partager les grandes lignes que j’entrevoyais pour mes mois à venir (cf. 2020 et 2021). Qui dit nouvelle année, dit donc nouvel article.

Pour créer le cadre présenté ici, je me suis basé sur des notes personnelles rédigées tout au long de l’année de façon hebdomadaire. Je les ai relues ces derniers jours pour en tirer une version résumée qui m’a permis de savoir ce qui avait bien fonctionné ou non durant mon année. C’est enfin sur la base de ce résumé que j’ai décidé des grands axes que je voulais explorer cette année. Ici je ne vous en dévoile qu’une partie, le reste étant d’ordre plus personnel.

Changer de cadre

Depuis 2019, je rythmais ma façon de travailler au sein de cycles — six semaines initialement, puis un mois depuis l’an dernier — se concluant par des rétrospectives. Cela me permettait de garder un rythme de travail efficace, ce qui m’était important puisque je travaille seul chez moi. Les rétrospectives étaient des occasions de mettre en place des actions puissantes pour changer mon quotidien.

Après trois ans à travailler ainsi, je ressens le besoin de fonctionner autrement. Le cadre me paraît désormais peu efficace et me fatigue. De plus, en relisant les notes des différentes rétrospectives, j’ai réalisé qu’elles tournaient toujours autour des mêmes problèmes, sans les résoudre. Leur résultat est donc mitigé.

En 2021, j’ai commencé à fonctionner sur la base de « routines » hebdomadaires ou mensuelles. Une routine consiste en une liste de tâches à faire. Les tâches sont simples et répétitives, ce qui me permet de mettre en place des automatismes. Il s’agit de moments qui me demandent peu de réflexion et sont positifs pour mon moral.

En 2022, je ne vais donc garder que ce système de routines. Je conserverai également une rétrospective en fin d’année et, éventuellement, quelques-unes au fil de l’eau si j’en ressens le besoin ; elles ne seront en tout cas plus faites automatiquement.

Évoluer professionnellement

Depuis fin 2019, je travaille sur Flus à plein temps. Je pouvais me le permettre grâce à mes économies et aux allocations que je percevais.

Sans trop rentrer dans les détails — j’aurai l’occasion d’y revenir ici et dans le carnet de Flus —, j’ai fait le choix en 2022 de trouver un job complémentaire. Mes allocations ont effectivement touché à leur fin et, même si mes économies me permettraient de tenir un an de plus, je ne pense pas que je serai en mesure de vivre de mon activité d’ici là. Enfin, je ressens de plus en plus l’envie de travailler avec d’autres personnes.

Si je fais ce choix, c’est aussi parce que j’ai identifié que la seule manière pour moi d’être rapidement rentable serait de viser des entreprises. Or, ce n’est ni l’ambition ni la vision que je porte pour Flus, qui restera donc un outil à destination de particuliers. Je m’offre ainsi plus de liberté dans les choix fonctionnels puisque le critère de rentabilité ne sera pas / plus prépondérant.

Idéalement, j’aimerais pouvoir continuer à dédier au moins 3 jours de travail par semaine à Flus.

Écrire ici et ailleurs

En 2020, j’avais annoncé mon envie d’écrire beaucoup plus sur ce blog ; cela s’était soldé par deux petits articles. En 2021, je ne me suis risqué à aucune prédiction pour un total de huit articles. J’ai espoir d’être plus prolifique cette année : ça me manque et l’évolution de mes pratiques numériques devrait me le permettre (j’y reviens en fin d’article).

Si l’activité n’a pas été énorme sur ce blog en 2021, j’ai beaucoup plus écrit sur le carnet de Flus. J’espère continuer cette année.

Finalement, le gros changement par rapport aux années précédentes, c’est que j’ai écrit quasiment toutes les semaines en 2021. Mes notes hebdomadaires dont j’ai parlé plus haut ne se sont arrêtées que le temps de 4 semaines de vacances. Je suis le premier surpris d’avoir tenu sur la durée, mais mon système de routines n’y est pas étranger. Je compte bien continuer sur cette lancée en 2022.

Terminer des projets

En 2021, j’ai commencé à clore certains projets que j’avais développés au fil des années. Les clore a essentiellement consisté à terminer leur documentation et indiquer dans le fichier README que le projet ne bénéficierait plus d’ajout de fonctionnalités. C’est notamment le cas de mon générateur de sites statiques, Boop! Terminer un projet ne consiste pas à dire qu’il est mort ; je les mettrai d’ailleurs à jour en cas de faille de sécurité ou de bug vraiment gênant par exemple. Par « terminer », je signifie simplement qu’ils sont dans un état que je considère comme complet. J’aurai — j’espère — l’occasion d’en reparler ici.

En tout cas, j’aimerais continuer à clore certains projets en 2022, comme Lessy, ce qui représente toutefois une quantité de travail non négligeable compte-tenu du nombre de dépendances… Je devrai peut-être trouver une approche différente pour ce projet en particulier.

Améliorer mon assiduité

En 2021, j’ai commencé à apprendre à jouer du ukulélé. Je n’ai pas été très assidu et mon niveau n’a pas beaucoup décollé, mais j’y ai tout du moins pris du plaisir. Dans le même genre, je n’ai jamais réussi à faire des exercices physiques quotidiennement, alors que mon dos me le réclame. Il y a également cette envie de concevoir un jeu vidéo qui revient de manière cyclique, sans que je n’arrive à aller plus loin qu’un tutoriel.

Bon, vous voyez où je veux en venir ! :)

Pour enfin me mettre à ces activités en 2022, je compte sur un changement important dans mon quotidien : la diminution de mon temps passé sur Internet et à consommer du numérique.

Moins consommer le numérique

Je consomme énormément de numérique et ça me pose de gros soucis. En 2021, j’ai passé un temps incommensurable à regarder des vidéos YouTube, ou des gens jouer sur Twitch. J’ai également passé beaucoup trop de temps à scroller sur Twitter et, dans une moindre mesure, sur Mastodon. J’ai passé un peu moins de temps sur les plateformes de streaming, principalement parce que j’y ai arrêté mes abonnements. Enfin, j’ai lu vraiment beaucoup d’articles de presse sans pour autant être sûr de savoir ce que j’en retenais.

Tout cela s’est fait à la place d’autres activités que j’aurais pu considérer comme plus utiles, des activités créatives notamment. À titre d’illustration, voici une sélection d’extraits de mes notes hebdomadaires sur le sujet.

Le 9 mai :

J’ai passé trop de temps sur Twitch. Ce temps s’est forcément fait au détriment de temps plus « utile ».

Le 31 août :

Les barrières mises en place pour décrocher du PC semblent fonctionner.

Le 12 septembre :

C’était un weekend très inefficace et ça m’agace. Je comprends pas comment réussir à décrocher, mon cerveau trouve toujours autre chose à faire pour glander.

Le 30 décembre :

Je viens de débrancher le câble Ethernet du PC.

Le sujet me suit depuis de nombreuses années. J’ai essayé de le traiter à quasiment chaque rétrospective 2021, avec un succès toujours mitigé. Finalement, la réponse trouvée le 30 décembre, sans être miraculeuse — la Switch trône toujours pas loin —, me permet au moins d’aborder mon PC de manière différente. Débrancher Internet, peut-être est-ce ce que j’ai cherché toute l’année !

Alors en 2022, je compte bien expérimenter cela à fond. Comment s’occuper sans Internet ? Comment travailler ? Les réponses ne sont sans doute pas si compliquées à trouver — d’autres s’en sortent très bien —, mais je manquais sans doute de motivation pour m’y atteler jusque-là. Je crains d’être tellement imprégné d’une culture numérique que la tâche ne soit plus compliquée qu’elle n’en a l’air. Toutefois, si je me base sur mon expérience d’ordiphone déconnecté, cela ne devrait pas non plus être infaisable.

Je suis très enthousiaste à l’idée de découvrir ce qui va émerger de cette expérience. Je compte bien la partager sur ce blog.

Ordiphone

2021-10-04T21:38:00+02:00

Je discutais hier avec un copain de nos usages respectifs de nos téléphones dits intelligents. La discussion m’a permis de mieux mesurer le parcours que j’ai réalisé ces dernières années. De fait, j’ai totalement réussi à redonner à mon téléphone la place qui lui incombe : un simple outil à mon service. Je me disais que c’était l’occasion de partager quelques trucs et astuces que j’ai mises en place.

Désinstaller

La principale action que j’ai réalisée a aussi été la plus compliquée et la plus longue : désinstaller un maximum d’applications. Ce fut compliqué car, pour chaque appli, on mesure facilement ce qu’elle nous apporte ; plus difficilement ce qu’elle nous impose. Surtout, on s’imagine difficilement vivre sans — on avait sûrement une bonne raison de l’installer en premier lieu ! De mémoire, voici les principales applications qui m’ont posé souci :

Twitter — positif : certain d’avoir toujours quelque chose de nouveau à lire ; négatif : chronophage, peut facilement générer des émotions négatives ;
Signal — positif : discussion facilitée avec les proches, on ne rate aucune info ; négatif : beaucoup trop de notifications, l’appli s’impose rapidement comme indispensable ;
Firefox — positif : le Web dans la poche, tout est à notre portée ; négatif : TOUT est à notre portée ;
K9 Mail (courriels) — positif : facilite encore un peu plus nos échanges, permet de transférer facilement des infos sur son téléphone via un simple courriel ; négatif : tendance à vérifier ses courriels dès qu’on a 2 minutes de libre ;
Google Maps — positif : jamais perdu ; négatif : jamais perdu.

Plutôt que de peser de manière rationnelle le pour et le contre de garder ou non chaque application, je crois les avoir toutes désinstallées sur un coup de tête (« je teste quelques jours, je vois ce qu’il se passe »). Le plus compliqué a été de se convaincre que je n’avais pas besoin de mes courriels sur le téléphone. Je pense que ça fait au moins 2 ans que j’ai désinstallé K9 Mail et je ne regrette absolument pas 🙂. Pour passer à l’action, je me suis imposé quelques contraintes.

Se contraindre

La première contrainte que je me suis imposée a été de limiter à deux les bureaux virtuels de l’écran d’accueil : un pour les applis, un autre pour mon agenda. J’ai fini par rendre cette contrainte encore plus stricte : un seul écran afin d’afficher mon agenda. Les applications visibles sont dans le deck permanent et sont limitées à 4 en plus de l’icône pour ouvrir la liste des applications. Mes applications visibles sont les suivantes :

l’appareil photo ;
une application de prise de notes ;
l’horloge pour les alarmes ;
l’appli de SMS.

La seconde contrainte est très similaire : un seul écran pour lister mes applications. Aujourd’hui, cet écran contient 24 applications. Je ne vous les liste pas toutes mais, pour les plus utiles, on retrouve les applications listées précédemment ainsi qu’un explorateur de fichiers, la galerie photo, un lecteur de musiques, l’appli de contacts, etc.

Ma dernière contrainte forte a été de limiter au maximum les applications autorisées à générer des notifications. Cette contrainte est très facile à s’imposer une fois qu’on a réduit la liste des applications, mais reste à mon avis importante à garder en tête. En l’occurrence, les seules applications qui me notifient sont les SMS, le téléphone et l’agenda.

Accepter l’inconfort

À cette étape, vous vous dites que c’est n’importe quoi, que je dois aimer me faire mal — et alors ? —, que vous vous seriez incapable de limiter autant vos usages. Mais attendez, j’en rajoute :

mon téléphone est un modèle de 2013, acheté en 2015 (fun fact: feu mon Firefox OS venait de griller sur une prise en Bulgarie, je cherchais le modèle moins cher possible du magasin pensant que j’en rachèterais un en rentrant en France… 6 ans plus tard, il est toujours vivant !) ;
il tourne sous LineageOS 11 (Android 4.4, soit une version datant de 2014) ;
lié à ça, rien n’est vraiment à jour, il est donc bourré de failles et c’est sans doute ce qui m’enquiquine le plus ;
le navigateur de base — que j’ai conservé — est extrêmement lent et pas du tout à jour… je n’ai donc pas besoin de me forcer pour ne pas l’utiliser ! Il est juste suffisant pour me dépanner de temps à autre, mais je pense que je pourrais tout à fait m’en passer ;
l’appareil photo est nul nul nul, je suis incapable de faire des photos pas floue, mais c’est artistique.

Je ne vais pas non plus affirmer que tout est parfait : oui je rate parfois des infos qui passent par Signal, oui Google Maps aurait pu me dépanner plus d’une fois, oui ça va sans doute devenir de plus en plus pénible au fur et à mesure qu’on nous impose l’usage des smartphones (coucou les banques 👋). Mais, honnêtement ? je suis tellement plus serein vis-à-vis de mon téléphone depuis ces dernières années que je n’ai absolument aucune envie de revenir sur mes choix.

Un ordiphone ?

Finalement, la question qui reste en suspens est celle de savoir si j’ai toujours besoin d’un téléphone intelligent dans la poche ? Je pense que je pourrais effectivement m’en passer. Les seules choses dont j’ai l’impression d’avoir vraiment besoin sont le téléphone et les SMS. J’aurais du mal à me passer du réveil, de l’agenda, voire du lecteur de musiques, mais je suis sûr de trouver des moyens de contourner si cela venait à m’être imposé.

Plusieurs points positifs à tout ça :

je n’ai plus l’impression de faire d’efforts au quotidien pour me détacher du téléphone, mes habitudes ont totalement changé. Vous imaginez pas le bien fou que ça fait :) ce n’est plus qu’un bout de plastique qui traîne dans un coin de mon appartement et qui fait du bruit occasionnellement ;
le jour où j’aurais besoin de changer de téléphone, j’aurais l’embarras du choix tout en pouvant privilégier des critères de durabilité (l’actuel s’en sort bien vu le nombre de fois où il est tombé) ;
ça me réaligne un peu avec mon idéal écolo. Je ne sauverai pas la planète avec cette démarche, mais le jour où le monde fera face à une pénurie d’électricité, le manque de téléphone ne sera au moins pas un problème pour moi 😜.

Mon prochain objectif : avoir une démarche similaire avec le PC qui me pose d’énormes problèmes de distractions. J’ai bien peur que ce soit plus compliqué !

Mes points médians sont-ils militants ?

2021-04-28T09:10:00+02:00

Il y a quelques mois, le journal Marianne a publié une tribune de 32 linguistes critiquant l’écriture inclusive. Cette tribune s’ouvre ainsi (la mise en gras est de moi) :

Présentée par ses promoteurs comme un progrès social, l’écriture inclusive n’a paradoxalement guère été abordée sur le plan scientifique, la linguistique se tenant en retrait des débats médiatiques. Derrière le souci d’une représentation équitable des femmes et des hommes dans le discours, l’inclusivisme désire cependant imposer des pratiques relevant d’un militantisme ostentatoire sans autre effet social que de produire des clivages inédits. Rappelons une évidence : la langue est à tout le monde.

La critique du militantisme est fréquente pour les « anti-inclusifs ». Elle m’a questionné sur mon propre usage du point médian, la forme d’écriture inclusive la plus critiquée.

J’ai discrètement utilisé ce point pour la première fois en 2017, sur ce blog. J’ai ensuite étendu cet usage à d’autres formes écrites (courriels, réseaux sociaux, etc.) sans en parler, et sans qu’on m’en parle. Au final, c’est à travers les critiques portées en direction de Framasoft que j’ai pris conscience de la sensibilité du sujet (lire le texte en réponse à ces critiques).

Soyons clairs : le fait d’utiliser le point médian n’a jamais constitué une volonté de ma part de l’« imposer » au reste de la société. Qui fait donc cela ? C’est un faux débat. Pour autant, inutile de le nier, il est effectivement le marqueur d’un certain militantisme : celui qui revendique plus d’égalité ainsi que la reconnaissance et la visibilité de toutes et tous au sein de la société. Militantisme ostentatoire ? Vous jugerez.

J’ai toujours considéré le point médian comme un outil à ma disposition. Je ne me souviens pas des raisons exactes qui m’ont poussé à l’utiliser la première fois, mais aujourd’hui il me sert à m’adresser à un certain public. Il me sert à dire que je suis sensible à la représentation des personnes, peu importe le genre auquel elles s’identifient (ou non). Il me sert à m’exprimer avec plus de précision. Il me sert à faire preuve d’empathie.

Comme tout outil, il est également imparfait et pose certainement des problèmes d’accessibilité. Je suis sensible à cet argument et c’est pour cela que j’en fais un usage raisonné :

je privilégie d’autres formes autant que possible : formes épicènes, accord de proximité, jusqu’à expérimenter quelques néologismes comme « utilisateurice » ;
je ne l’utilise pas systématiquement : par exemple, plus haut, lorsque j’ai écrit « anti-inclusifs » par respect du choix des personnes visées à privilégier le masculin générique ;
je privilégie une forme légère : « utilisateur‧ices » au lieu de « utilisateur‧ice‧s » ;
et qui facilite la prononciation : « inclusi‧ve » au lieu de « inclusif‧ve » ;
pour les puristes, j’utilise d’ailleurs le point d’hyphénation au lieu du point médian, car il serait ignoré par certaines synthèses vocales.

J’ajoute que la question de l’accessibilité est bien trop sérieuse pour être brandie comme un vulgaire « argument-chiffon ». Cela nécessiterait néanmoins un article à part entière.

Pour en revenir à la question des « militants du point médian », je n’en comprends ni le fondement, ni la pertinence. Je n’ai jamais croisé personne affirmant qu’il fallait que cette forme devienne la norme. Je suis bien sûr biaisé, peut-être avez-vous eu une expérience différente. Celle-ci vous suffit-elle à généraliser ? La tribune aide justement à répondre à cette question : « l’écriture inclusive n’a paradoxalement guère été abordée sur le plan scientifique ». Bon courage pour prouver quoi que ce soit.

Pour ma part, je ne crois ni ne souhaite que le point médian se généralise. Paradoxal ? Je vois en fait le point médian comme un outil transitoire vers quelque chose de plus accessible. Peut-être un marqueur plus lisible ? Peut-être une nouvelle forme neutre distincte du masculin ? Ou peut-être encore la disparition du genre au sein la langue, qui sait ?

Pour conclure cet article, je me contenterai de citer une fois de plus la tribune : « la langue est à tout le monde ».

J’effectue une veille active sur le sujet et partage tout un tas de ressources sur Flus. Si vous ne savez pas par où commencer et que vous souhaitez aborder le sujet sérieusement, je vous conseille l’épisode « Écriture inclusive : pourquoi tant de haine ? » du podcast « Parler comme jamais » (il dure 46 minutes, vous êtes prévenu‧e !)

Célébrer la technique

2021-04-24T21:50:00+02:00

Je parle très peu de technique. Souvent, ce genre de conversations m’ennuient. Mais à force de m’en tenir éloigné, j’ai fini par croire que la technique ne m’intéressait pas tant que ça. J’ai fini par me dire que ce qui comptait uniquement, c’était que le résultat final soit utile et que seule l’approche utilisateur m’intéressait. Mais c’est faux : les deux approches m’intéressent et je crois que je me serais reconverti depuis longtemps sans l’une ou l’autre.

Aujourd’hui je vais donc parler technique en célébrant les choix que j’ai pris depuis un an pour flusio, le logiciel derrière mon service Flus.

Je suis heureux d’avoir fait le choix du PHP. Certains choix de conception sont rageants, mais je suis très à l’aise avec ce langage au quotidien. Il me permet également une certaine créativité que je ne trouve pas avec d’autres langages.

Je suis heureux d’avoir fait le choix de (re)développer mon propre framework, Minz. Il s’adapte à ma manière de penser en fonction des problèmes que je rencontre, pas l’inverse.

Je suis heureux de son système d’abstraction des requêtes utilisateur et des réponses serveur. Cela me permet de tester une large portion du logiciel facilement. Un effet de bord positif a été de me fournir un mécanisme de ligne de commande à peu de frais.

Je suis heureux de ne pas utiliser d’ORM pour l’accès à la base de données. Le SQL m’est souvent facile à lire et je me torture moins l’esprit pour les requêtes compliquées.

Je suis heureux de mon système de migrations qui tient en moins de 300 lignes, commentaires inclus. J’ai appris que ce n’était pas si compliqué que ça à faire.

Je suis heureux du choix d’abstraire la création des dates derrière une classe \Minz\Time. Durant les tests, cela me permet de figer le temps à une date précise et faciliter ainsi le travail sur les dates relatives.

Je suis heureux d’avoir développé un système de jobs asynchrones au sein de flusio plutôt qu’utiliser un logiciel dédié. Ça me fait un logiciel de moins à maîtriser et installer. Le cœur du système tient en quelques lignes.

Je suis heureux de ma mini-bibliothèque SpiderBits pour parser le Web. Elle tient en 1 300 lignes de code relativement simples et permet d’aller du nettoyage d’URL à l’extraction d’informations OpenGraph en passant par l’analyse de flux RSS.

Je suis heureux du nombre de tests écrits. Ça prend du temps à écrire, mais ils m’ont sauvé plus d’une fois. Le résultat, c’est une application stable depuis sa première version.

Je suis heureux du nombre réduit de dépendances à des bibliothèques externes (PHP et JavaScript). Le code externe, c’est du code que je ne maîtrise pas ; j’y fais appel avec parcimonie.

Je suis heureux de prendre mon temps pour abstraire les concepts. Je préfère répéter du code de nombreuses fois tant que je n’ai pas trouvé l’abstraction qui me satisfait, souvent pour mon plus grand bien.

Je suis heureux de traiter la dette technique comme l’évolution naturelle de mon code répondant à de nouveaux problèmes, pas comme de mauvais choix de conception passés.

Tout n’est pas parfait dans flusio, mais je suis heureux de chacun des choix que j’ai pu faire, même ceux sur lesquels je souhaite revenir. Ils ont tous été pris en connaissance de cause, en fonction de ce que j’avais comme information à ma disposition à un instant T. Pour prendre mes décisions, je ne suis pressé ni par une personne externe, ni par le temps. Il en résulte un logiciel maintenable dont j’ai plaisir à parcourir le code. Même seulement au bout d’un an de développement, ce n’est pas souvent le cas.

Je crois que flusio est une bonne vitrine sur tout ce que j’ai appris en 10 ans, c’est un logiciel qui me ressemble.

De l’aléatoire en CSS ?

2021-04-09T17:00:00+02:00

Ces derniers temps, un mini-projet me trottait en tête : un site qui propose des idées de choses rapides à dessiner. La liste serait établie au préalable par moi-même ou par des propositions externes, mais tout serait statique. Le cahier des charges me semblait suffisamment simple pour que je puisse me passer d’un langage dynamique à la fois côté serveur et client (ni PHP, ni JavaScript en somme). C’était sans compter que je voulais que les idées soient suggérées de manière aléatoire.

En y réfléchissant hier soir, je me suis demandé : « et si on pouvait générer de l’aléatoire en CSS ? » La réponse courte est « non », mais il existe également une réponse longue et elle m’a été donnée par le site CSS-Tricks : « Are There Random Numbers in CSS? ».

Attention, n’utilisez pas cette technique en production. Elle n’est ni accessible, ni très maintenable. Il s’agit avant tout de jouer avec CSS. Vous êtes prévenu‧e ! 😄

Le principe est assez simple : il consiste à superposer plusieurs label avec le même texte, les uns au-dessus des autres, puis à modifier leur z-index en boucle à l’infini grâce à une animation. Ainsi, le clic surviendra sur un label que le visiteur ne saura pas prévoir. Les label sont associés à des champs radio : il suffit alors d’adapter l’affichage en fonction du sélecteur input:checked.

Ce qui est marrant avec cette méthode, c’est que la génération d’aléatoire est déplacée de l’ordinateur au visiteur.

Pour ma part, j’ai adapté la solution parce qu’elle ne me convenait pas tout à fait : j’ai préféré me baser sur des liens avec ancre et le sélecteur associé, :target. En effet, en cliquant sur un lien avec l’attribut href="#1" par exemple, le sélecteur CSS #1:target devient actif. Voici une illustration :

<p class="idee-dessin" id="1">Un renard qui fait du surf</p>
<p class="idee-dessin" id="2">Une tomate amoureuse</p>
<p class="idee-dessin" id="3">Une pendule en retard à un rendez-vous</p>

<div class="conteneur-boutons-nouvelle-idee">
    <a class="bouton-nouvelle-idee" href="#1">Nouvelle idée ?</a>
    <a class="bouton-nouvelle-idee" href="#2">Nouvelle idée ?</a>
    <a class="bouton-nouvelle-idee" href="#3">Nouvelle idée ?</a>
</div>

Ainsi, le premier lien « Nouvelle idée ? » active le premier paragraphe, etc. Il suffit alors de cacher en CSS tous les paragraphes, sauf celui visé par le sélecteur :target.

.idee-dessin {
    display: none;
}

.idee-dessin:target {
    display: block;
}

Il ne reste alors plus qu’à superposer les liens et animer leur z-index :

.conteneur-boutons-nouvelle-idee {
    position: relative;
}

@keyframes changeOrdre {
    from { z-index: 3; }
    to { z-index: 1; }
}

.bouton-nouvelle-idee {
    animation: changeOrdre 3s infinite linear;
    position: absolute;
}

.bouton-nouvelle-idee:nth-of-type(1) { animation-delay: -0.0s; }
.bouton-nouvelle-idee:nth-of-type(2) { animation-delay: -0.5s; }
.bouton-nouvelle-idee:nth-of-type(3) { animation-delay: -1.0s; }

.bouton-nouvelle-idee:active {
    z-index: 4 !important;
}

La dernière règle est importante car les navigateurs génèrent un clic uniquement si l’élément qui a reçu l’évènement mousedown est le même qui reçoit l’évènement mouseup. Comme les z-index changent en permanence, ce n’est souvent pas le cas. Il faut donc forcer un peu les choses en mettant l’élément :active au premier plan. C’est expliqué dans l’article de CSS-Tricks avec une solution plus compliquée, mais qui fait l’économie d’un !important.

Une dernière chose me chagrinait avec cette méthode, c’est qu’il était compliqué d’ajouter de nouvelles phrases à la main. J’ai donc écrit un script Python pour générer les fichiers HTML et CSS à partir d’un fichier contenant des phrases.

Le code est sur Framagit, et le résultat sur frama.io.

Avec ça je me serai bien marré, mais la prochaine fois j’utiliserai quand même JavaScript, ce sera plus simple 😅

Des nouvelles de Lessy

2021-03-14T14:43:00+01:00

Je n’ai pas donné beaucoup de nouvelles de Lessy ces derniers temps (le dernier article remonte à septembre 2018). Je profite donc que le serveur ait cramé pour vous en retoucher deux mots.

Pour rappel, Lessy est un gestionnaire de temps destiné à vous aider à mieux vous organiser en associant à vos tâches des indicateurs clairs sur ce que vous avez de plus urgent à réaliser (ou abandonner) dans l’immédiat. Un service est mis à disposition gratuitement sur lessy.yuzu.ovh et le code est hébergé sur GitHub, le tout sous licence libre.

Incendie OVH

Suite à l’incendie chez OVH mercredi dernier, deux de mes serveurs ont été impactés : celui qui hébergeait mes courriels, et celui qui hébergeait Lessy. J’ai remonté le premier rapidement car il est critique pour mon quotidien (j’en ai parlé sur le carnet de Flus). J’ai trainé pour celui de Lessy car j’avais l’espoir de le récupérer… finalement le verdict est tombé vendredi soir : c’est non. J’ai donc pris le temps de remonter le serveur ce matin. Je disposais de backups des données à la date de mardi 9 à 18h, un moindre mal.

Le serveur est toujours hébergé chez OVH, à Gravelines cette fois-ci.

Et ensuite ?

Si vous utilisez Lessy, vous vous demandez peut-être si je prévois encore de bosser dessus. C’est une question difficile.

En l’état, Lessy m’est en fait relativement peu utile. Je l’utilise principalement pendant les périodes où j’ai la tête sous l’eau ; périodes qui se font de plus en plus rares. Ma manière de gérer mes tâches a évolué et j’arrive la plupart du temps à me contenter d’un bout de papier ou du tableau blanc accroché dans ma cuisine. De plus, j’ai le sentiment qu’un outil a tendance à figer l’évolution de mon organisation.

J’aime également pouvoir accéder à ce dont j’ai besoin de me souvenir sans avoir à allumer le PC. Je diminue ainsi le risque de me faire happer par des activités numériques.

Lessy, dans sa version actuelle, correspond en fait pas mal à ce que je souhaitais avoir quand j’ai commencé son développement. J’ai bien des tas d’idées, de choses à ajouter ou à changer, mais je crois qu’il s’agirait d’un outil différent.

Tout bien pensé, je crois que Lessy est terminé.

Dites-moi ce que vous en pensez

Je vois toujours des gens s’inscrire à Lessy, j’ignore d’où elles viennent. Il y a à l’heure actuelle plus de 3 500 comptes créés et je suis extrêmement surpris.

Je n’ai en revanche que (très) peu de retours des personnes qui l’utilisent et j’ignore donc ce que vous en pensez. Aussi, il y a peut-être des micro-changements à apporter qui me coûteraient peu de temps, mais qui vous aideraient grandement au quotidien (je ne m’engage évidemment pas sur des choses plus importantes).

Bref, si vous utilisez Lessy, n’hésitez pas à me contacter pour me faire vos retours, ça m’intéresse !

Une histoire de pizzas : les actions

2021-02-14T18:00:00+01:00

Hey salut, ça fait un bail hein ? Hein, quoi… plus d’un an ? Le temps passe vite 😅 Je dois vous avouer que l’écriture de cet article m’angoissait légèrement parce qu’il s’agissait d’un gros morceau. J’ai donc laissé trainer quelques semaines… puis mois… puis une année entière. Mais nous y voilà !

Pour redonner le contexte, j’ai donné un coup de main en 2019 à deux anciennes collègue pour développer un mini-jeu. Le projet global est un site qui invite à découvrir différents principes d’ergonomie à travers des jeux illustrant les concepts : les Ergogames. J’ai accepté à condition que le code soit ouvert (il l’est donc). Le jeu sur lequel j’ai bossé consiste à déplacer un personnage (Meiko) dans une cuisine en cliquant de case en case. L’objectif est de lui faire fabriquer une pizza. Le principe illustré est celui des actions minimales.

J’ai commencé une série d’articles pour expliquer comment j’avais conçu ce jeu alors que je n’y connaissais pas grand-chose auparavant. J’y explique les étapes pas à pas en tentant d’être aussi pédagogique que possible. Vous êtes invité‧es à lire les articles précédents pour vous y retrouver.

Durant les épisodes précédents, on s’est surtout concentré sur le visuel et les déplacements. On a donc désormais un personnage qui peut aller de case en case, tout en étant arrêté par des éléments « bloquants » (le frigo, le four, etc.) Dans le dernier article, on avait ajouté la liste des étapes du jeu. Il nous faut maintenant la rendre dynamique, en fonction des actions de Meiko !

Le résultat du code de cet article se trouve ici. Je vous invite à en lire le code source, les parties ajoutées par cet article sont commentées.

Cette fois-ci, on ne va modifier que le JavaScript. Il nous faut commencer par adapter quelques éléments.

Premièrement, en fonction des étapes du jeu, Meiko et la pizza vont changer de « look ». Par exemple, la pizza se trouve à l’état de boule au début du jeu, puis Meiko va l’étaler, donc il faut adapter le visuel. Du côté de Meiko, son look s’adapte en fonction des ingrédients qu’il porte (ou non). Ce qu’on va faire, c’est ajouter un composant look. Sa valeur sera modifiée en fonction des actions effectuées par le joueur. On va également modifier le composant assets en l’indexant par les valeurs possibles du composant look.

let gameStore = [
    {
        id: 'meiko',
        // Meiko va changer de "look" en fonction des actions, on ajoute
        // donc un nouveau composant pour le mémoriser
        look: 'normal',
        assets: {
            // On modifie notre composant "assets" pour indexer d’abord par
            // le look et on conserve le système de "direction"
            normal: {
                bottom: 'assets/meiko-face.svg',
                right: 'assets/meiko-droite.svg',
                left: 'assets/meiko-gauche.svg',
                top: 'assets/meiko-dos.svg',
            },
            mozza: {
                bottom: 'assets/meiko-face-mozza.svg',
                right: 'assets/meiko-droite-mozza.svg',
                left: 'assets/meiko-gauche-mozza.svg',
                top: 'assets/meiko-dos.svg',
            },
            sauce: {
                bottom: 'assets/meiko-face-sauce.svg',
                right: 'assets/meiko-droite-sauce.svg',
                left: 'assets/meiko-gauche-sauce.svg',
                top: 'assets/meiko-dos.svg',
            },
            pizza: {
                bottom: 'assets/meiko-face-pizza.svg',
                right: 'assets/meiko-droite-pizza.svg',
                left: 'assets/meiko-gauche-pizza.svg',
                top: 'assets/meiko-dos.svg',
            },
        },

        // ...
    },

    // Puis on fait la même chose avec la pizza (note : dans les articles
    // précédents, l'id était `dough`, j'ai modifié en `pizza` mais c'est
    // un détail)
    {
        id: 'pizza',
        // la pizza aussi change de look au fur et à mesure de la partie,
        // mais pas de direction pour elle !
        look: 'doughBall',
        assets: {
            doughBall: 'assets/pate-pizza-boule.png',
            dough: 'assets/pate-pizza.svg',
            tomato: 'assets/pate-tomate.svg',
            mozza: 'assets/pizza.svg',
            profile: 'assets/pizza-plat.svg',
        },

        /// ...
    },

    // ...
};

Maintenant qu’on a modifié le fonctionnement du composant assets, il faut prendre ça en compte dans le code qui l’utilise. Heureusement pour nous il s’agit d’une seule petite fonction simple : entityAssetImage. On la retrouve dans nos méthodes VueJS :

const app = new Vue({
    methods: {
        // On modifie légèrement le rendu ici puisqu’on a fait évoluer le
        // composant "assets" pour fonctionner avec le nouveau composant
        // "look".
        entityAssetImage(entity) {
            if (entity.assets == null || entity.look == null) {
                return '';
            }

            // on récupère l'asset correspondant au "look" actuel
            const asset = entity.assets[entity.look];
            if (entity.direction) {
                // si l'entité a un composant direction, il faut encore
                // piocher la bonne image
                return asset[entity.direction];
            } else {
                // sinon, on retourne la valeur telle quelle
                return asset;
            }
        },

        // ...
    },

    // ...
});

Désormais, lorsque la valeur de look changera, VueJS changera pour nous l’image affichée à l’écran. Idéalement il faudrait faire quelques vérifications supplémentaires pour rendre le code plus robuste, mais on est sur un mini-jeu pas critique, je privilégie la lisibilité en allant droit au but.

Deuxième élément important à ajouter à notre jeu : le système qui va exécuter les actions. Il va s’agir de fonctions exécutées quand on cliquera sur le bon élément du jeu et qui modifieront l’état interne du jeu (gameStore). Ces fonctions vont donc être rattachées aux différentes entités via un nouveau composant : exec. Elles seront exécutées lorsqu’on cliquera sur l’entité correspondante (au sein de la fonction onClickSystem). Une facilité du jeu, c’est qu’il n’y a toujours qu’une seule chose à faire à la fois, soit un seul composant exec à la fois. Ça nous évite quelques nœuds au cerveau. La première action consiste à étaler la pâte, il faut donc rajouter le composant exec à la pizza-pâte :

let gameStore = [
    {
        id: 'pizza',
        // Le nouveau composant exec qui permet de faire avancer le jeu !
        // La première action consiste à étaler la pâte, on a donc un seul
        // composant exec qui pointe vers l'action `rollOutDough`.
        exec: rollOutDough,

        /// ...
    },

    // ...
};

La fonction elle-même sera écrite un peu plus loin. En attendant on va ajouter l’exécution de la fonction au sein de onClickSystem, exécuté lorsqu’on clique sur une case :

function onClickSystem(e, store) {
    // ...

    const meiko = getEntity(store, 'meiko');
    if (!positionIsAccessibleFor(meiko, position)) {
        return store;
    }

    // Avant de bouger Meiko, on recherche les entités situées sur la case
    // cliquée : s'il en existe avec le composant "exec", alors on appelle
    // la fonction associée en lui passant le store et la position. La
    // fonction doit retourner un nouveau store mis à jour.
    let updatedStore = store;
    const entitiesAtPosition = searchEntitiesAt(updatedStore, position);
    entitiesAtPosition.forEach((entity) => {
        if (typeof entity.exec === 'function') {
            updatedStore = entity.exec(updatedStore, position);
        }
    });

    // ...
}

Rien de sorcier ici, on se contente du fait que JavaScript nous permet de référencer une fonction par son nom et de l’exécuter via cette référence en ajoutant les parenthèses et les paramètres.

On pourrait passer tout de suite à l’écriture des actions, mais il va nous manquer une dernière mini-fonction. On va en effet avoir besoin de supprimer des entités du gameStore (ex. la sauce tomate va disparaître une fois que Meiko l’aura attrapée).

// On a désormais besoin de supprimer des entités du jeu. On ne garde
// (`filter`) que les entités dont l'id est différent de celui passé en
// argument.
function removeEntity(store, id) {
    return store.filter((entity) => entity.id !== id);
}

Nous avons désormais tous les éléments nécessaires pour faire avancer le jeu, il n’y a plus qu’à écrire les actions ! Une action est en fait très simple :

elle commence par mettre à jour l’étape courante (l’entité currentStep) ;
elle ajoute un composant exec, pointant vers la prochaine action, sur l’entité correspondante ;
et supprime le composant exec de l’entité actuelle ;
elle peut également changer le look des entités, en supprimer, etc.

Commençons par notre première action : rollOutDough.

function rollOutDough(store) {
    let updatedStore = store;

    // on commence par mettre à jour l’étape actuelle
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_GRAB_TOMATO' });

    // puis on "installe" un composant exec sur l'entité "tomato" puisque
    // c’est la prochaine destination de Meiko
    updatedStore = setEntityComponents(updatedStore, 'tomato', { exec: grabTomato });

    updatedStore = setEntityComponents(updatedStore, 'pizza', {
        // Meiko vient d’étaler la pâte, il faut changer le "look" de la
        // pizza
        look: 'dough',
        // comme on n’a plus rien à faire pour le moment sur la pizza, on
        // pense à enlever son composant "exec" (sinon Meiko pourra étaler
        // la pizza plusieurs fois de suite).
        exec: null,
    });

    // et finalement, on renvoie le nouveau store
    return updatedStore;
}

On le voit, il s’agit uniquement de modifier le store passé en paramètre à l’aide de la fonction setEntityComponents qu’on avait écrite dans un article précédent. Si vous avez réussi à suivre jusqu’ici, ça devrait être vraiment simple à comprendre ! Le fait de changer le currentStep permet de changer visuellement l’étape courante : c’est le code écrit dans l’article précédent.

Nous avons maintenant une nouvelle action à écrire…

function grabTomato(store) {
    let updatedStore = store;

    // idem, on met à jour l’étape actuelle
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_SPREAD_TOMATO' });

    // puis on ajoute un "exec" sur la pizza car l'action suivante porte
    // sur elle
    updatedStore = setEntityComponents(updatedStore, 'pizza', { exec: spreadTomato });

    // on change le look de Meiko qui porte maintenant le pot de tomate
    updatedStore = setEntityComponents(updatedStore, 'meiko', { look: 'sauce' });

    // et on enlève l'entité "tomato" car elle n'est plus présente sur le
    // plan de travail. On est d'accord que le pot de tomate est toujours
    // visible, mais on triche en l’intégrant visuellement à l'asset de
    // Meiko.
    updatedStore = removeEntity(updatedStore, 'tomato');

    return updatedStore;
}

En supprimant l’entité tomato, on a supprimé par la même occasion son exec. Mais… oh non, on a encore une action à écrire ! Vous l’aurez compris, on va continuer exactement de la même manière pour chaque action, car elles s’enchaînent les unes après les autres. Je vous donne tout le code d’un coup. Il y a quelques passages où j’ai triché par rapport à la version initiale du jeu pour simplifier les explications. Ces passages sont signalés en commentaire.

function spreadTomato(store) {
    let updatedStore = store;
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_GRAB_MOZZA' });
    updatedStore = setEntityComponents(updatedStore, 'mozza', { exec: grabMozza });
    updatedStore = setEntityComponents(updatedStore, 'pizza', {
        look: 'tomato',
        exec: null,
    });
    updatedStore = setEntityComponents(updatedStore, 'meiko', { look: 'normal' });
    return updatedStore;
}

function grabMozza(store) {
    let updatedStore = store;
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_SPREAD_MOZZA' });
    updatedStore = setEntityComponents(updatedStore, 'pizza', { exec: spreadMozza });
    updatedStore = removeEntity(updatedStore, 'mozza');
    updatedStore = setEntityComponents(updatedStore, 'meiko', { look: 'mozza' });
    return updatedStore;
}

function spreadMozza(store) {
    let updatedStore = store;
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_GRAB_PIZZA_1' });
    updatedStore = setEntityComponents(updatedStore, 'pizza', {
        look: 'mozza',
        exec: grabUncookedPizza,
    });
    updatedStore = setEntityComponents(updatedStore, 'meiko', { look: 'normal' });
    return updatedStore;
}

function grabUncookedPizza(store) {
    let updatedStore = store;
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_PUT_PIZZA_IN_OVEN' });
    updatedStore = setEntityComponents(updatedStore, 'oven', { exec: putPizzaInOven });
    // Ici on triche un peu. On ne veut plus afficher la pizza dans le jeu.
    // Dans la version initiale, je supprimais le composant et le recréait
    // plus tard. Ça se basait cependant sur un mécanisme que je n'ai pas
    // expliqué dans ma série d'articles, donc je dois faire différemment.
    // Ici, je vire simplement le "look" pour cacher la pizza.
    updatedStore = setEntityComponents(updatedStore, 'pizza', {
        look: null,
        exec: null,
    });
    updatedStore = setEntityComponents(updatedStore, 'meiko', { look: 'pizza' });
    return updatedStore;
}

function putPizzaInOven(store, position) {
    let updatedStore = store;
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_GRAB_PIZZA_2' });
    updatedStore = setEntityComponents(updatedStore, 'oven', {
        exec: null,
    });
    // la suite de l'action précédente : on redonne un look à la pizza, et
    // on change sa position à l'emplacement qui vient d'être cliqué.
    updatedStore = setEntityComponents(updatedStore, 'pizza', {
        position,
        look: 'profile',

        // je triche encore ! Dans la version initiale on est sensé
        // attendre la cuisson de la pizza (5 secondes). Ça se base sur un
        // autre système que je n'ai pas expliqué dans la série d'articles,
        // donc je saute l'étape de la cuisson (STEP_BAKE_PIZZA). Peut-être
        // que j'en parlerai dans un article bonus parce que le mécanisme
        // est intéressant.
        exec: grabCookedPizza,
    });
    updatedStore = setEntityComponents(updatedStore, 'meiko', { look: 'normal' });
    return updatedStore;
}

function grabCookedPizza(store) {
    let updatedStore = store;
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_DELIVER_PIZZA' });
    updatedStore = setEntityComponents(updatedStore, 'hatch', { exec: deliverPizza });
    updatedStore = setEntityComponents(updatedStore, 'pizza', {
        look: null,
        exec: null,
    });
    updatedStore = setEntityComponents(updatedStore, 'meiko', { look: 'pizza' });
    return updatedStore;
}

function deliverPizza(store, position) {
    let updatedStore = store;
    // et c'est la fin ! Remarquez qu'on vire le dernier "exec" sans en
    // rajouter un autre.
    updatedStore = setEntityComponents(updatedStore, 'currentStep', { value: 'STEP_FINISH' });
    updatedStore = setEntityComponents(updatedStore, 'hatch', { exec: null });
    updatedStore = setEntityComponents(updatedStore, 'pizza', {
        position,
        look: 'profile',
    });
    updatedStore = setEntityComponents(updatedStore, 'meiko', { look: 'normal' });
    return updatedStore;
}

Les actions se ressemblent vraiment toutes, la difficulté réside dans le fait de ne pas se tromper dans l’enchaînement des étapes et des choses à faire. Un avantage à la simplicité de ces fonctions, c’est qu’on peut écrire des tests pour vérifier leur comportement extrêmement facilement.

Voici donc pour le dernier article « officiel » de cette série ! Celui-ci était peut-être un peu plus dense que les autres, bien qu’au final pas excessivement compliqué. Pour rappel, vous pouvez retrouver la version de cet article ici.

J’ai été surpris d’arriver à me replonger dans le code aussi facilement après plus d’un an de pause dans l’écriture de la série, ce qui me conforte dans la qualité de ce que j’ai développé (malgré les facilités et « hacks » utilisés par endroits). J’aurais encore bien des choses à raconter : la mise en cache des images, les mécanismes asynchrones (dont la gestion du chronomètre), les écrans de début et fin de jeu, etc. Certaines de ces choses m’intéressent à écrire, d’autres moins. Dans tous les cas je ne veux pas m’engager à les écrire, donc si je le fais ce sera à travers des articles « bonus ».

J’ai pris beaucoup de plaisir à expliquer les choses de manière didactiques, en découpant les étapes autant que possible et en commentant un maximum de code. Je ne sais pas si beaucoup de monde m’aura lu en intégralité, mais je serais ravi si ça a pu être utile (ou même simplement intéresser quelqu’un).

Alléger

2021-02-07T13:00:00+01:00

J’ai parlé dans mon précédent article, 2021, de ma volonté de retrouver une part d’anonymat sur Internet. À l’époque je n’étais pas sûr de savoir ce que cela signifierait pour ce site. J’envisageais notamment de simplifier la page d’accueil et de virer le blog. J’ai trouvé une solution qui me convenait mieux.

La page d’accueil a effectivement subi un ravalement de façade conséquent : mon nom, 4 phrases et quelques liens. C’est largement suffisant pour me présenter.

J’ai conservé le blog. En revanche, j’ai décidé de garder dans la liste principale uniquement les articles récents (6 mois et moins). J’y ai adjoint une seconde liste d’articles sélectionnés (parce qu’ils me parlent et qu’ils racontent quelque chose sur moi). Celle-ci évoluera sans doute ; j’aimerais n’en lister qu’une dizaine maximum. Enfin, j’ai conservé les séries parce qu’elles recontextualisent certains articles. Finalement, peu d’anciens articles ne sont plus accessibles directement, mais j’aime l’idée que certains tombent dans une forme d’oubli. Ils existent toutefois toujours afin de ne pas casser les liens pointant vers eux.

De manière plus globale, j’ai allégé visuellement quelques éléments : l’en-tête est plus simple, le pied de page ne contient plus qu’une poignée de liens. J’ai aussi réorganisé quelques éléments pour mettre l’emphase sur le contenu « utile ».

Enfin, il n’y a plus de liens vers mes comptes de réseaux sociaux, seulement mon adresse courriel sur la page d’accueil. Inversement, j’ai retiré les liens vers mon site depuis mes comptes de réseaux sociaux. C’est une manière de cloisonner mes identités en ligne. Je continuerai sans doute de partager des articles là-bas, mais ça ne sera pas automatique. Pour suivre le blog, privilégiez les flux de syndication.

Je suis heureux de ces changements qui simplifient beaucoup de choses. Le site est maintenant plus aligné avec ce que je veux partager en ligne. Reste plus qu’à reprendre l’écriture d’articles 😏

2021

2021-01-16T19:11:00+01:00

L’année dernière, dans mon article « 2020 », j’exprimais mon envie de continuer à écrire plus d’articles sur ce blog. Si vous êtes passé‧e par l’accueil, vous devez être en train de rigoler : je n’en ai publié que deux.

Je ne suis pas certain de reprendre un meilleur rythme cette année, mais je prends tout de même le temps de faire un point d’étape à ce moment charnière du changement d’année (ok, avec quelques jours de retard). J’apprécie cet exercice car il me permet de prendre du recul et de me fixer des résolutions pour l’année à venir. Vous y lirez également en filigrane les raisons qui m’ont poussé à moins écrire ici.

Flus, le gros morceau qui occupe

Je n’ai pas pris le temps d’en parler ici, mais mon projet Flus a bien décollé avec la sortie d’une deuxième version en décembre. Il s’agit d’un média social de veille, qui s’articule autour de 3 principes : des signets pour mettre de côté des liens à consulter plus tard, des collections pour partager sa veille avec les autres personnes de la plateforme et un journal qui vous suggère du contenu à lire. Il s’agit de mon activité à plein temps et j’espère me dégager un premier revenu d’ici la fin de l’année.

Le lancement de décembre a été réussi (CA multiplié par 8 par rapport aux mois précédents, 200 inscrit‧es), j’en suis content. Il reste à transformer l’essai, mais les retours sont très positifs. Je me retrouve maintenant sous une montagne de retours à prendre en compte (ou pas) ; c’est un chouette problème à avoir je crois. Maiwann et son expertise UX m’ont été d’une aide énorme, mais j’ai toujours l’impression de ne pas réussir à la remercier suffisamment.

Flus dispose de son propre blog, le carnet, qui a été bien pourvu en 2020. J’espère continuer sur cette lancée en 2021, mais mon expérience d’un tel objectif me laisse penser qu’il faut rester discret. Si vous souhaitez en savoir plus, je vous invite à vous abonner à son flux RSS.

Cycles, rythme de vie et expériences

Ces derniers mois j’ai eu l’occasion de revoir mon rapport à l’ordinateur.

Les 2 confinements m’auront tapé sur le système, surtout le deuxième qui a été compliqué. J’ai réussi à le traverser grâce à quelques jours de vacances et une réorganisation de mon temps libre. Ça faisait quelque temps que je diminuais le temps PC ; ça a été l’occasion de diminuer encore plus. Je me suis fixé comme objectif de dessiner, d’écrire et de faire de l’exercice tous les jours. Pour l’instant, à part le 25 décembre, c’est un succès. J’ai commencé par un rythme de 5 minutes par jour – pas plus, pas moins – pendant 2 semaines. C’est peu, mais ça m’a permis de tenir les premiers temps. J’augmente la durée au fil des semaines, en variant selon les jours. Je commence à trouver un plaisir dans ces activités que je n’avais pas lors de mes tentatives précédentes. C’est bon signe.

J’adapte également la place que me prend le boulot dans mon quotidien. M’arrêter à 15h pour aller faire une balade devient possible sans que je m’en « veuille ». Je trouve que c’est un processus difficile que de s’autoriser à faire des journées plus courtes sans éprouver de remords ; c’est le deuxième confinement qui a servi de déclic. Il m’est toutefois compliqué de mesurer l’impact que ça a concrètement sur mon travail. Je travaille moins, c’est certain, mais j’ai également la sensation d’être plus efficace. Je n’ai pas envie de mesurer si le bilan « productif » est positif : je me sens mieux et c’est le plus important.

Enfin, je continue de fonctionner par cycles. J’ai toutefois récemment adopté un rythme calqué sur les mois de l’année (ils faisaient 6 semaines auparavant) : ça m’en facilite le suivi. Chaque cycle se conclut par une rétrospective. Les actions qui en découlent sont souvent puissantes pour changer mon quotidien. J’ai trouvé un format de rétro qui me plaît et qui est efficace ; il m’aura fallu 2 ans.

Anonymat ?

La fin de l’année 2020 m’aura donné l’occasion de réfléchir à comment je souhaite gérer ma présence en ligne. J’ai envie de plus d’anonymat et dévoiler le strict minimum concernant mon identité. Ça questionne en partie la stratégie que je voulais adopter avec Flus qui est de pouvoir mettre un nom et un visage sur la personne qui gère le service, mais :

j’ai déjà créé un compte Twitter séparé pour tester ;
je ne souhaite pas adopter un anonymat strict ;
mettre un peu de distance permettrait de mieux me protéger au cas où le service gagnerait en notoriété.

Tout ça est en douce réflexion et je trouve la question de la présence/identité en ligne passionnante. J’ai envie d’explorer ça cette année.

Le site et le blog s’en trouveraient potentiellement impactés. Simplification du site ? Masquage ou arrêt du blog ? Essayer « autre chose » ? Mes envies fluctuent sur ce point, affaire à suivre.

Conclusion

J’ai eu une année plus tranquille que la précédente. Vous direz que forcément, avec le confinement… Mais je suis persuadé que sans confinement, mon année n’aurait pas été fondamentalement différente. Je consolide peu à peu le rythme que j’ai adopté au début de mon chômage et apprend à prendre soin de moi au quotidien. J’ai l’impression d’avoir plus appris sur moi durant les deux dernières années qu’au cours des 27 années précédentes ; je me sens transformé. Cela est sans doute dû également aux personnes que j’ai rencontrées ou que je me suis mis à suivre sur les réseaux sociaux durant cette période. Je les remercie.

La low-tech existe-t-elle dans le numérique ?

2020-03-08T10:30:00+01:00

Je développe une gêne croissante vis-à-vis de la notion de « low-tech » en informatique : il me semble y déceler un biais inconfortable dans sa définition même. Je précise que je parle en tant que développeur travaillant principalement dans le Web. Cet article est – volontairement – biaisé.

Pour comprendre l’origine de mon problème, il me faut commencer par définir ce que j’entends par low-tech. De mon point de vue, il s’agit avant tout d’une notion qui s’oppose à celle de high-tech. Si vous effacez cette dernière du paysage, la low-tech disparaît par la même occasion car elle perdrait son sens, sa raison d’exister. Je parle ici de la notion et non pas de l’existence « d’objets low-tech » (une roue en bois par exemple) qui ne disparaitront pas par magie. Il nous faudrait toutefois désormais définir ce qui ferait la spécificité d’un numérique high-tech pour en tirer ce qui s’y oppose. Or le numérique est intrinsèquement high-tech car il se base sur des connaissances et des techniques de pointe. Le fonctionnement d’un ordinateur et déjà par lui-même quelque chose de pointu ; que dire alors de sa fabrication ? de celle de nos ordiphones ? et des milliers de kilomètres de câbles parcourant la terre et les océans pour former l’Internet mondial ?

Comment définir un terme – la low-tech numérique – si son existence même est impossible ? ¹

Il est toutefois évident que certaines pratiques et outils numériques décrivent une réalité low-tech, ne serait-ce qu’à travers la définition que leur donne leurs concepteurs et conceptrices. On peut notamment citer le site du « low-tech magazine », tournant sur un serveur alimenté en énergie solaire et qui passe hors-ligne lorsque le soleil vient à se cacher trop longtemps. En moins extrême, Gauthier Roussilhe a raconté la transition de son site vers un site « low-tech ». Plus récemment, Geoffrey Dorne a également listé quelques sites (à inspiration) low-tech. J’ai moi-même créé un générateur « low-tech » de sites statiques.

Une chose me frappe alors : le numérique low-tech serait-il le Web « un point zéro » des débuts ? de simples sites statiques à l’occasion d’un grand bond en arrière dans nos usages ? C’est évidemment une manière très caricaturale de voir les choses et il suffit de reprendre l’article de Geoffrey pour cela : il y cite notamment Wikipédia et un thème pour Wordpress. On reste évidemment sur des systèmes très simples, mais on voit que la low-tech n’est pas uniquement réservée aux sites statiques ; une part de « dynamique » y est autorisée.

Reste à déterminer ce qui rentre dans la case et ce qui n’y rentre pas. Une application métier peut-elle être low-tech ? Si je me base sur mon ressenti j’ai envie de répondre par l’affirmative. Qu’en est-il d’un service de streaming de vidéos ? Ici, j’ai envie de répondre par un franc « non »… mais si les vidéos sont optimisées au poil de cul, mises en cache et partagées sur le réseau local au point que leur impact écologique ne constitue plus qu’une ridicule broutille ?

Ce n’est peut-être pas aussi simple…

On voit toutefois sur cet exemple de site de streaming que pour faire du low-tech, j’ai dû user de l’argument d’un certain savoir-faire technique ; d’une technique qui me permette de réduire l’impact écologique du site en question. Je m’étais d’ailleurs fait cette réflexion en lisant l’article de Gauthier qui expliquait avoir réduit de 75 % le poids des vidéos qu’il hébergeait, soit un passage de quelque 14 Go à un poids final d’environ 3 Go. Finalement, les autres optimisations qu’il avait pu faire par ailleurs ne représentaient plus grand-chose comparé au gain fait sur les vidéos. On aurait pu le questionner sur l’impact de la démarche elle-même – le temps de calcul pour optimiser les images par exemple – comparé aux gains. Quant aux vidéos il avait fait le choix de les conserver, au moins en partie. Pourtant, tout cela ne semblait pas avoir été fait en vain ; l’article a même été abondamment relayé autour de moi, comme pour me certifier qu’il s’agissait bien là d’un article de référence dans le paysage de la low-tech.

De tout cela, j’en tirai la conclusion que « faire de la low-tech » n’est pas tant lié au résultat final qu’à une démarche volontaire.

Finalement, c’est Bertrand Keller qui l’exprimait le mieux dans son article « La Low-Tech, concept positif » (la mise en gras est de moi) :

Dans l’article (Les tables de la Low (Tech)), j’ai repris la définition donnée par le Low-Tech Lab, pour la questionner. Je n’ai pas vu dans la définition, de notion de perte d’usage. On parle d’utilité, d’accessibilité, de durabilité ; c’est-à-dire un concept de but mais pas de perte d’usage sous prétexte que ça consomme moins d’énergie.

Pour comprendre la low-tech, il faudrait donc prendre le problème par l’autre bout : pour un usage donné que je considère utile, comment puis-je le rendre le plus accessible et durable possible ?

À ce point-là de mon article, je ne suis toujours pas aligné avec le terme même de low-tech, mais sa finalité positive me parle bien.

Toutefois, quelque chose continue de me chiffonner et je vais l’illustrer avec une petite anecdote. Lors du dernier Snowcamp, une conférence – Développement Zéro Déchet – a fait salle comble (c’est un euphémisme tellement ça débordait de partout). Les intervenant·es n’abordaient pas frontalement la notion de low-tech, mais vous conviendrez que quand on parle de « zéro déchet », on n’en est quand même pas bien loin. Il et elle expliquaient les étapes pour optimiser une application développée précédemment en se basant sur des principes « zéro déchet ». Sauf que – et je ne sais pas si ça a été décidé consciemment avec le souci d’illustrer – l’application avait été tellement mal conçue à l’origine que je trouvais l’exercice totalement aberrant. J’ai plutôt eu l’impression d’assister à un cours d’optimisation assez basique que réellement une réflexion autour d’un hypothétique « développement zéro déchet ».

La démarche n’en était pas moins intéressante, d’autant plus que c’est ce qui m’a mis la puce à l’oreille qu’il pouvait y avoir un problème plus profond dans cette histoire de low-tech numérique. Finalement ne s’agirait-il pas d’une forme de green-washing pour développeur·ice en quête de sens dans son métier ? Sous couvert de vouloir alléger notre empreinte carbone, nous commencerions (enfin) à développer nos sites de manière correcte et optimisée ; de l’optimisation technico-politique en fin de compte.

Cela cache par ailleurs un problème que je n’ai vu nulle part posé : de quel impact concret parle-t-on ? Je n’en ai pas la réponse, mais si des études existent sur le sujet je ne serais pas étonné que le gain du passage d’un site dynamique à du statique soit ridiculement faible face au visionnage d’une vidéo de chaton sur Youtube, lui-même minime face à la fabrication d’un terminal. « Développer des sites statiques », bientôt dans les conseils du gouvernement pour combattre le réchauffement climatique au côté de « faire pipi sous la douche » et « trier ses courriels » !

Mais ce serait considérer le problème uniquement d’un point de vue comptable.

On en revient doucement à l’éternel débat : les actions individuelles de faible impact valent-elles le coût d’être menées ? J’ai tranché pour mon cas personnel depuis un moment en considérant que c’est très justement à chaque individu d’y apporter une réponse. Les encourager ne me semble toutefois pas idiot en cela qu’une action individuelle reste souvent un premier pas facile au sein d’une démarche politique plus large (ici, « réduire notre impact environnemental »). Cela ne doit pas occulter que les vrais changements surviendront à un niveau systémique… mais est-ce qu’un ensemble d’individus ne peut pas former un « système » en capacité de s’opposer à d’autres forces systémiques ?²

Pour résumer tout ce que j’ai dit jusque-là, on a vu que la notion de low-tech en numérique n’a pas tellement de réalité « physique » (ou alors peut-on parler de « low-tech-on-high-tech » ?) Il s’agirait aujourd’hui plutôt d’un mouvement d’individus adoptant une démarche politique volontaire d’optimisation de leurs sites Internet afin de réduire leur impact écologique. Ça peut sembler extrêmement réducteur comme vision et je rappelle qu’il s’agit uniquement de la mienne, exprimée à travers mes propres biais. Connaître les limites d’une telle démarche me semble toutefois important pour prendre conscience qu’il ne s’agit que d’un outil parmi d’autres pour ne pas s’en contenter. Cela peut également aider à répondre à des critiques.

Vous ne sauverez certainement pas la planète avec des sites statiques, mais vous aiguiserez vos engagements tout en rendant vos visiteur·heureuses³.

Pour ma part, je ne pense pas / plus utiliser le terme de low-tech car je le trouve mal adapté à ce qu’il cherche à définir. Pour l’instant je lui préfère la notion de « sobriété » qui a l’avantage de ne pas s’opposer frontalement à la high-tech (ce que le numérique est intrinsèquement). Il s’agit évidemment d’un choix personnel, et Bertrand – cité plus haut – s’est aussi questionné sur le sujet en faisant le choix inverse. Cela n’enlève rien à l’utilité de cet outil qui cherche à questionner l’impact du numérique sur le monde physique qui nous entoure. Il vient donc s’ajouter à ma besace, en compagnie de la notion de logiciel libre qui questionne le concept de propriété. Dans ces deux cas, ce n’est pas tant leur finalité qui m’intéresse que les imaginaires positifs qu’ils tentent de bâtir, ainsi que les cultures qui en émergent ; comme des remèdes à un monde qui ne tourne parfois plus si rond.

Sauf à vivre en Océania en 1984, évidemment. ↩
J’avais initialement écrit « qu’est-ce qu’un « système » si ce n’est un ensemble d’individus ? » On m’a très justement fait remarquer que cela occultait la présence d’autres « systèmes » comme les États ou Marchés. ↩
L’écriture inclusive permet également d’inventer de nouveaux type de jeu de mots. On est d’accord que ce n’est pas super lisible par contre ! ↩

2020

2020-01-03T10:57:00+01:00

Mon année 2019 aura sans aucun doute été très riche sur le plan personnel. J’ai notamment :

refait mon site web ;
repris goût à l’écriture (18 articles ici, 12 là-bas) ;
participé à une super association ;
co-organisé ma première conférence ;
aidé à mettre en place une plateforme de démocratie participative ;
développé un mini-jeu ;
appris à faire du pain ;
et, surtout, entamé un nouveau projet professionnel.

Mais ce que j’ai fait ne m’intéresse guère, c’est plutôt le ressenti que tout cela me laisse qui fait que je suis content de mon année. Pour l’année 2020, je vais essayer de me recentrer pour approfondir quelques voies empruntées.

Valider que Flus est un projet viable (ou non). Il y a encore du boulot, et parfois beaucoup trop. J’avance pas (à pas) mais jamais aussi vite que ce que j’aimerais, probablement lié à ma capacité à m’éparpiller. Je travaille dessus. Et il faut que je m’améliore en communication et marketing. En tout cas ça m’amuse et je suis rentable pour l’instant, c’est déjà ça de pris.

Continuer de faire du pain (genre, beaucoup). J’ai commencé à en faire après le passage de Thomas à l’appartement, j’ai trouvé ça chouette. Au début vraiment une fois de temps en temps, j’ai finalement pris un rythme soutenu depuis la fermeture de ma boulangerie préférée à Grenoble (désormais à Chambéry). Je me dis que ça ferait une chouette reconversion plus tard.

Continuer d’écrire (genre, pas mal). Pour ce blog, j’aimerais réussir à faire quelque chose de peut-être plus personnel. La liste des titres de mes articles de 2019, dans leur majorité, me laisse une impression un peu dérangeante, comme si je ne parlais jamais de moi dedans ; bizarre pour un blog lié à un site personnel. Je le ressens aussi dans le « ton » que j’emploie, dans les mots que je choisis. J’aimerais me rapprocher d’un ton plus « parlé ». J’ai commencé à travailler dessus mais ne suis pas encore totalement satisfait.

Concevoir une V2 pour Lessy (et la terminer). J’ai laissé trainer ce projet en 2019, mais je continue de l’utiliser quotidiennement. J’ai eu une fulgurance le 1^er janvier, et toutes les idées que j’avais pour l’améliorer se sont agencées correctement. Je ne me vois pas « améliorer » la version actuelle, donc ce sera un redéveloppement sur des bases plus simples, dans l’idéal tendant sur du low-tech pour une maintenance minimale une fois que j’aurai terminé. En tout cas la vision que j’ai des fonctionnalités est très claire.

Bon, et puis j’ai décidé d’arrêter de procrastiner pour avoir le temps de faire plus de choses. Ça fait quatre jours que je me suis fait une note mentale qui fait qu’à chaque fois que « j’ai la flemme », je me réponds « bouge-toi » et que ça marche. Vous inquiétez pas, ça va pas durer.

Et bonne année !

Une histoire de pizzas : les étapes

2019-12-31T10:39:00+01:00

Après une petite pause, voici le sixième épisode de ma série d’articles retraçant la conception d’un mini-jeu vidéo. Comme d’habitude, vous êtes invité·es à lire les articles précédents pour vous y retrouver.

Aujourd’hui, on va faire simple : on va afficher la liste des étapes que le joueur devra suivre pour avancer dans le jeu. Le gros du travail se fera dans l’article suivant.

Pour ce faire, on va commencer par déclarer les étapes en JavaScript :

// On déclare les étapes dans un objet...
const steps = [
    { id: 'STEP_ROLL_OUT_DOUGH', label: 'Étaler la pâte avec les doigts' },
    { id: 'STEP_GRAB_TOMATO', label: 'Aller chercher la sauce tomate sur l’étagère' },
    { id: 'STEP_SPREAD_TOMATO', label: 'Verser la sauce tomate sur la pizza' },
    { id: 'STEP_GRAB_MOZZA', label: 'Aller chercher la mozzarella dans le frigo' },
    { id: 'STEP_SPREAD_MOZZA', label: 'Disposer la mozzarella sur la sauce tomate' },
    { id: 'STEP_GRAB_PIZZA_1', label: 'Prendre la pizza' },
    { id: 'STEP_PUT_PIZZA_IN_OVEN', label: 'Mettre la pizza au four' },
    { id: 'STEP_BAKE_PIZZA', label: 'Cuire 5 secondes' },
    { id: 'STEP_GRAB_PIZZA_2', label: 'Prendre la pizza' },
    { id: 'STEP_DELIVER_PIZZA', label: 'Emporter la pizza jusqu’au passe-plat' },
    { id: 'STEP_FINISH' },
];

const app = new Vue({
    el: '#app',
    data: {
        size: BOARD_SIZE,
        store: gameStore,
        // ... que l'on passe ensuite à data pour pouvoir y accéder depuis la vue
        steps,
    },

    // ...
});

C’est tout bête, rien de bien méchant ici. Il nous faut désormais afficher cette liste dans le HTML.

<div id="app">
    <div class="steps">
        <div class="steps-title">Recette</div>

        <transition v-for="(step, index) in steps" :key="step.id">
            <div
                v-if="step.label"
                :class="['steps-item', { current: step.id === currentStep }]"
            >
                <div class="steps-item-index">{{ index + 1 }}</div>
                <div class="steps-item-label">{{ step.label }}</div>
            </div>
        </transition>
    </div>

    <!-- ... -->
</div>

Vous remarquerez peut-être que je déclare une class .current pour indiquer quelle est l’étape en cours. Néanmoins, je fais appel à une variable currentStep que nous n’avons pas encore déclarée. Il s’agit d’une valeur qui va évoluer au fil du temps à travers des actions liées aux clics du joueur, c’est-à-dire dans notre système onClickSystem. Cette valeur doit donc être déclarée dans le store du jeu. Retour dans le JavaScript :

let gameStore = [
    /*
        On ajoute une nouvelle entité au store pour mémoriser l'étape
        courante. C'est cette valeur qui va permettre d’avancer dans le jeu
        plus tard.
    */
    { id: 'currentStep', value: 'STEP_ROLL_OUT_DOUGH' },

    // ...
];

const app = new Vue({
    // ...

    computed: {
        // On déclare une donnée "computed" : il s'agit d'une donnée qui
        // est calculée depuis une autre donnée déjà stockée dans data
        // (ici, le store). Il s'agit juste de simplifier le code du
        // template HTML.
        currentStep() {
            return getEntity(this.store, "currentStep").value;
        },
    },
});

Avec ça, on a quasiment terminé pour cette fois-ci, on va juste ajouter un peu de CSS pour rendre le tout un poil plus joli.

/* Du CSS pour afficher le bloc des instructions à gauche de la zone de jeu */
#app {
    display: flex;
    justify-content: center;
}

/*
   Et du CSS pour styler les instructions elles-mêmes. Ironiquement, il y a
   besoin de plus de CSS pour cette partie que pour la zone de jeu.
*/
.steps {
    width: 30%;
    margin-right: 1rem;
    padding: .5rem 1rem;

    font-family: sans-serif;

    background-color: #eee;
    border-radius: .5rem;
}

.steps .steps-title {
    margin-bottom: 1rem;
    padding-bottom: .25rem;

    text-align: center;

    border-bottom: 1px solid #ccc;
}

.steps .steps-item {
    display: flex;
    padding: .25rem .5rem;

    align-items: baseline;

    color: #666;
    font-size: .8rem;

    border: .25rem solid transparent;
}

.steps .steps-item.current {
    color: #000;
    font-weight: bold;

    border-color: #00dbcb;
    border-radius: .5rem;
}

.steps .steps-item .steps-item-index {
    display: flex;
    width: 1.25rem;
    height: 1.25rem;
    margin-right: .25rem;

    flex-shrink: 0;
    align-items: center;
    justify-content: center;

    color: #fff;

    background-color: #666;
    border-radius: 50%;
}

.steps .steps-item.current .steps-item-index {
    color: #000;

    background-color: #00dbcb;
}

Avant de finir cet article, je veux juste pointer une petite différence vis-à-vis du jeu initial. J’ai fait le choix ici d’afficher toutes les instructions pour simplifier légèrement le code et ne pas rentrer dans des détails inutiles d’implémentation. Dans le jeu des Ergogames, seulement deux instructions sont affichées à la fois : l’étape courante et l’étape suivante. Si le détail technique n’est pas important, il l’est cependant d’un point de vue utilisabilité. Cette partie a beaucoup évolué avec les retours des utilisateurs et utilisatrices, notamment pour satisfaire la contrainte de l’écran réduit sur mobile. Ce n’est d’ailleurs même pas moi qui aie fait les derniers changements.

Il ne vous reste plus qu’à tester le résultat du code de cet article ici. Il n’y a rien de plus à faire qu’à regarder puisque nous n’avons pas encore implémenté les actions qui vont permettre d’avancer dans le jeu. Ce sera l’objet du prochain article.

Sortie de Boop! 0.4 à l’arrache

2019-11-16T20:15:00+01:00

Je me rends compte ce soir que cela fait un an que j’ai commencé mon générateur de sites statiques, Boop!. Comme je n’ai pas sorti de version depuis un petit moment, je fais donc ça maintenant, au pied levé.

Pour les personnes qui débarquent, il s’agit d’un projet totalement personnel, sans ambition aucune : je fais ça pour m’amuser.

Pour les personnes qui se posent la question : oui je continue de l’utiliser, et même de plus en plus. C’est notamment Boop! qui est utilisé pour mon blog « carnet de flus » ainsi que pour le site indiquant le statut de Flus. À chaque fois, cela m’a permis d’améliorer un peu plus le programme. Petit tour d’horizon des nouveautés.

Le truc qui aurait dû être dans la dernière version – je sais pas pourquoi je n’ai pas sorti une autre version d’ailleurs à l’époque – ce sont plus de variables accessibles dans les templates. J’avais notamment besoin d’afficher les séries sur la page du blog.

Tant qu’on est dans les templates, j’ai ajouté un nouveau mot clé (set) permettant d’assigner des variables. 6 lignes de codes en plus, c’est pas cher payé pour la prise de tête que je me suis ainsi évité.

J’ai également ajouté le support des articles privés (qui n’apparaissent ni dans les flux Atom, ni sur la page principale du blog). C’était fait en 5 lignes, je vois pas pourquoi je me serais privé (*ba-dum tss* 🥁).

Ensuite, la possibilité de modifier le « slug » de la page principale du blog permet notamment d’en faire une page d’accueil, comme sur « carnet de flus ». Cette fois-ci j’ai étonnamment enlevé plus de lignes de code que j’en ai ajoutées, ça fait plaisir.

J’ai activé l’extension Markdown qui permet d’ajouter la coloration syntaxique) dans les articles. J’en avais particulièrement besoin pour ma série « Ergogames, une histoire de pizzas ». Ça aurait été illisible sans ça.

Un truc qui m’aura pris un peu plus de temps (2h pour 50 lignes de code) mais me permet de rester serein, c’est l’ajout d’un système de cache pour les articles. Le site est désormais généré en 0,3 seconde au lieu de 2 secondes avant. 2s ça peut paraître peu, mais c’est énorme lorsque je relis un article et que je le régénère plusieurs fois par minute.

J’ajoute à cela des micro-trucs, comme :

le site qui est généré dans le répertoire ./_site au lieu de ./site (ça me permet de le distinguer très facilement des autres répertoires) ;
le fait de pouvoir forcer la génération d’un flux RSS même lorsqu’il n’y a pas encore d’article publié ;
l’affichage du temps de génération pour se rendre compte de si c’est trop long ou pas ;
ou encore le fait d’afficher les derniers articles écrits en toute fin de terminal (ce qui m’évite de devoir scroller vers le haut pour retrouver mon article en cours d’écriture au milieu de la liste).

Je parle de « micro-trucs » mais ce n’est vraiment pas des détails pour moi : c’est ce qui fait que je trouve mon expérience utilisateur bien au-dessus de celles que j’ai pu avoir avec d’autres générateurs de sites statiques. Par contre je parle bien de « mon » expérience : c’est totalement pensé par et pour moi. Déjà il va falloir que j’améliore grandement la documentation pour en faire un truc plus accessible à d’autres.

Tout ça pour dire que Boop! 0.4 est sortie, youpi ! 🎉

Une histoire de pizzas : coup de pinceau

2019-11-11T18:00:00+01:00

Vous aimez les pizzas ? Vous aimez les ratons laveurs ? Alors voici déjà le cinquième épisode de ma série d’articles retraçant la conception d’un mini-jeu vidéo !

Dans le deuxième article, on ne s’était pas trop embêté pour les graphismes : on avait fait de gros blocs de couleurs moches. Il est toutefois temps de corriger ça en passant un coup de peinture sur le jeu. Notre raton va bientôt ressembler à un raton !

Le premier ingrédient qu’il nous faut, c’est un graphiste ; et surprise, je ne le suis pas. Mes anciennes collègues de uxShadow ont fait appel à Goulven Barron pour réaliser les graphismes du jeu (merci à lui !), je n’avais ainsi plus qu’à les intégrer.

Pour cet article, je me suis donc contenté de récupérer des images du jeu d’origine et de les déposer dans un répertoire assets (qu’on peut traduire par « ressources » en bon françois).

Ensuite, il ne nous reste plus qu’à attacher chaque entité à une image et à l’afficher. Pour cela, on va tout simplement créer un nouveau composant au sein des entités (asset) qui contiendra l’URL vers l’image et ajouter cette dernière au HTML à l’aide d’une balise <img />.

<div id="app">
    <div class="board">
        <!-- ... -->

        <div
          v-for="entity in store"
          :key="entity.id"
          :class="['board-cell-entity', entity.id]"
          :style="entityPosition(entity)"
        >
            <!-- On affiche une image si l'entité possède un composant "asset" -->
            <img
                v-if="entity.asset"
                :src="entity.asset"
                alt=""
                class="entity-asset"
            />

            <!-- Sinon, on continue d'afficher le label -->
            <div v-else-if="entity.label" class="entity-label">
                {{ entity.label }}
            </div>
        </div>

        <!-- ... -->
    </div>
</div>

<script>
    // ...

    let gameStore = [
        // On se contente d'ajouter un composant "asset" à chacune de nos
        // entités. Il s’agit juste d'une URL vers une image.
        {
            id: 'meiko',
            asset: 'assets/meiko-face.svg',
            // ...
        },

        {
            id: 'mozza',
            asset: 'assets/pot-mozzarella.svg',
            // ...
        },
        {
            id: 'tomato',
            asset: 'assets/sauce-tomate.svg',
            // ...
        },
        {
            id: 'dough',
            asset: 'assets/pate-pizza-boule.png',
            // ...
        },

        {
            id: 'oven',
            asset: 'assets/four.svg',
            // ...
        },
        {
            id: 'hatch',
            asset: 'assets/passeplat.svg',
            // ...
        },
        {
            id: 'fridge',
            asset: 'assets/refrigirateur.svg',
            // ...
        },
        {
            id: 'workplan',
            asset: 'assets/plan-travail.svg',
            // ...
        },
        {
            id: 'shelf',
            asset: 'assets/etagere-horizontale.svg',
            // ...
        },
    ];

    // ...
</script>

<style type="text/css">
    /* ... */

    /*
        On vire quasiment tout le CSS concernant les entités (sauf les z-index)
        et on le remplace par... seulement ce max-width pour éviter que les
        images débordent des cases. Vous vous attendiez à plus de CSS ? :)
    */
    .board-cell-entity img {
        max-width: 100%;
    }

    /* Bon OK, on en ajoute un pour que la mozza ne déborde pas trop du frigo */
    .board-cell-entity.mozza img {
        max-width: 85%;
    }

    /* ... */
</style>

Et voilà, en seulement quelques lignes, on a largement transformé notre jeu. On est désormais visuellement très proches du jeu d’origine. Un petit détail toutefois reste à régler : on aimerait bien que Meiko se tourne dans la direction vers laquelle on vient de cliquer. Pour cela on va avoir besoin de 4 images représentant Meiko : une pour chaque direction. La question qui se pose est : « comment changer d’image ? »

Je vais aborder ici deux solutions possibles pour faire cela. Le choix que j’ai fait n’est pas forcément le meilleur, mais il sera justifié. Libre à vous de penser que c’est vraiment n’importe quoi et de préférer l’autre solution.

La première façon de faire est de regrouper toutes les images au sein d’un seul fichier : un « sprite » (ou lutin, c’est Wikipédia qui le dit, j’ai toujours entendu parler que de sprite). Ensuite, il faut afficher seulement une partie de l’image, en fonction d’une classe CSS par exemple. Je ne rentre pas dans le détail de l’implémentation, les méthodes sont de plus sensiblement différentes si vous avez un PNG ou un SVG. Cette technique me posait plusieurs problèmes :

générer un sprite est un poil plus pénible (soit on complique la tâche de la personne qui génère l’image, soit on complique la chaîne de build du projet)
je ne savais pas faire avec des SVG et n’avais pas envie de passer trop de temps là-dessus, ayant des choses plus intéressantes à développer par ailleurs (c’est important d’utiliser son temps à bon escient 😉)
je pensais que ça me poserait des problèmes de responsive design (problèmes grandement exagérés par le fait que je ne savais pas faire, tout est lié !)

Bref, je suis parti sur une seconde solution plus naïve, moins performante et moins élégante, mais qui me permettait au moins d’avancer sans me poser trop de questions.

La technique est simple. Chaque image se trouve dans un fichier à part, et on les rattache via un composant assets (notez le « s » final, c’est un autre composant !) qui va regrouper ces images, indexées par des directions. Lors de l’affichage, on va calculer dynamiquement l’image à afficher en fonction de la direction vers laquelle Meiko est dirigé. Ça ressemble à ça :

<div id="app">
    <div class="board">
        <!-- ... -->

        <div
          v-for="entity in store"
          :key="entity.id"
          :class="['board-cell-entity', entity.id]"
          :style="entityPosition(entity)"
        >
            <!-- On affiche une image si l'entité possède un composant "asset" -->
            <img
                v-if="entity.asset"
                :src="entity.asset"
                alt=""
                class="entity-asset"
            />

            <!--
                Ou bien un composant "assets", il faut alors calculer
                dynamiquement l'image à afficher.
            -->
            <img
                v-else-if="entity.assets"
                :src="entityAssetImage(entity)"
                alt=""
                class="entity-asset"
            />

            <!-- Sinon, on continue d'afficher le label -->
            <div v-else-if="entity.label" class="entity-label">
                {{ entity.label }}
            </div>
        </div>

        <!-- ... -->
    </div>
</div>

<script>
    // ...

    let gameStore = [
        {
            id: 'meiko',

            // Pour Meiko, on remplace le composant "asset" par "assets". Cela
            // nous permettra d'associer plusieurs images, la bonne sera
            // choisie dynamiquement lors de l'affichage.
            assets: {
                bottom: 'assets/meiko-face.svg',
                right: 'assets/meiko-droite.svg',
                left: 'assets/meiko-gauche.svg',
                top: 'assets/meiko-dos.svg',
            },

            // On ajoute également un composant "direction" à Meiko
            direction: 'bottom',

            // ...
        },

        // ...
    ];

    const app = new Vue({
        // ...

        methods: {
            // ...

            // Cette méthode JS calcule dynamiquement l'image à afficher pour
            // les entités possédant un composant "assets"
            entityAssetImage(entity) {
                if (entity.assets == null || entity.direction == null) {
                    return '';
                }

                // Comme le composant "assets" est indexé par les directions,
                // récupérer la bonne image se fait très facilement. Ce code
                // n’est pas très robuste mais comme le jeu est très simple
                // avec peu de contributeurices, on peut s’en contenter pour
                // l'instant.
                return entity.assets[entity.direction];
            },
        },
    });

    // ...
</script>

La dernière étape consiste à changer effectivement la direction de Meiko en fonction d’où le clic a été effectué. Vous l’aurez compris : on va modifier l’état du store, cela se passe donc au sein de notre système onClickSystem.

function onClickSystem(e, store) {
    // ...

    // Notre code doit s'exécuter avoir vérifié que Meiko peut accéder à la
    // case ciblée, sinon il ne doit pas bouger du tout.
    const meiko = getEntity(store, 'meiko');
    if (!positionIsAccessibleFor(meiko, position)) {
        return store;
    }

    // On veut désormais changer la direction de Meiko : il suffit de
    // comparer sa position à la position de la case ciblée pour savoir
    // vers où Meiko doit se tourner.
    let direction = meiko.direction;
    if (position.x > meiko.position.x) { direction = 'right'; }
    else if (position.x < meiko.position.x) { direction = 'left'; }
    else if (position.y < meiko.position.y) { direction = 'top'; }
    else if (position.y > meiko.position.y) { direction = 'bottom'; }

    let updatedStore = setEntityComponents(store, meiko.id, { direction });

    // On fait bien attention à utiliser le updatedStore à partir d’ici au
    // lieu du store sinon Meiko ne se tournera pas.
    const entitiesAtPosition = searchEntitiesAt(updatedStore, position);
    if (entitiesAtPosition.some((entity) => entity.obstruct)) {
        return updatedStore;
    }

    updatedStore = setEntityComponents(updatedStore, meiko.id, { position });

    return updatedStore;
}

Avec ça on a fini notre coup de peinture sur le jeu. D’ailleurs, on a même terminé de toucher au HTML concernant la zone de jeu elle-même : même pas 50 lignes de code. Vous remarquerez sans doute en testant le jeu (le résultat est ici) que Meiko ne change pas immédiatement de direction : il s’agit du temps de charger l’image la première fois. On corrigera ça plus tard dans un article bonus. Pour l’instant, on a quelque chose de bien plus important à faire : ajouter les étapes ainsi que les actions pour avancer dans le jeu. Ce sera l’objet des deux prochains articles (au moins !)

Une histoire de pizzas : contraindre les mouvements

2019-11-06T09:00:00+01:00

Bienvenue sur le déjà quatrième article retraçant le développement d’un mini-jeu web que j’ai développé pour les Ergogames. Les introductions se suivent et se ressemblent toutes alors commencez par lire les autres articles de la série avant d’aller plus loin si vous voulez comprendre quelque chose.

Bien, on a donc vu dans l’épisode précédent comment mouvoir le petit corps de Meiko. Le problème qui se posait alors est qu’il pouvait se déplacer n’importe où sur le terrain de jeu. Je vous propose donc de voir comment le forcer à se déplacer de case en case, sans monter sur le frigo ni l’étagère (c’est dangereux !!)

Pour ce faire, on touchera uniquement au JavaScript cette fois-ci : tout se passera dans notre système onClickSystem, celui qui prend un clic en entrée et modifie la position de Meiko. On commence par vérifier que le clic a bien été fait sur une case du jeu :

function onClickSystem(e, store) {
    e.preventDefault();

    const x = Math.ceil(e.layerX / CSS_CELL_SIZE) - 1;
    const y = Math.ceil(e.layerY / CSS_CELL_SIZE) - 1;

    const position = { x, y };

    // On vérifie que la position visée correspond bien à une case du jeu.
    // En théorie c'est toujours le cas (souvenez-vous la modification
    // faite en CSS dans l'article précédent), mais c'est bien de le
    // vérifier en JS aussi.
    if (
        position.x < 0 ||
        position.x >= BOARD_SIZE ||
        position.y < 0 ||
        position.y >= BOARD_SIZE
    ) {
        return store;
    }

    // ...
}

Si le clic est en dehors du terrain, on retourne le store tel quel, pas besoin de faire autre chose.

La seconde étape est de vérifier que Meiko a effectivement accès à la case sur laquelle on vient de cliquer. Il faut pour cela qu’il s’agisse d’une case adjacente. Avant de vous montrer le code, il me faut expliquer un peu comment calculer ça.

Pour une entité donnée, il existe un maximum de 4 cases accessibles (j’exclue la case sur laquelle se trouve l’entité, mais un autre choix peut être pertinent). Pour faciliter la représentation, prenez le tableau de 3x3 cases suivant (l’entité est représentée par e et les cases accessibles par les o) :

   0 1 2
0 | |o| |
1 |o|e|o|
2 | |o| |

Notre entité est donc en position x=1, y=1. Si l’on fait la différence de son abscisse avec n’importe quelle abscisse des cases accessibles, la valeur absolue est égale soit à 0, soit à 1 (1 - 0 = 1 ; 1 - 1 = 0 ; 1 - 2 = -1). Le résultat est le même pour les ordonnées, mais on remarque que lorsque la différence des abscisses est égale à 1, la différence des ordonnées est égale à 0 (et inversement). Le cas où les deux différences sont égales à 0 correspond à la case où se trouve l’entité, et les cas où les deux sont égales à 1 correspondent aux cases en diagonales.

Pour savoir si Meiko a le droit d’accéder à la case ciblée, il nous faut donc récupérer les deux positions, faire leur différence en valeur absolue en x et en y et vérifier que la somme fait 1.

function onClickSystem(e, store) {
    // ...

    // On récupère notre entité Meiko. On a besoin de connaître sa position
    // pour vérifier que la case visée est accessible.
    const meiko = getEntity(store, 'meiko');

    // On teste que la position est bien accessible à Meiko grâce à une
    // fonction utilitaire. Si elle ne l'est pas, on retourne le store tel
    // quel.
    if (!positionIsAccessibleFor(meiko, position)) {
        return store;
    }

    // ...
}

function getEntity(store, id) {
    // Ici c'est un bête appel à une fonction JS (find) pour trouver notre
    // entité dans le store (qui est un tableau). Le `|| null` permet de
    // retourner null au lieu de undefined, simple coquetterie de ma part.
    return store.find((entity) => entity.id === id) || null;
}

function positionIsAccessibleFor(entity, position) {
    // Si l'entité passée en paramètre n'a pas de position, elle va
    // forcément pas avoir accès à la position donnée puisqu'elle n'est pas
    // présente dans notre tableau !
    if (entity.position == null) {
        return false;
    }

    // On fait la différence (en valeur absolue) de nos abscisses...
    const diff_x = Math.abs(entity.position.x - position.x);
    // ... de nos ordonnées...
    const diff_y = Math.abs(entity.position.y - position.y);
    // ... et on vérifie que seulement l'une des 2 différences est égale
    // à 1. On aurait aussi pu écrire ça `diff_x + diff_y === 1`, mais je
    // trouve ça un peu moins clair.
    return (diff_x === 1 && diff_y === 0) || (diff_x === 0 && diff_y === 1);
}

Avec ça, Meiko arrête de voler à travers le terrain et est obligé de se déplacer sur une case adjacente. Il reste encore à régler sa manie de monter sur tous les objets de la cuisine. On va faire ça en deux temps.

La première chose à faire est d’ajouter un composant à nos entités stockées dans le store pour indiquer qu’elles ne peuvent pas être franchies. J’ai décidé de nommer celui-ci obstruct : si sa valeur est true, alors l’entité ne peut pas être franchie.

let gameStore = [
    // ...

    {
        id: 'meiko',
        label: 'Meiko',
        size: { width: 1, height: 1 },
        position: { x: 3, y: 2 },
        obstruct: true,
    },

    {
        id: 'oven',
        label: 'Four',
        size: { width: 2, height: 1 },
        position: { x: 1, y: 0 },
        obstruct: true,
    },
    {
        id: 'hatch',
        label: 'Passe-plat',
        size: { width: 1, height: 1 },
        position: { x: 5, y: 0 },
        obstruct: true,
    },
    {
        id: 'fridge',
        label: 'Frigo',
        size: { width: 2, height: 2 },
        position: { x: 0, y: 2 },
        obstruct: true,
    },
    {
        id: 'workplan',
        label: 'Plan de travail',
        size: { width: 1, height: 2 },
        position: { x: 5, y: 2 },
        obstruct: true,
    },
    {
        id: 'shelf',
        label: 'Étagère',
        size: { width: 4, height: 1 },
        position: { x: 2, y: 5 },
        obstruct: true,
    },
];

Ici j’ai déclaré le composant uniquement sur les gros objets ainsi que sur Meiko. Si par exemple la sauce tomate traîne au milieu de la cuisine, Meiko pourra passer au-dessus car je ne lui ai pas ajouté obstruct: true.

La deuxième étape est maintenant de récupérer les entités présentes sur la case visée et de vérifier qu’aucune n’est bloquante.

Avant de rentrer dans le code, une fois n’est pas coutume, on va décortiquer un peu ce qu’on veut faire. En théorie, trouver les entités présentes sur une case est facile : il suffit de sélectionner celles dont la position est égale à celle de la case (c’est-à-dire lorsque les valeurs x et y sont identiques). Mais vous avez sans doute remarqué que nos entités ont une taille qui n’est pas toujours de 1x1 case ? La position d’une entité correspond en fait à son angle haut-gauche. On a donc besoin de récupérer l’ensemble des positions occupées par notre entité, et vérifier qu’au moins une correspond à la case visée. Pour cela il faut faire un petit calcul. Prenons l’entité suivante qui occupe quatre cases :

   0 1
0 |e|e|
1 |e|e|

Sa position est x=0, y=0, sa largeur ainsi que sa hauteur sont de 2 chacune. On veut récupérer les cases suivantes à partir de ces deux informations : x=0, y=0, x=1, y=0, x=0, y=1 et x=1, y=1. Pour cela, il suffit d’itérer sur l’intervalle entre 0 et la largeur exclue (ici, « 2 exclu » est égal à 1) : chaque valeur prise est ajoutée au x de la position initiale et équivaut à une position prise par l’entité. On fait évidemment la même chose avec la hauteur et y.

Ce n’est pas très simple à expliquer avec des mots, donc voici le code de cette dernière partie :

function onClickSystem(e, store) {
    // ...

    // On récupère les entités présentes à la position donnée pour vérifier
    // qu'aucune n'est bloquante et empêche ainsi le déplacement.
    const entitiesAtPosition = searchEntitiesAt(store, position);

    // `some` retournera `true` si au moins une entité possède `obstruct` à
    // `true`.
    if (entitiesAtPosition.some((entity) => entity.obstruct)) {
        return store;
    }

    // Et enfin, on met à jour la position de Meiko dans le store. Le seul
    // changement par rapport à la dernière fois est qu'on utilise
    // `meiko.id` au lieu de `'meiko'`.
    let updatedStore = setEntityComponents(store, meiko.id, { position });

    return updatedStore;
}

function searchEntitiesAt(store, position) {
    // On filtre ici les entités présentes à la position donnée en
    // argument. La difficulté réside dans le fait qu'une entité à une
    // taille et peut donc être présente sur plusieurs positions à la fois.
    return store.filter((entity) => {
        if (entity.position == null) {
            // Pas de position, pas de chocolat
            return false;
        }

        if (entity.size == null) {
            // si l'entité n'a pas de taille, on considère quand même
            // qu'elle a une présence de 1x1. On a juste à tester que les
            // positions sont égales. En pratique dans ce jeu, ce cas de
            // figure ne se présente pas.
            return (
                entity.position.x === position.x &&
                entity.position.y === position.y
            );
        }

        // getCoveredPositionsBy retourne l'ensemble des positions que
        // l'entité occupe, on vérifie juste que l'une de ces positions
        // correspond à la position recherchée.
        return getCoveredPositionsBy(entity).some((coveredPosition) => (
            coveredPosition.x === position.x &&
            coveredPosition.y === position.y
        ));
    });
}

function getCoveredPositionsBy(entity) {
    // Ici on collectionne les ~canards~ les positions prises par l’entité.
    const coveredPositions = [];

    // On itère sur l'intervalle entre 0 et la largeur exclue (ouais bon,
    // le code JS est pas hyper accueillant)
    for (const w of Array(entity.size.width).keys()) {
        // Puis sur l'intervalle entre 0 et la hauteur exclue
        for (const h of Array(entity.size.height).keys()) {
            // On a plus qu’à additionner les valeurs à x et y pour obtenir
            // une position occupée par l'entité
            coveredPositions.push({
                x: entity.position.x + w,
                y: entity.position.y + h,
            });
        }
    }
    return coveredPositions;
}

Et voilà ! Vous pouvez tester (le résultat final est ici), Meiko ne peut plus monter sur le frigo, ni sur le plan de travail. Si vous décidez de tripatouiller un peu le code, vous pourrez vérifier que Meiko peut cependant allègrement marcher sur la Mozzarella si on la laisse trainer au milieu de la cuisine (ce n’est pas le cas dans le jeu initial, mais ça me permettait de mieux illustrer l’utilité des composants).

Bien qu’il n’y ait pas eu « beaucoup » de code dans cet article, celui-ci était sans doute assez dense pour la compréhension. Le prochain devrait traiter d’un aspect un peu plus sympa : l’ajout des images. On pourra ainsi se débarrasser de nos blocs moches dessinés à l’arrache.

Une histoire de pizzas : les déplacements

2019-11-01T20:30:00+01:00

Je suis en forme alors voici le troisième article qui relate le développement du jeu que j’ai conçu pour les Ergogames. On a déjà vu comment afficher la grille et comment gérer les objets, nous allons aujourd’hui voir comment déplacer notre personnage, Meiko.

Je vous invite très fortement à lire les autres articles si ce n’est pas déjà fait, vous risquez autrement de ne rien piger à celui-ci.

Le but ici est de pouvoir viser une case avec la souris et de déplacer Meiko en cliquant. Là encore, on a tout un tas de solutions possibles. Ma première approche a été de vouloir rendre les entités « cliquables », mais comme on veut potentiellement cliquer sur des cellules sans entité, j’étais bloqué.

Ma seconde approche a été de faire en sorte de pouvoir cliquer sur les .board-cell qui représentent les cellules de notre tableau (ce sont celles du premier article). Le problème ici est que les entités survolent les cellules et risquent de récupérer l’action du « clic » sans le propager aux cases en dessous, pas cool. Alors on pourrait vouloir rendre tout ce petit monde « cliquable », mais ça deviendrait galère à gérer parce que les clics ne portent plus sur les mêmes types d’objets et il faudrait les distinguer.

Bref, j’ai choisi une solution qui me semble plutôt élégante : j’ai posé un lien unique (balise <a />) par-dessus la zone de jeu, puis j’ai déterminé en JavaScript la case sur laquelle porte le clic.

<div class="board">
    <!-- ... -->

    <!--
        On ajoute un lien qui recouvre l’ensemble de la zone de jeu et qui
        va récupérer les clics du ou de la joueuse pour ensuite modifier
        l’état du jeu.
    -->
    <a href="#" @click="onBoardClick" class="board-click-zone"></a>
</div>

<script>
    // ...

    const app = new Vue({
        // ...

        methods: {
            // ...

            onBoardClick(e) {
                // C'est ici qu'on connecte le tout : onBoardClick est appelé
                // quand on clique sur le lien .board-click-zone. On passe
                // l'évènement généré à un "système" qui va modifier le store
                // (ou non) en conséquence. Le store retourné est réassigné à
                // notre objet VueJS, ce qui va entrainer un rafraichissement
                // du HTML si besoin. Magique.
                this.store = onClickSystem(e, this.store);
            },
        },
    });

    // Notre premier "vrai" système. C'est une fonction qui prend un store
    // en entrée et en retourne un en sortie (modifié... ou non).
    // L'évènement qui est également passé en argument permet de déterminer
    // quelle zone du jeu a été "activée" par le ou la joueuse.
    function onClickSystem(e, store) {
        // On fait en sorte que le clic ne soit pas actionné (sinon l'écran va
        // remonter en haut de l'écran et ce sera pas agréable)
        e.preventDefault();

        // e.layerX et e.layerY donnent la position en pixels de là où l’on a
        // cliqué. Il suffit de diviser cette valeur par la taille d’une
        // cellule et d'arrondir le résultat pour savoir sur quelle cellule on
        // a cliqué... enfin presque, on retranche encore "1" parce que notre
        // tableau commence à l'indice "0".
        // Exemple : si la cellule à l’indice 0 fait 10px et que l’on clique
        // sur le pixel "10", le calcul 10/10 est égal à 1 ; il faut donc
        // retrancher encore 1 pour retrouver notre indice "0".
        // Et si vous avez rien compris c'est pas dramatique, en plus j'ai pas
        // fait comme ça dans le jeu de base :)
        const x = Math.ceil(e.layerX / CSS_CELL_SIZE) - 1;
        const y = Math.ceil(e.layerY / CSS_CELL_SIZE) - 1;

        // On change la position de Meiko pour correspondre à l'endroit visé
        store.meiko.position = { x, y };

        // Et on retourne le store ainsi modifié
        return store;
    }
</script>

<style type="text/css">
    /* ... */

    .board {
        position: relative;
        /*
           On limite la largeur du tableau pour ne pas pouvoir cliquer en
           dehors de la zone de jeu. Ça aurait pu être fait plus tôt mais on
           s’en fichait un peu puisque ça ne posait pas encore de problème.
        */
        width: calc(6 * var(--cell-size));
    }

    /*
       Rien de compliqué : .board-click-zone est positionné relativement à
       .board et le recouvre totalement, c'est donc bien lui qui va récupérer
       tous les clics. Oh, et on n'oublie pas le z-index pour nous assurer que
       ça passera par-dessus les entités.
    */
    .board-click-zone {
        position: absolute;
        top: 0;
        bottom: 0;
        right: 0;
        left: 0;
        z-index: 100;
    }

    /* ... */

    /* On s'assure que Meiko est toujours visible au-dessus des autres entités. */
    .board-cell-entity.meiko {
        z-index: 20;

        background-color: #fff;
        border: 2px solid green;
    }
</style>

Avec ça, on pourrait être content puisque Meiko peut désormais se déplacer, et cela avec peu de nouveau code. C’est sans compter un petit détail que les personnes connaissant VueJS ou autres bibliothèques de ce type auront peut-être remarquées : le store est un Object que l’on passe par référence à onClickSystem (enfin presque, je rentre pas dans les détails). La conséquence est que lorsqu’on modifie sa valeur, le store initial (stocké dans data) est également modifié et l’assignation dans onBoardClick n’a absolument aucun impact puisqu’on se contente de lui réassigner le même Object. Une manière de mieux comprendre est de modifier cette méthode :

onBoardClick(e) {
    const newStore = onClickSystem(e, this.store);
    console.log({
        oldPosition: this.store.meiko.position,
        newPosition: newStore.meiko.position,
    });
},

Ici j’ai logué la position de Meiko depuis le store initial ainsi que celle du nouveau store. J’ai également enlevé l’assignation à this.store. Si vous regardez le résultat dans une console, vous remarquerez toutefois que les deux valeurs sont identiques et que Meiko se déplace quand même : l’assignation n’avait donc bien aucun intérêt ! Ici il faut comprendre que VueJS ne devrait pas être capable de détecter un changement dans le store et donc d’actualiser la vue ; ce qu’il fait pourtant. La réponse à cette bizarrerie est donnée dans la documentation de VueJS qui nous explique que la valeur de l’objet data est gérée d’une manière un peu spéciale, permettant de surveiller les changements et donc de « réagir » à ceux-ci. C’est pratique, mais c’est accompagné d’avertissements importants concernant l’ajout ou la suppression de données dans cet objet qui ne sont pas, eux, détectés à moins d’utiliser des méthodes particulières. On peut illustrer cela en changeant légèrement le code de onClickSystem :

function onClickSystem(e, store) {
    e.preventDefault();

    // Ici on ne change plus la position de Meiko mais on tente de la supprimer
    delete store.meiko.position;

    return store;
}

Si vous tentez de voir ce que cela donne, vous verrez que Meiko ne bougera pas. Le résultat attendu est toutefois qu’il disparaisse car la méthode entityPosition est censée retourner un objet vide pour les entités ne possèdant pas de position (voir le deuxième article pour comprendre). Ici, VueJS n’a tout simplement pas détecté qu’il y avait eu un changement dans le store. La bonne manière de faire serait en fait de remplacer la ligne du delete par :

Vue.delete(store.meiko, 'position');

Ça marche, mais ce n’est finalement pas vraiment ce que je souhaite. En effet, ici les modifications dans le store vont être directement (ou presque) prises en compte par VueJS qui va impacter cela dans la vue. J’aimerais pour ma part pouvoir faire celles-ci par « lots » et assigner le nouveau store dans onBoardClick, comme je l’ai fait dans mon code. Mon idée est également de ne pas avoir d’effet de bord à l’intérieur de mon système. Celui-ci doit prendre un store en entrée, puis en retourner un en sortie sans toucher au premier. Cela facilite à mon sens la compréhension du code et l’écriture de tests.

Pour réaliser cela il faut dupliquer le store, mais c’est un peu pénible avec un Object JavaScript (c’était en tout cas mon avis à l’époque, mais je réalise maintenant que j’ai totalement surestimé la complexité, je reviens là-dessus en fin d’article). J’ai à ce moment-là pris la décision de revoir le format de données de mon store en le transformant en un Array, que j’aurai plus de facilité à manipuler. Cela demande toutefois quelques adaptations et il vaut mieux le faire dès maintenant alors que l’on a peu de code :

<div class="board">
    <!-- ... -->

    <!--
        Dans le template HTML, on change l'appel à `id` qui a été déplacé
        au sein des entités
    -->
    <div
      v-for="entity in store"
      :key="entity.id"
      :class="['board-cell-entity', entity.id]"
      :style="entityPosition(entity)"
    >
        <div v-if="entity.label" class="entity-label">
            {{ entity.label }}
        </div>
    </div>

    <!-- ... -->
</div>

<script>
    // On revoit la structure de données du store en le transformant en un
    // Array pour faciliter la manipulation des données.
    // Les anciennes clés qui servaient à identifier les entités sont déplacées
    // au sein des entités.
    let gameStore = [
        {
            id: 'meiko',
            label: 'Meiko',
            size: { width: 1, height: 1 },
            position: { x: 3, y: 2 },
        },

        {
            id: 'mozza',
            label: 'Mozzarella',
            size: { width: 1, height: 1 },
            position: { x: 1, y: 3 },
        },
        {
            id: 'tomato',
            label: 'Sauce tomate',
            size: { width: 1, height: 1 },
            position: { x: 2, y: 5 },
        },
        {
            id: 'dough',
            label: 'Pâte à pizza',
            size: { width: 1, height: 1 },
            position: { x: 5, y: 3 },
        },

        // etc.
    ];

    // ...
</script>

Ce changement est relativement indolore et a finalement assez peu d’impact (si ce n’est sur la rapidité d’exécution de certaines instructions). Par contre Meiko ne peut malheureusement plus bouger ! On va devoir faire une dernière adaptation au code :

function onClickSystem(e, store) {
    e.preventDefault();

    const x = Math.ceil(e.layerX / CSS_CELL_SIZE) - 1;
    const y = Math.ceil(e.layerY / CSS_CELL_SIZE) - 1;

    // On change la position de Meiko pour correspondre à l'endroit visé à
    // l'aide de la fonction écrite juste en dessous.
    const position = { x, y };
    let updatedStore = setEntityComponents(store, 'meiko', { position });

    // Et on retourne le store modifié
    return updatedStore;
}

// Cette fonction permet de modifier les composants d'une entité présente
// au sein d'un store, sans modifier ce dernier directement : un nouveau
// store est en fait retourné.
function setEntityComponents(store, id, components) {
    return store.map((entity) => {
        if (entity.id !== id) {
            return entity;
        }
        // Je ne rentre par contre pas dans le détail de la syntaxe
        // JavaScript...
        return {
            ...entity,
            ...components,
        };
    });
}

Et voilà, avec ça Meiko a désormais la possibilité de se déplacer en toute liberté dans sa cuisine. Et pour le coup il en a un peu trop puisqu’il est capable de passer d’un coin à un autre en un seul clic. Il peut également passer au-dessus des gros objets tels que le frigo, ce qui ne devrait pas être autorisé. J’avais imaginé traiter de ce sujet dans cet article, mais je me rends compte qu’il est déjà bien assez complet comme ça alors j’expliquerai comment contraindre les mouvements de notre personnage dans un prochain article !

Le code final de cet article est accessible ici (la console est toujours ton amie).

Pour terminer, je voulais revenir sur mon choix de changer de structure de données pour représenter mon store. Comme je l’ai précisé entre parenthèses, je réalise aujourd’hui que mon choix était insuffisamment justifié et j’aurais pu continuer avec un Object plutôt qu’un Array. L’impact immédiat est la complexité du code : pour accéder à mon entité meiko, je dois désormais parcourir les éléments de mon tableau un par un (complexité en O(n)), alors que je pouvais le récupérer directement avec un Object indexé par les identifiants des entités (complexité en O(1)). Ce changement est toutefois assez peu couteux dans ce jeu car nous aurons peu d’entités à manipuler (bien que nous en rajouterons plus tard).

J’ai décidé de conserver ce changement dans mon article pour trois raisons. La première est très basique : je reste proche de mon code initial. La seconde est d’illustrer que l’on ne fait pas toujours les bons choix d’implémentation du premier coup (surtout quand on tâtonne) et qu’il est pertinent de prendre du recul sur ce qu’on est en train de faire. C’est OK de revoir une structure de données, mais attention aux impacts que cela a sur le code ! Une suite de tests aurait pu être pertinente ici pour valider que nous n’avons pas de régressions dans les fonctionnalités.

Ma dernière raison est plus discutable : l’utilisation d’un Array permet de complexifier l’accès et la modification des entités, encourageant par la même occasion l’utilisation des fonctions utilitaires (ici, setEntityComponents). Je trouve cela utile car, comme on l’a vu, il faut absolument éviter d’ajouter ou supprimer un composant « à la main » dans les entités (au risque que VueJS ne détecte pas le changement). Un ou une nouvelle développeur·euse n’aura pas forcément conscience de cette particularité et perdra du temps à tenter de comprendre pourquoi son code ne marche pas. En lui empêchant certaines facilités, on l’encourage à découvrir comment ont fait les autres et on la pousse ainsi à utiliser les fonctions qui lui assure de le faire « correctement ». C’est une sorte d’ergonomie pensée à travers la complexité, je ne sais pas si ça a été théorisé mais c’est plutôt à-propos ! 😄

Une histoire de pizzas : les objets

2019-10-28T17:30:00+01:00

J’ai commencé la semaine dernière une série d’articles pour expliquer comment j’ai développé un jeu pour les Ergogames. Il me semble qu’il n’y a rien d’exceptionnel dans ce que j’explique, je vise plutôt un public amateur qui chercherait à comprendre comment fonctionne un jeu. Mon but est aussi de montrer ma démarche alors que je n’y connaissais rien au développement de jeux vidéos (enfin « presque rien », j’y reviens plus loin).

Dans l’article précédent nous avons commencé par afficher une grille de 6 par 6 cases. Nous allons maintenant afficher les éléments du jeu (le frigo, le four, Meiko, etc.) Ces éléments vont interagir entre eux, il faut donc les représenter dans notre code JavaScript pour gérer ces aspects « dynamiques » et l’« état » du jeu. Cette représentation est importante et ne doit pas être prise à la légère puisqu’elle va impliquer notre capacité à ajouter de nouvelles fonctionnalités au jeu.

C’est le moment où je révèle que j’ai légèrement triché dans mon précédent article quand je disais que je n’y connaissais rien : je m’étais déjà un peu amusé par le passé avec quelques concepts, et notamment l’architecture « entité-composant-système ». J’avais découvert ce paradigme dans une série d’articles sur LinuxFR et j’avais même commencé à développé une bibliothèque Python, Pytity.

Le principe est assez simple :

les entités représentent les objets du jeu (ex. un frigo) mais ne possèdent pas de données ; on représente une entité par un identifiant
à ces entités, on associe des composants qui représentent l’état de l’entité (ex. une couleur, une position) ; il s’agit d’un ensemble de données
les systèmes contiennent le code pour interagir avec notre tas de données comme, par exemple, pour afficher les entités, écouter les actions du joueur ou modifier les composants

Alors comment on s’y prend pour représenter tout ça ? Ici on va faire simple et même légèrement différent de ce que j’ai fait pour les Ergogames afin d’être plus lisible. Il n’existe de toute façon pas de manière unique pour représenter une architecture « entité-composant-système ».

Commençons par lister les différents objets de notre jeu à l’état initial, nous en avons 9 :

// L'ensemble de nos entités avec leurs composants est stocké dans un gros
// objet JavaScript.
let gameStore = {
    // L'identifiant de l'entité est une clé (meiko) de l'objet JS. On lui
    // associe un ensemble de composants (label, size et position)
    meiko: {
        label: 'Meiko',
        size: { width: 1, height: 1 },
        position: { x: 3, y: 2 },
    },

    // Et on fait la même chose avec toutes les entités de notre jeu
    mozza: {
        label: 'Mozzarella',
        size: { width: 1, height: 1 },
        position: { x: 1, y: 3 },
    },
    tomato: {
        label: 'Sauce tomate',
        size: { width: 1, height: 1 },
        position: { x: 2, y: 5 },
    },
    dough: {
        label: 'Pâte à pizza',
        size: { width: 1, height: 1 },
        position: { x: 5, y: 3 },
    },

    oven: {
        label: 'Four',
        size: { width: 2, height: 1 },
        position: { x: 1, y: 0 },
    },
    hatch: {
        label: 'Passe-plat',
        size: { width: 1, height: 1 },
        position: { x: 5, y: 0 },
    },
    fridge: {
        label: 'Frigo',
        size: { width: 2, height: 2 },
        position: { x: 0, y: 2 },
    },
    workplan: {
        label: 'Plan de travail',
        size: { width: 1, height: 2 },
        position: { x: 5, y: 2 },
    },
    shelf: {
        label: 'Étagère',
        size: { width: 4, height: 1 },
        position: { x: 2, y: 5 },
    },
};

const app = new Vue({
    el: '#app',
    data: {
        size: BOARD_SIZE,
        // on ajoute le store à "data" pour pouvoir y accéder dans le html
        store: gameStore,
    },
});

Ceci étant fait, nous pouvons créer notre premier « système » : celui qui va afficher les objets. Dans notre cas, le rendu est géré par le navigateur ce qui nous simplifie grandement la vie par rapport à un jeu « natif ». Ça n’a d’ailleurs pas grand-chose à voir à mon avis et je ne sais pas si on peut vraiment parler de « système ». On va se contenter ici d’écrire un peu de HTML et de JS (pour positionner les entités au bon endroit) :

<div class="board">
    <!-- Ça, ça ne change pas -->
    <div v-for="y in size" :key="y" class="board-line">
        <div v-for="x in size" :key="x" class="board-cell">
        </div>
    </div>

    <!--
        On itère sur les entités (objets) du store pour les ajouter dans le
        HTML. Le truc important ici est la fonction "entityPosition" qui va
        retourner les dimensions et la position en CSS de l'entité pour que
        le navigateur l'affiche au bon endroit.
    -->
    <div
      v-for="(entity, id) in store"
      :key="id"
      :class="['board-cell-entity', id]"
      :style="entityPosition(entity)"
    >
        <!-- Si l'entité a un composant "label", on l’ajoute au HTML. -->
        <div v-if="entity.label" class="entity-label">
            {{ entity.label }}
        </div>
    </div>
</div>

<script>
    // ...

    // Cette valeur correspond à la variable --cell-size en CSS.
    const CSS_CELL_SIZE = 128;

    const app = new Vue({
        // ...

        methods: {
            // entityPosition retourne la position de l'entité en CSS.
            entityPosition(entity) {
                if (entity.size == null || entity.position == null) {
                    // Si l'entité ne possède pas de taille ou de position,
                    // cela signifie qu'on ne peut pas l'afficher : on ne
                    // retourne donc rien.
                    return {};
                }

                return {
                    // on multiplie la taille de l'entité par la taille d'une
                    // cellule pour obtenir sa taille en CSS.
                    width: (entity.size.width * CSS_CELL_SIZE) + 'px',
                    height: (entity.size.height * CSS_CELL_SIZE) + 'px',

                    // et pareil pour obtenir sa position
                    top: (entity.position.y * CSS_CELL_SIZE) + 'px',
                    left: (entity.position.x * CSS_CELL_SIZE) + 'px',
                };
            },
        },
    });
</script>

Une solution plus élégante serait de ne générer le HTML que pour les entités avec une taille et une position : en effet, quel intérêt y a-t-il à ajouter une entité qui n’a pas d’existence visuelle ? J’ai choisi cette façon de faire afin de garder le code plus simple et parce que je n’avais pas pensé à cela initialement (je reste ainsi plus proche de ce que j’ai fait initialement).

Vous noterez aussi que je ne tente pas de placer les entités dans les cellules du tableau que l’on a généré lors de l’étape précédente. En effet, une entité peut se trouver dans plusieurs cellules en même temps et ce serait galère à gérer correctement en termes de HTML. Je préfère donc dissocier les entités des cellules et les superposer. Ça n’a pas beaucoup d’importance ici puisqu’il s’agit uniquement de rendu visuel.

À ce niveau on est pas mal, mais ça reste toujours moche et on ne voit pas grand-chose. On va donc ajouter du CSS pour rendre nos entités correctement.

/* ... */

/*
   Ça c'est important pour pas se prendre la tête sur les dimensions mais
   je ne rentre pas dans le détail du pourquoi du comment.
*/
* {
    box-sizing: border-box;
}

/*
   Les entités ont une position absolue *au sein* du tableau, donc on
   précise le nécessaire pour éviter qu'elles ne volent n'importe où à
   l'écran, et surtout pas en dehors du cadre de jeu.
*/
.board {
    position: relative;
}
.board-cell-entity {
    position: absolute;
}

/* Puis on colorie nos entités pour les rendre plus visibles à l'écran */
.board-cell-entity.oven { background-color: #333; }
.board-cell-entity.fridge { background-color: #666; }
.board-cell-entity.workplan { background-color: #783f04; }
.board-cell-entity.shelf { background-color: #000; }
.board-cell-entity.hatch { background-color: #cf2a27; }

.board-cell-entity .entity-label { color: #fff; }
.board-cell-entity.shelf .entity-label { text-align: right; }

/*
   Certaines entités peuvent être superposées à d'autres (la pâte, la mozza
   et la sauce tomate). On leur met un z-index pour être sûr qu'elles se
   trouveront au-dessus.
*/
.board-cell-entity.dough,
.board-cell-entity.mozza,
.board-cell-entity.tomato {
    z-index: 10;

    background-color: green;
}

/*
   Meiko a droit à un style un peu différent mais ça change pas grand-chose
   à la logique : on le colorie aussi !
*/
.board-cell-entity.meiko {
    border: 2px solid green;
}
.board-cell-entity.meiko .entity-label {
    color: initial;
}

Notez ici que la majorité du code CSS n’est pas très important puisqu’on remplacera nos blocs colorés par des images plus tard.

On arrive toutefois à la fin de cet article puisqu’on a vu comment représenter les objets du jeu et comment les afficher. Le résultat final est visible ici et, comme la dernière fois, n’hésitez pas à regarder le code source de la page.

Nous verrons dans le prochain article comment déplacer Meiko de case en case tout en faisant attention à ce qu’il ne puisse pas traverser les objets tel que le frigo.

Une histoire de pizzas : la grille

2019-10-24T13:30:00+02:00

En début d’année, j’ai passé du temps à développer un mini-jeu pour les Ergogames. Le principe des Ergogames est simple : faire découvrir des principes d’ergonomie à travers des jeux qui illustrent différents concepts. Ceux-ci sont conçus par deux anciennes collègues ergonomes, Marion et Margaux, via l’agence de design uxShadow de Sogilis (mon ancienne boite).

Elles m’ont demandé si je pouvais leur donner un coup de main et j’ai accepté à condition que le code soit ouvert (ça se passe ici 😊).

J’ai donc développé le mini-jeu « À vous les pizzas ! » en précisant bien que je n’avais jamais conçu de jeux mais que c’est pas grave, « je vais apprendre ». Du coup j’ai effectivement appris, et c’est ce cheminement que j’aimerais partager maintenant à travers une série d’articles. Je préviens tout de suite : je n’ai aucune idée de si je finirai cette série, mais enfin, je l’aurai au moins commencée. Si vous cherchez le code du jeu en lui-même, il se trouve ici.

Le but de la série va être de redévelopper le jeu pas à pas. Je n’irai pas aussi loin que celui des Ergogames pour me simplifier la vie, mais nous verrons quand même les principaux mécanismes. Le principe du jeu est de déplacer un personnage (Meiko) dans une cuisine en cliquant de case en case pour lui faire fabriquer une pizza. Je vous laisse jouer au jeu sur le site des Ergogames pour découvrir le principe d’ergonomie qui est illustré ici. Le résultat ressemble à cela :

Le jeu sera développé en HTML, CSS et JavaScript avec la librairie VueJS afin de rester le plus proche possible de ce qui a été fait initialement. J’éviterai tout de même toute étape de build qui consisterait à transformer le code JS en un seul fichier optimisé : c’est ce qui est fait pour les Ergogames mais ça complexifierait la compréhension sans rien apporter de plus. Je vais également m’éviter quelques bonnes pratiques en mixant allègrement tout le code (HTML, JS et CSS) au sein d’un même fichier (ne faites pas ça chez vous).

Dans ce premier article qui servait essentiellement à introduire la série, on va se contenter d’afficher un cadre de 6 par 6 cases. Comme je l’ai dit plus haut, je n’avais encore jamais développé de jeu, donc j’ai avancé de manière très naïve. Il me semblait évident que la première phase consisterait à dessiner le tableau de jeu.

Cela permet en plus d’introduire à la fois un peu de HTML, de CSS et de JS et donc de poser les bases. Pour représenter le cadre, on va se contenter de 6 balises <div> pour les lignes, découpées elles-mêmes en 6 autres balises <div> pour les cellules. On va s’éviter tout de suite de copier-coller plein de code HTML et on va donc ajouter VueJS immédiatement et répéter ces blocs avec des boucles v-for. Ça donne quelque chose que j’espère simple :

<div id="app">
    <div class="board">
        <!--
            la variable size est passée par VueJS et a pour valeur 6. On répète
            donc 6 fois la div "board-line", au sein desquelles on répète 6
            fois la div "board-cell".
        -->
        <div v-for="y in size" :key="y" class="board-line">
            <div v-for="x in size" :key="x" class="board-cell">
            </div>
        </div>
    </div>
</div>

<!--
    J’ajoute la librairie VueJS via un CDN, mais dans la vraie vie préférez
    héberger le code vous-même, c’est meilleur pour la vie privée de vos
    visiteurs et visiteuses.
-->
<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>

<script>
    const BOARD_SIZE = 6;

    // Un tout petit peu de JS pour dire à VueJS de "monter" l'application sur
    // la balise possédant l'id #app et passer la variable size. Je ne rentre
    // pas dans le détail ici, ce n’est pas très important.
    const app = new Vue({
        el: '#app',
        data: {
            size: BOARD_SIZE,
        },
    });
</script>

Avec ça, on a la base de notre code HTML, par contre ça ne ressemble à rien. On va donc ajouter un zeste de CSS pour rendre le tout visuel :

/*
    Ici on définit quelques variables CSS, c'est pas forcé mais ça aidera à
    la maintenance du code.
*/
#app {
    --cell-size: 128px;

    --color-floor: #fff;
    --color-floor-border: #ccc;
}

/*
    Une ligne est un conteneur flex, ça permet de se simplifier la vie pour
    aligner les cellules. La conséquence ici est que les .board-cell seront
    affichées en lignes et non pas en colonnes.
*/
.board-line {
    display: flex;
}

/*
    Puis on définit la taille des cellules ainsi qu’une couleur de fond et
    de bordure pour les mettre en évidence.
*/
.board-cell {
    width: var(--cell-size);
    height: var(--cell-size);

    background-color: var(--color-floor);
    border: 1px solid var(--color-floor-border);
}

Avec ça on a un cadre que l’on va pouvoir améliorer par petites touches pour arriver au jeu final. Le résultat final est visible ici (n’hésitez pas à ouvrir la console de votre navigateur pour regarder le code).

J’ai essayé ici de détailler au mieux ce que je faisais pour faciliter la compréhension du code afin de rendre ma série d’articles accessible au plus de monde possible, en particulier aux débutant·es. N’hésitez pas à me contacter si des choses ne sont pas claires !

Le prochain article explique comment afficher les éléments dans le jeu.

Bretagne, le retour

2019-10-21T11:50:00+02:00

Je suis rentré de Bretagne un peu plus tôt que prévu. J’ai finalement beaucoup moins randonné que ce que je voulais, mais j’ai dû me rendre à l’évidence de trois choses :

la santé physique, ça se soigne ;
un budget, ça explose vite ;
marcher seul, c’est long.

C’était néanmoins une chouette balade entre le Mont-Saint-Michel et Saint-Brieuc, de superbes paysages (et des moins bien aussi, mais peu 😉), quelques rencontres qui font plaisir (en particulier un groupe de quatre que j’ai suivi presque tout du long), et des bonnes galettes. Je remercie également Hervé de m’avoir montré Brest, ainsi que Thomas et Aline pour l’hébergement et les croissants !

Une chose m’a surpris : la Bretagne, c’est pas plat du tout ! Ça monte et ça descend sans cesse, avec des marches (j’en ai compté 106 à Saint-Cast-le-Guildo en fin de journée pour atteindre l’hôtel, pas cool) ou sans. J’avais clairement mal anticipé ça et mes tendons d’Achille ont souffert plusieurs jours de suite (d’où le fait de m’arrêter pour éviter de me blesser).

La période à laquelle j’y suis allé n’était pas idéale, les établissements commencent à fermer et il était parfois compliqué de se loger. Au pire ça aurait été camping sauvage dans un coin, mais je voulais éviter. Je viserai la prochaine fois la première quinzaine de septembre (des contraintes m’en ont empêché cette fois-ci).

À propos de la météo (comme la question revient souvent), j’ai eu droit à quelques bonnes averses, mais je n’ai réellement fini trempé que deux fois. J’étais équipé de vêtements qui sèchent rapidement donc, en général, le simple fait de marcher suffisait pour redevenir sec (le vent aidant bien). J’ai quand même eu du très beau temps la majorité du voyage, me permettant d’être en t-shirt.

Je me suis amélioré dans la préparation de mon sac par rapport à mes voyages précédents. Bien qu’étant parti avec un sac d’environ 14 kg, j’aurais pu gagner en m’évitant le matériel de camping (3 kg au total dont j’ai eu peu besoin) et en emportant moins de nourriture au départ. Concernant ce deuxième point, il est possible soit de manger au resto, soit de se ravitailler dans des supérettes à intervalle régulier (ce n’est pas un problème sur ce chemin de randonnée). J’ai calculé, je pense pouvoir viser un sac de 9 kg aisément, voire encore moins si je veux vraiment voyager léger.

Pour finir, j’aimerais bien retourner en Bretagne pour finir ce que je n’ai pas fait et visiter d’autres coins. En revanche je ferai en sorte de ne pas voyager seul et de mieux me préparer physiquement avant de partir. Et si vous étiez là pour les photos : je n’en ai pas prises, désolé !

Gagner ma vie : FreshRSS ou Lessy ?

2019-09-19T18:30:00+02:00

Lorsque j’ai décidé de monter un service pour essayer de gagner ma vie, j’étais parti dans l’idée de le faire avec Lessy (un gestionnaire pour aider à gérer son temps). Les avantages étaient nombreux :

une demande qui me semble plus importante ;
des technologies que je connais mieux ;
une base de code plus récente avec moins de dette technique ;
un projet dont la gouvernance est super simple vu que je suis le seul à travailler (ahem…) dessus ;
et j’en oublie sans doute.

Toutefois, en y réfléchissant un peu, je me suis dit que le but de Lessy était d’avoir à l’utiliser le moins possible, voire d’être capable de s’en passer totalement dans une démarche de réappropriation de son temps. Il me semblait du coup malhonnête de générer de l’argent avec puisque cela impliquait nécessairement de tenter de capter l’attention des gens (à minima pour les faire venir sur le service, idéalement pour m’assurer qu’ils l’utilisent effectivement).

À l’inverse il me semble que FreshRSS, étant un outil de veille, s’intègre plutôt bien dans une activité quotidienne. Je suis moins gêné par le fait que les personnes utilisant le service payent pour l’utiliser quotidiennement puisque c’est dans sa nature. Je crois également qu’un outil de veille s’attaque à un problème plus ambitieux : l’information nous est aujourd’hui pré-digérée principalement à travers des plateformes centralisées et propriétaires, donc de manière plus ou moins uniforme, en tout cas opaque. Il est pour moi plus que temps que l’on redonne leurs lettres de noblesse à des technologies comme RSS et Atom ; cela implique d’inventer de nouveaux usages autour d’elles, et donc de développer des outils. En gagnant de l’argent avec FreshRSS, je serai en mesure de l’améliorer en lui accordant du temps. D’ailleurs, j’entérine ça dans les conditions générales de vente de Flus (le service que je mets en place pour fournir un FreshRSS hébergé) :

Le service est amené à évoluer régulièrement à travers des mises à jour du logiciel, développées à la fois par une communauté de développeurs et développeuses, et par le vendeur du service qui s’engage de ce fait à contribuer au développement d’un bien commun. Cet engagement sera tenu à partir de et aussi longtemps que le vendeur pourra vivre du service.

Je n’ai plus qu’à espérer que les flux RSS ne soient pas tout à fait morts ;)

Bretagne

2019-09-16T12:00:00+02:00

Je pars lundi prochain (le 23 septembre) pour un petit mois pédestre en Bretagne. Initialement prévu pour l’automne 2017, j’ai réussi à repousser ce voyage pendant deux ans pour diverses raisons, mais cette fois c’est bon !

Mon trajet, qui évoluera sans doute en cours de route, consistera en :

un passage (express) à Rennes ;
une quinzaine de jours à marcher entre le Mont-Saint-Michel et Saint-Brieuc ;
un passage à Brest ;
une petite dizaine de jours à marcher sur la presqu’île de Crozon ;
peut-être un saut à Vannes, puis à Nantes, avant de rentrer.

Les plus attentifs noteront que je vais plus ou moins suivre le sentier des douaniers. Je partirai sans PC et serai donc difficilement joignable. Si vous êtes sur la route et voulez faire un coucou ou marcher un bout de chemin, n’hésitez pas à me contacter avant que je ne parte.

Je profiterai de ce voyage pour finaliser mon discours et mes idées autour de Flus, ce serait d’autant plus intéressant de pouvoir rencontrer des gens en cours de route !

Phase de simplification

2019-09-11T10:15:00+02:00

J’ai la mauvaise habitude de tenter de me compliquer la vie (c’est humain j’imagine). La conception de ce site en est un bon exemple. Après quelques mois de recul sur ce que j’ai réalisé, je me suis rendu compte que la page d’accueil notamment ne collait pas du tout avec ce que je voulais mettre en valeur. J’ai pris 30 minutes ce matin pour changer tout ça, en me prenant moins la tête. Je vais également me simplifier la vie et rédiger des articles (beaucoup) moins longs. On verra bien si ça me motive à en écrire plus.

Mon (futur) service de veille

2019-07-12T11:30:00+02:00

J’ai partagé il y a quelque temps un questionnaire destiné à étudier le marché des agrégateurs d’actualité dans le but d’une potentielle création d’entreprise. Mon objectif était de mieux connaître le marché actuel, d’évaluer un début de tarification et de mieux connaître les attentes de potentiel·les client·es. J’en profite d’ailleurs pour remercier les 281 personnes qui ont pris le temps de répondre, ça m’a bien aidé à y voir plus clair dans ce que j’allais faire !

Je reviens dans cet article sur les raisons qui m’encouragent à mettre en place un tel service et j’appuie certains éléments par les questions posées par le questionnaire.

La raison de faire

Si vous suivez ce blog, vous savez sans doute que je suis au chômage depuis décembre dernier. Loin d’être une situation subie, j’en ai profité pour poser à plat mes envies à travers un travail d’introspection. Je comptais alors, sans le dire explicitement, suivre une voie « par défaut » qui était celle de me mettre en auto-entrepreneur pour faire du service auprès d’entreprises. J’ai mis un moment avant de prendre réellement conscience que ce métier ne m’intéressait absolument pas.

Mon chômage s’écoule doucement mais sûrement depuis maintenant 7 mois, finançant d’une certaine manière mes activités bénévoles (en témoigne l’évolution de ma page « En ce moment » ces derniers mois). Il est toutefois temps que je commence à travailler concrètement sur mon futur professionnel afin de me dégager un salaire. L’idée n’étant pas de générer un salaire mirobolant, mais juste assez pour pouvoir vivre tranquillement (par transparence, je vise entre 1 500 et 2 000 € par mois).

Je n’envisage pas mon avenir professionnel en tant que salarié d’une entreprise « traditionnelle » où l’on décide à ma place ce sur quoi je dois travailler. J’ai toujours pris soin de ma liberté de choix et je compte bien continuer. En avant donc pour créer ma propre structure. Aussi, l’envie de créer un service en ligne de manière professionnelle me trotte dans la tête depuis plusieurs années et cette remise en question m’a permis de la remettre au goût du jour.

Pour terminer sur ma raison de « faire », je souhaite revenir sur la limitation volontaire de mon salaire. J’ai à cœur de pouvoir travailler et être d’une quelconque aide au monde associatif, en particulier celles œuvrant dans les luttes pour le climat ou les luttes sociales. Le monde économique dans lequel nous vivons ne valorisant pas (encore ?) le travail qui peut être fait dans ces milieux-là, il s’agit bien souvent de bénévolat. Mon but en limitant mon salaire est donc de générer du temps libre que je pourrai mettre à dispositon d’associations : « gagner moins pour travailler plus utile » en quelque sorte.

Les raisons d’être

Se pose maintenant la question de la raison d’être du service en ligne. Quelle raison me fait dire que le service aura une quelconque utilité ? À quel besoin je réponds ?

L’une des choses que j’observe depuis longtemps, en partie à travers mon action au sein de Framasoft, c’est le cloisonnement de nos données et notre assentiment à déléguer le choix de nos sources d’information à des plateformes privées telles que Twitter ou Facebook. On l’a vu notamment lors du scandale de Cambridge Analytica : cela peut avoir des conséquences désastreuses sans réelle réflexion politique ni mesure de contre-pouvoir.

Pourtant, il est important de pouvoir se tenir au courant de l’actualité. C’est le cas pour toutes les personnes qui veulent s’informer de ce qu’il se passe dans le monde, mais aussi à des échelles plus locales. Il peut s’agir de politique, d’évènements festifs, de sport, etc. D’un point de vue professionnel, la veille spécialisée permet de se tenir à jour des évolutions de son domaine (on peut penser à l’informatique mais aussi au domaine législatif par exemple).

À travers notre veille, nous nous faisons influencer par les points de vue des personnes qui publient l’information, voire par la pub qu’elles y insèrent. Aucune information n’est totalement objective, mais nous décidons de suivre tel ou tel site de manière encore à peu près consciente. Cela devient plus pernicieux lorsque cette veille est orientée sans nous le dire par les plateformes sur lesquelles nous l’effectuons. Il me paraît par conséquent important d’avoir confiance dans ces plateformes (et donc les outils techniques sous-jacents).

Dans ce que j’explique ici, j’identifie deux raisons d’être distinctes :

celle de l’outil technique qui serait de proposer un outil de veille connecté, simple et respectueux de ses utilisateur·ices ;
et celle du service en ligne qui serait de permettre la promotion et le développement de cet outil en proposant un service transparent et de confiance.

Cela implique tout un tas de choses que je détaille dans la partie suivante en me basant sur les chiffres qui ressortent de mon questionnaire.

La philosophie du service

Connexion

J’ai eu beaucoup de réponses à mon questionnaire de personnes m’expliquant qu’elles préféraient utiliser un logiciel sur leur propre PC, voire même une personne m’a affirmé que les services en ligne étaient inutiles. Si je comprends très bien que l’on puisse préférer un logiciel sur sa machine, il me semble néanmoins que les outils de veille en ligne ont aussi leur utilité, ne serait-ce que pour faire face aux usages liés à la mobilité (c’est-à-dire lire sur différents terminaux en fonction de la journée tout en gardant synchronisé ce que j’ai lu ou marqué en favori). La connexion est aussi intéressante dans les interactions qu’elle peut apporter. Si notre suivi de l’actualité a migré sur des plateformes sociales, ce n’est pas parce qu’elles sont meilleures pour cet usage spécifique mais parce qu’elles permettent de réagir, compléter et confronter l’information à d’autres avis. Aujourd’hui les agrégateurs d’actualité ne le permettent effectivement pas, mais il s’agit pour moi d’une évolution qui aurait tout son sens.

Simplicité

Ensuite, la simplicité d’usage est importante si je veux toucher un public autre que celui qui est prêt à creuser les fonctionnalités ou qui comprend déjà le fonctionnement d’un agrégateur de flux RSS. C’est une composante essentielle si je veux poser mon service comme une véritable alternative face à d’autres plateformes. Deux questions dans mon sondage devaient d’ailleurs me permettre de valider cet aspect-là. À l’argument « Les fonctionnalités du service sont très ciblées et restent volontairement simples », 58% des personnes ont répondu qu’il les inciterait à utiliser le service, et 32% non. L’argument corollaire « Le service dispose de nombreuses fonctionnalités (au risque de devenir complexe) » a reçu 38% d’avis positifs et 54% négatifs. J’admets toutefois que ce deuxième argument était orienté, j’aurais sans doute dû éviter. On voit néanmoins que les rapports s’inversent de façon très claire. Et j’ajoute que le questionnaire a touché un public plutôt geek, plus enclein à fouiller un logiciel, alors qu’il ne s’agira pas forcément de ma cible finale (j’y reviens plus loin).

Transparence

La transparence du service m’apparaît comme une composante essentielle dans le respect des utilisateur·ices car cela peut amener à comprendre certains choix qui sont faits. Par exemple, une majorité de personnes sont prêtes à payer 1 ou 2 € par mois pour utiliser le service. Néanmoins, plus le prix sera bas, et plus je devrais avoir de client·es pour générer mon chiffre d’affaire. Qui dit plus de monde dit aussi plus de support à faire (donc moins de temps par personne), un serveur plus puissant avec plus de capacités de stockage, etc. Être transparent c’est aussi expliquer que le prix se calcule en fonction de nombreux paramètres et que s’il peut paraître cher, il y a une raison derrière. Cet argument sur la transparence des prix a d’ailleurs emporté l’adhésion de 70% des répondants à mon questionnaire, il y a donc une véritable demande.

La transparence induit également l’utilisation de code libre. Une telle condition n’est pas une fin en soi mais permet à qui le souhaite et le peut de vérifier que le code respecte ses utilisateur·ices et qu’il est effectivement à leur service. Sans surprise vis-à-vis du public touché, le logiciel libre est un argument pour utiliser le service pour 81% des répondants.

Confiance

La question de la confiance était posée sous différentes formes (et est d’ailleurs déjà traitée à travers la transparence). La confiance, c’est ce qui va convaincre les gens de venir, de rester (donc de payer) et de parler autour d’eux de mon service. C’est aussi peut-être ce qu’il y a de plus compliqué à assurer sur le long terme. Cela passe à la fois par le dialogue et par les actes ; les critiques ne seront pas tendres en cas (d’accumulation) de faux-pas.

Les deux composantes essentielles du dialogue que je vois sont la communication sur les médias sociaux et le support offert aux client·es. Une mauvaise communication ou un mauvais support, c’est ce qui peut plomber une image de marque ; à l’inverse d’un bon support, dont vous n’entendrez jamais parler. Quant à l’excellent support, c’est les anciens de Captain Train / Trainline qui en parle le mieux. À l’argument du support par email, j’ai d’abord été surpris de n’avoir que 51% de réponses favorables… mais cela ne veut pas dire qu’il ne faut pas en faire, juste que cela ne correspond pas à un argument marketing qui justifierait de changer de service.

Ensuite, je compte aligner mes actes avec mes paroles à travers au moins trois actions :

faciliter la portabilité des données (que ce soit pour arriver ou pour partir) ;
contribuer au code du logiciel utilisé ;
participer au collectif des CHATONS.

D’un point de vue marketing, les deux premiers arguments sont sans appel : 82 et 85% d’avis favorables. Le troisième est intéressant car c’est celui qui a recueilli le plus de personnes ne se prononçant pas (26% alors que les autres arguments tournent plutôt entre 7 et 15%). Je l’analyse du fait que les CHATONS n’est pas (encore) un collectif très connu et que les personnes ne savent donc pas quoi en penser. En revanche, 78% des avis exprimés sont favorables, ce qui est plutôt positif dans l’ensemble !

Qualité de service

Pour terminer, la qualité du service (performances et maintenance du service en ligne) devra être au cœur de mes préoccupations si je veux rester crédible. Sur ce point néanmoins je dispose d’un peu moins de billes aujourd’hui, même si je maintiens déjà Lessy sans trop de soucis.

L’une de mes certitudes toutefois est qu’il ne faut pas lésiner sur les moyens et notamment sur les capacités du serveur et la sécurité que ce soit maintenance, monitoring ou backups.

Pour avoir vécu quelques applications en production douloureuses, j’ai également conscience qu’il y a véritablement un changement d’esprit à opérer entre un service offert (type lessy.yuzu.ovh) et un service payant professionnel.

Marché et tarification envisagées

La définition d’un marché est un exercice compliqué car, d’une part, je ne l’ai jamais fait et, d’autre part, c’est un peu naviguer à l’aveugle. Dans le cas d’un agrégateur d’actualités, c’est encore plus casse-gueule car les technologies comme RSS semblent à la fois sur le déclin et déjà fortement investies par l’auto-hébergement. On me l’a d’ailleurs (sous-)entendu de (très) nombreuses fois dans les commentaires de mon questionnaire. 70% des répondants utilisent déjà un service hébergé ou sur leur propre PC et seulement 37% se disent prêt·es à payer pour un tel service ; ce qui ne signifie pas non plus qu’ils et elles viendront chez moi ! Qu’à cela ne tienne, je vais tout de même tenter une réponse.

Je vois très clairement deux périodes pour mon service. La première consistera à proposer un service basé sur un logiciel existant (très certainement FreshRSS). Je viserai alors un public déjà sensibilisé à ce genre d’outils, qui n’a pas l’envie ni le temps de maintenir un service en ligne et qui est prêt à payer pour déléguer ces tâches à quelqu’un d’autre. J’ai bon espoir d’arriver à générer un peu de chiffre d’affaire, de quoi commencer à me sortir un salaire (probablement pas énorme). En parallèle de cette période, je compte améliorer le logiciel pour l’orienter vers quelque chose de plus grand public et moins dépendant de technologies précises. Tout du moins, je pense qu’il sera nécessaire de repenser la façon de s’abonner à des sites. Je dis « améliorer » mais comme FreshRSS est déjà soutenu par une communauté, cela se fera nécessairement en accord avec celle-ci. Ce qui m’amènera donc à la deuxième période où je pourrai toucher un public élargi et qui ne se soucie pas des technologies sous-jacentes. En résumé, plutôt que de lutter pour m’insérer sur un marché hyper-concurrentiel, je compte en changer pour me permettre de respirer.

Un autre point, qui rajoute peut-être une couche de complexité, c’est que je compte m’adresser à un public exclusivement francophone. On peut trouver cette décision un peu étrange à l’heure de la connexion mondiale, mais je fais ce choix de manière pragmatique pour me faciliter la communication. Je ne serai en effet jamais aussi efficace qu’en français pour véhiculer une idée ou pour aider une personne sur le support. Je crois que ce choix me permettra de m’économiser de l’énergie pour d’autres tâches plus importantes (et j’aurai déjà beaucoup à faire !) Bien entendu, si le service se base sur FreshRSS, il existe déjà de nombreuses traductions donc je ne m’amuserai pas à les enlever. Je parle ici bien uniquement de la communication.

Concernant la politique tarifaire, cela reste encore à valider mais je partirais sur :

une période d’essai d’un mois ;
un abonnement mensuel (le prix reste à déterminer) ;
un abonnement annuel avec réduction (idem) ;
aucune limite sur le nombre de flux suivis.

Concernant le dernier point, plus de 90% des répondants se contentent de moins de 500 flux ce qui me semble tout à fait gérable. Reste les 10% restants et les abus éventuels qui pourraient faire exploser les coûts de stockage et de traitement notamment. J’envisageais d’abord de mettre une limite à 500 abonnements, déblocable sur simple demande au support, mais d’un point de vue marketing je trouve qu’il est plus efficace de ne pas mentionner de limite et de gérer les abus au cas par cas. L’avenir me le dira !

Aussi, j’ai décidé de ne pas appliquer de tarifs évolutifs en fonction du nombre d’abonnements. Les avis étant très partagés sur la question, il me semble qu’il est plus simple d’avoir un tarif unique.

Avenir envisagé sur le long terme

La grande question qui se pose lorsque l’on s’abonne à un service en ligne, c’est celle de sa pérennité. Est-ce que le service sera toujours là dans un an ou deux ? Vous aurez peut-être compris que je ne souhaite surtout pas me lancer sur un modèle « startup » qui consiste pour beaucoup à cramer de l’argent dans l’espoir de trouver un business model… bien au contraire. Comme déjà évoqué plus haut, mon premier objectif sera de me générer un revenu correct pour vivre. Cet objectif, j’aimerais l’atteindre globalement seul afin de valider un certain niveau d’autonomie. Mais maintenir un service seul sur le long terme ne me paraît absolument pas viable et extrêmement fragile, c’est pourquoi j’envisage le long terme au sein d’une structure avec plusieurs personnes. Il est bien sûr trop tôt pour m’avancer sur quoi que ce soit, en particulier sur la forme que prendrait cette structure. J’ai toutefois une ambition, directement inspirée par la société Basecamp : celle de maintenir le service jusqu’à la fin d’Internet.

Cela ne peut rester qu’une ambition tant que je ne génère pas de revenu et que la stabilité de l’entreprise n’est pas prouvée, mais je trouve que c’est une vision juste et encourageante que ce soit pour moi ou pour mes (futur·es) client·es. Là où beaucoup trop de services sont aujourd’hui éphémères, je trouve qu’il est rassurant de savoir qu’un tel endroit est prévu pour durer. J’espère également que cela me poussera à faire les choses « correctement » et inspirera d’autres personnes à faire de même.

Prochaines étapes

Tout ce que je viens de raconter reste très théorique tant que je n’ai pas commencé à avancer dessus. Je n’ai d’ailleurs pas encore de date à donner quant à la sortie officielle du service. J’ai commencé un plan pour avoir une vue d’ensemble de tout ce que j’ai à faire d’ici là. Si je suis assez confiant sur le fait de pouvoir avancer relativement vite, le service ne devrait pas sortir pour autant avant la fin de l’année. J’ai notamment, avant ça, un voyage à faire en Bretagne ; voyage que je repousse depuis plusieurs années… mais cela risque bien d’être le dernier moment si je veux le réaliser sous la forme que j’envisage.

En parallèle de ce travail de définition de mon service, j’ai également réalisé des documents prévisionnels pour connaître les coûts de mon projet et comprendre mon chiffre d’affaire. Il me reste encore à affiner ces chiffres, en particulier les objectifs en terme de nombre de client·es. La prochaine étape que je vois est celle du choix du statut légal de l’entreprise. J’envisage aujourd’hui deux possibilités : le statut de micro-entreprise ou rejoindre une coopérative d’activité et d’emploi. Je reste néanmoins toujours à l’écoute d’autres solutions.

Quant au nom du service… je le garde pour plus tard 😉

Questionnaire sur votre utilisation des agrégateurs d’actualité

2019-05-29T17:50:00+02:00

J’ai partagé hier matin sur les réseaux sociaux un questionnaire pour étudier l’utilisation des agrégateurs d’actualité (ou « de flux RSS »). Je reviendrai plus longuement dans un autre article sur le pourquoi et le comment mais, pour faire court, je souhaite me mettre à mon compte d’ici la fin de l’année et j’ai pour cela besoin de connaître un peu mieux les attentes des personnes utilisant de tels outils.

J’ai pour le moment récupéré plus de 200 réponses, ce qui représente le double de ce que j’espérais initialement. J’aurais toutefois souhaité un peu plus de réponses de personnes prêtes à payer pour un tel service (un peu plus du tiers des répondants pour le moment).

Si vous souhaitez me donner un petit coup de main, n’hésitez donc pas à remplir ce questionnaire et à le partager auprès de vos proches et collègues. Je l’ai pensé court pour pouvoir le remplir en 5 minutes sans avoir à se creuser la tête. Je ferai sans doute un questionnaire plus détaillé ensuite pour les personnes acceptants de prendre un peu plus de temps.

Je publierai l’analyse des résultats sous la forme probable d’un article de blog afin que cela puisse bénéficier à n’importe qui.

Merci d’avance !

Concevoir les logiciels de demain

2019-04-16T11:05:00+02:00

J’ai donné le dimanche 7 avril dernier une conférence à l’occasion des Journées du Logiciel Libre (JdLL). L’article qui suit correspond à la transcription de ce que j’y ai raconté. Je me proposais de poser des réflexions autour de la conception des logiciels de « demain », en intégrant à la fois des considérations environementales et d’impact utilisateurice. Loin d’être exhaustive, cette présentation était surtout l’occasion de jeter quelques pistes à défricher ensuite ensemble. Le format lui-même tentait de faire intervenir les personnes venues m’écouter. Sur ce point j’ai été particulièrement satisfait que les conversations se déroulent de manière aussi fluide, sans accaparement de la parole ; vraiment merci aux personnes qui étaient là ! J’ignore si elles sont reparties avec ce qu’elles étaient venues chercher, c’était finalement assez éloigné de ce que j’avais en tête au moment de proposer le sujet. J’ai en tout cas pris plaisir à donner cette conférence (même pas stressé !) Pour bien faire, il faudrait maintenant que je creuse chaque sujet dans des articles spécifiques, il y a de quoi faire.

La transcription est plus complète que ce que j’ai raconté à l’oral vu que j’ai nécessairement oublié de dire des choses. Je l’ai aussi annotée pour redonner du contexte lorsque nécessaire. Les quelques diapos sont accessibles en suivant ce lien.

Introduction

Je vais commencer par vous poser une question : qui ici s’est déjà posé la question d’adopter un mode de vie numérique plus en accord avec la planète ?

Note : tout le monde ou presque a levé la main alors que la salle était pleine. Très content de cette réponse même si du coup ça a augmenté mon syndrome de l’imposteur. Ça a toutefois bien aidé à alimenter les discussions qui ont suivi.

Si je vous pose la question, c’est parce qu’en préparant cette conférence, je me suis rendu compte que je n’arriverais jamais à aborder tous les sujets qui pourraient l’être. Je risque de perdre des gens, et je risque surtout de ne pas répondre aux attentes de celleux qui se sont posées plus de questions que moi. Alors j’aimerais faire de cette conférence un espace participatif en tentant un format un peu particulier. Je vais introduire les deux parties de notre conférence pendant 10 à 15 minutes chacune, et à la fin de chaque partie, je vous poserai une question pour ouvrir le sujet. Le but étant de venir compléter ce que j’aurais dit, ou de débattre selon les envies. Ce que je vais raconter paraîtra sûrement incomplet aux yeux de certaines personnes, mon but n’est pas forcément de rentrer dans le détail mais de défricher un certain nombre de sujets… en les survolant donc.

Mon objectif est que vous repartiez avec trois éléments. Le premier, c’est que vous vous posiez la question de savoir si votre vie numérique est en accord avec vos convictions. Le deuxième, ce sont des idées, des outils pour concevoir plus simple, plus orienté « bien-être » utilisateurices. Enfin, je voudrais tracer quelques sillons de sujets que vous auriez envie de creuser, d’approfondir en sortant de cette salle.

Je vous mets un pad à disposition pour retrouver la transcription de ce que je vais raconter ainsi que les diapos. Mais je vous encourage, si vous prenez des notes, à le faire de manière collaborative sur ce pad. Si vous avez des questions, des retours à faire sur le fond comme sur la forme, allez-y. Si vous voulez partager des liens, des ressources ou si vous voulez échanger des coordonnées pour discuter de tout ça entre vous plus tard, faites-vous plaisir !

Note : personne n’avait son PC sur les genoux du coup l’idée du pad collaboratif est tombée à l’eau. Pas très grave, les gens étaient d’autant plus à l’écoute.

Moi, super-héros et développeur de sites statiques

Pour commencer, je vais vous parler de moi. Et donc aussi un peu de vous, je l’espère.

L’autre jour en trainant sur Twitter, je suis tombé sur une photo montrant un ours sur la banquise, rachétique et visiblement mal en point. Le commentaire sous la photo laissait entendre que son état était dû au réchauffement de la planète. Du coup, ni une ni deux, un sentiment de révolte m’envahit ! « Comment peut-on laisser faire ça ? » Mais l’ours n’est pas la seule raison de cette colère : chaque tweet, chaque article traitant d’inégalité, de racisme ou d’effondrement vient alimenter ce sentiment d’injustice, et par la même occasion, cette envie de vouloir tout résoudre. Ce syndrome, c’est celui du super-héros, celui qui est capable de tout remettre dans l’ordre. Nous avons tous envie d’être un super-héros pour résoudre les problèmes dans le monde. Mais notre kryptonite à nous, ce n’est pas un caillou radioactif, c’est les photos de chats « vraiment-trop-mignons ». Invariablement après une telle photo, notre colère s’estompe.

Heureusement, il y a celleux qui font. Celleux qui font pipi sous la douche pour économiser l’eau de la planète. Celleux qui éteignent la télé avant de se coucher pour sauver la banquise de ce pauvre ours famélique. Et il y a celleux qui développent des sites statiques pour réduire leur impact carbone. Alors oui, ça vous fait peut-être rire : « C’est pas comme ça qu’ils vont sauver le monde, hé ! » Mais en attendant, est-ce qu’ils et elles ne font déjà pas un peu plus que vous, en colère derrière votre écran ?

Évidemment, je vous présente des situations caricaturales, on est toutes et tous un peu des deux à la fois, et il est hors de question de confronter celleux qui font à celleux qui se révolent. Nous ne sommes pas toutes et tous égaux face à l’action politique (au sens large du terme), notamment à cause de nos inégalités face au temps, aux ressources ou à notre position sociale. Je propose que nous restions tous humble vis-à-vis de ce que l’on peut entreprendre et d’accepter que nous avons tous une part d’incohérence que nous travaillons chacun·e à notre rythme. Je suis convaincu par ailleurs (c’est donc subjectif) que ce sont nos actions individuelles (bien que parfois un peu ridicules) qui nous font avancer sur le chemin d’une action plus collective et plus efficace. C’est parce que j’ai rejoint une AMAP un jour que j’ai eu l’idée de faire une conférence participative et que demain je m’associerai peut-être à un collectif pour faire avancer les causes qui m’importent, en espérant peut-être un effet boule de neige.

Mais revenons-en à notre sujet : j’ai moi-même développé un générateur de sites statiques avec dans l’idée de faire « mieux ». Évidemment, je sens bien que c’est totalement insuffisant, mon site personnel notamment a une toute petite visibilité, quel impact pourrait-il bien avoir sur la planète ? Alors si mon site statique est insuffisant, qu’est-ce que je fais ? J’ai essayé de formaliser un peu les problèmes que le numérique me pose.

Partons de ce schéma représentant la répartition de notre empreinte carbone. On y voit notamment que notre usage du numérique possède un impact aussi important que celui de notre consommation de viande et de poisson et on peut parier sur une augmentation au moins à court terme.

Cet empreinte est notamment due à notre façon d’acheter compulsivement du matériel et d’en changer sans réel besoin : on change de téléphone en moyenne tous les 2 ans et d’ordinateur tous les 3 à 4 ans ! Mais je laisse ce sujet à d’autres, je veux me concentrer sur le sujet du développement logiciel aujourd’hui.

Lorsqu’on cherche comment est réparti cet impact numérique, c’est la consommation de vidéos qui ressort principalement. Ainsi, selon le Shift Project, « Le visionnage d’une vidéo en ligne de dix minutes disponible dans le “Cloud” induit par exemple une consommation électrique équivalente à la consommation propre d’un smartphone sur dix jours ». Vous penserez à moi la prochaine fois que vous regarderez une vidéo de « chatons-trop-mignons » en haute définition sur Youtube !

On pourra donc commencer à nous questionner sur nos usages un par un, en commençant peut-être par regarder moins de vidéos et en qualité plus basse, le but étant à terme d’avoir un usage plus respectueux de la planète. Mais je me pose quand même une question : suis-je vraiment le fautif dans l’affaire ? Je veux dire, nous sommes tout de même des millions d’utilisateurs et utilisatrices à partager une consommation irraisonnée de vidéos en ligne et nous partagerions un même usage sans s’être jamais concerté·es ? Excusez-moi mais je flaire quand même quelque chose de louche dans l’affaire ! Est-ce que ce ne serait pas plutôt l’outil qui me pousse à l’usage ? Mais pourquoi ? Qui l’a conçu ? Dans quel but ?

Lorsque je me rends sur Youtube, c’est facile : c’est Google qui a conçu cette plateforme de divertissement. Mais moi, lorsque j’entends Google, j’ai un petit drapeau qui se lève dans la tête et qui me dit « attention, Google est l’une des plus grosses capitalisations boursières et génère la grande majorité de son chiffre d’affaire à partir de la pub ! » Et pour que la pub génère de l’argent, il faut des personnes pour la regarder. Idéalement beaucoup. Et qui reste longtemps. Est-ce que j’ai réellement consenti à regarder beaucoup de vidéos à la suite… ou est-ce Google qui m’a incité à le faire pour vendre du « temps de cerveau disponible » (comme dirait l’autre) et donc m’incite à rester sur sa plateforme ? Vous l’aurez compris, je touche du doigt un problème du ~~capitalisme~~ design de l’attention.

Donc non seulement il y a des usages, des logiciels qui ne respectent pas l’environnement, mais en plus ils ne respectent pas non plus leurs utilisateurices ! Est-ce qu’on ne pourrait pas y faire quelque chose ? Par exemple, si on commençait à virer cette colonne de suggestions de vidéos « qui pourraient nous intéresser » ainsi que l’enchainement automatique de vidéos ? Évidemment Youtube ne vous permet pas de le faire… mais est-ce qu’on aurait pas inventé une chose qui se nomme « le logiciel libre » ? Si je n’aime pas ce que fait telle ou telle plateforme de mon attention, alors je vais la modifier pour qu’elle me respecte, n’est-ce pas la promesse du logiciel libre ?

Nous sommes sauvé·es !
…
Vraiment ?

Prenons une plateforme de vidéos libre comme Peertube, et imaginons qu’il y ait au sein de Peertube un tel système de suggestions de vidéos ainsi que l’enchainement automatique de vidéos. Qui dans la salle se sent capable de modifier le code pour virer ces deux fonctionnalités ? Et en moins d’une heure (le temps que je considère comme raisonnable pour ne pas avoir l’impression de le perdre) ? Et bien je suis désolé de vous annoncer que toutes les personnes qui ont levé la main ne sont pas vraiment libre ! Ils ou elles sont dépendantes soit d’une personne externe, soit de temps et de ressources qu’elles devront dépenser de façon disproportionnée vis-à-vis du gain consenti. La liberté 1 du logiciel libre, celle qui implique que l’on peut modifier le code n’est finalement peut-être pas si bien respectée.

Note : quelques mains se sont levées dans la salle lorsque j’ai posé la première question, mais toutes se sont rabaissées lorsque j’ai précisé « en moins d’une heure ». J’ai bien conscience qu’il s’agit d’un temps arbitraire, mais j’avais à cœur de remettre en perspective le « temps disponible » que nous n’avons pas toutes et tous à disposition de manière égale.

J’ai donc posé lors de cette partie trois questions / problèmes qui se posent à moi aujourd’hui dans le numérique : mon usage du numérique respecte-t-il la planète ? Suis-je maître de mon attention lorsque j’utilise un logiciel ? Et suis-je capable de modifier ce logiciel pour qu’il respecte l’usage que je souhaite avoir de lui ?

Mais vous, quels problèmes vous pose le numérique aujourd’hui et aimeriez voir disparaître / résolu demain ?

Note : la discussion a eu tendance à dévier vers des solutions aux problèmes que j’ai soulevés. En cela le résultat de cette première question est mitigé, bien qu’il y ait eu des prises de parole vraiment pertinentes. N’ayant pas pris de notes, je ne serai pas capable de tout retranscrire ici cependant.

Cultivons notre jardin (ou une vision positive du numérique de demain)

Bien, maintenant que nous avons établi les problèmes que nous pose le numérique, on voit un peu mieux ce dont on ne veut pas… mais du coup, on veut quoi ?

Essayons pour cela de commencer par déterminer ce qui nous fait vibrer. Pour ma part, mon premier gros coup de cœur pour le numérique a été un jour d’hiver lorsque j’étais en troisième et que j’ai reçu mon premier PC à Noël. Lorsque j’ai réalisé que j’allais pouvoir avoir Internet directement dans ma chambre, je me suis tout de suite imaginé converser avec des personnes aux quatres coins du monde. C’est difficile de définir ce que j’ai ressenti mais je m’en souviens encore. Et c’était synonyme d’un numérique très positif.

Mais bon, à l’époque c’était compliqué l’informatique pour moi, on était encore en 56K avec le modem qui faisait du bruit dans le bureau de mes parents et j’étais persuadé qu’il fallait que j’installe le cédérom fourni par Orange pour que ça marche. Révélation : ça n’a jamais marché. Le temps est passé, Internet s’est fait omniprésent et me vendait de moins en moins de rêve ; une sorte de routine s’est installée.

Mais voilà qu’en 2017, avec les copains de Framasoft on lançait la campagne Contributopia. Je me souviens très bien du sentiment positif que j’ai eu lorsque Pouhiou et pyg nous ont présenté ce qu’ils avaient en tête. C’était le même sentiment que quelques années plus tôt, et ça dessinait un numérique tout aussi positif, voire plus.

Ce sont ces sentiments, ces imaginaires que j’aimerais qu’on arrive ensemble à reconstruire. Si on pouvait appuyer sur un bouton reset, il ressemblerait à quoi notre monde numérique ? Plutôt que de faire une liste détaillée qui prendrait des plombes à faire, je vais me contenter de parler de trois « zones » que j’aimerais rebatir si je devais repartir de zéro. Cette liste est donc très loin d’être exhaustive ! Notez que je vais mélanger alégrement numérique et Internet dans cette partie, c’est voulu.

Le premier point, c’est celui qui m’a fait vibrer au collège. C’est cette possibilité de pouvoir faire des voyages culturels, le cul vissé sur ma chaise et au prix d’une connexion Internet ; rencontrer son prochain sans contrainte de distance. Peut-être que ça ne fait pas rêver tout le monde, mais ça faisait rêver un garçon de 13 ans, donc pourquoi pas commencer par là ? Et de toute façon demain sera sans avion, autant commencer à changer notre façon de voyager.

Le deuxième sujet numérique qui me donne ce sentiment « wahou ! », c’est le partage des ressources et des connaissances. Vous connaissez peut-être ce petit site qui se nomme Wikipédia : il s’agit d’une encyclopédie en ligne alimentée uniquement par des bénévoles… je vous jure que ça marche ! Et tout le monde peut participer, donc même des sujets hyper spécifiques peuvent se retrouver être présentés en long et en large. Ce que j’aime, c’est ce pot commun, tout le monde contribue et tout le monde peut se servir sans léser personne. Il n’y a pas d’accaparement de la connaissance, c’est pour tout le monde.

Enfin, le troisième coin d’Internet que je trouve « beau », ce sont les zones d’information et d’entraide entre oppressé·es et personnes ayant besoin de se renseigner pour « améliorer » leur cadre de vie, pour s’organiser ou tout simplement pour discuter. L’anonymat notamment que permet Internet offre la possibilité de se dégager d’une certaine honte et de se sentir plus en confiance pour aborder certaines recherches et discussions. Les liens tissés entre les individus sur Internet sont généralement décrits comme « virtuels », mais je vous assure que ça ne l’est pas du tout. Ces liens numériques se prolongent d’ailleurs bien souvent dans la vie « réelle » (mais je préfère le terme « vie physique »).

Vous me rétorquerez alors : « ton Internet de demain il ressemble quand même vachement à celui d’aujourd’hui » et vous aurez sans doute raison. Sauf que dans celui d’aujourd’hui, ce ne sont pas ces aspects-là qui dominent. J’aimerais que les logiques de communautés prennent le pas sur les logiques individuelles en quelque sorte. Et l’élagage des usages que j’ai effectué permet de rendre le numérique plus soutenable. Mais un réseau d’entraide basé sur des vidéos en très haute qualité n’est pas forcément beaucoup plus soutenable, il faut bien évidemment se poser aussi la question de la conception en plus de celle des usages.

Alors comment on conçoit pour demain ? Quel est le secret si bien gardé de cette conférence ?

Je vous propose de partir sur une idée que j’applique de temps en temps lorsque je veux progresser dans ma pratique d’un sujet : je me pose des contraintes fortes. Ces contraintes ne sont pas des axiomes de conception qu’il faudrait appliquer coûte que coûte, mais des exercices qui doivent vous pousser à vous questionner sur des pratiques que vous auriez plus ou moins intégrées comme « normales ». Ces contraintes doivent répondre à un problème que vous cherchez à résoudre. Et ça tombe bien, on a identifié au moins trois problèmes dans la partie précédente !

Concernant l’impact environnemental tout d’abord, quel genre de contraintes peut-on imaginer ? Le poid des pages étant souvent pointé du doigt, commençons par là. Première contrainte : transformer un site ou une application pour que ses pages de fassent pas plus de 200Ko, images comprises ! Cette première contrainte devrait déjà soulever des questions : est-ce que mon fichier HTML est suffisamment simple ? Et mon fichier CSS ? Mais cette librairie JavaScript pèse déjà 200Ko, quelles implications si je dois m’en passer ? Combien d’images puis-je insérer ? Avec quelle qualité ? Et comment appliquer ça à un service de partage de photos ou de vidéos ? Quels choix de conception cela implique-t-il ? Peut-être que vous ne trouverez pas de réponse satisfaisante sans relacher légèrement la contrainte, mais ce n’est pas grave car vous aurez déjà commencé à vous poser la question et imaginer des solutions plus « simples ».

Sur l’attention de l’utilisateurice maintenant. Je rappelle que son but dans la vie n’est pas de passer son temps sur votre site ou application, il ou elle a bien d’autres chats à fouetter (mais ne faites pas ça chez vous, c’est de la maltraitance animale et c’est mal). Imaginons la contrainte suivante : au bout de 5 minutes passées (durant une journée) sur votre application, celle-ci se ferme automatiquement. Comment allez-vous la concevoir pour que l’utilisateurice fasse tout de même ce qu’elle est censée faire ? Cela pose la question de ce que doit faire votre application car il vous faut maintenant définir quelles fonctionnalités sont maintenant essentielles. Par exemple, comment appliquer cette contrainte à un réseau social ? Quels choix allez-vous faire pour que la personne qui se rend sur Twitter ou Mastodon puisse toujours lire ce qu’il ou elle l’intéresse ? Et au fait, à quoi ça doit servir un réseau social ? Faire de la veille ? se détendre ? créer des liens ? organiser des communautés ? tout à la fois ?

Enfin, concernant la maintenabilité des logiciels, comment favoriseriez-vous la possibilité pour un néophyte de rentrer dans votre code ? Exemple de contrainte : votre programme doit faire moins de 500 lignes de code. Là encore peut-être qu’il va devenir compliqué de recréer quelque chose comme un réseau social ou une plateforme de partage de vidéos, mais posez-vous les questions que cela engendre. Que doit faire mon programme ? Comment j’organise mon code ? Vous réaliserez sans doute qu’on ne peut pas faire l’impasse sur une « éducation au code » et tant mieux. Maintenant : quelles sont les actions que vous prendrez pour qu’un minimum d’éducation soit nécessaire pour au moins comprendre l’architecture de votre logiciel ? Et on voit que des tas de questions peuvent découler d’une bête question (celle de rendre votre code accessible au plus grand nombre).

On peut évidemment imaginer des tas d’autres contraintes comme limiter le temps de chargement de votre site ou application à moins de 0,5 seconde, limiter le nombre d’écrans à 2, développer une application sans aucune dépendance autres que celle du langage et de sa librairie standard ou encore limiter l’accès au réseau au strict minimum. Vous pouvez aussi les mixer, les modifier, etc. Ces contraintes vont sans doute vous paraître contre-productives par moment, voire totalement opposées à leur objectif et c’est pour ça que j’insiste sur le fait qu’il ne s’agit que de guides de conception. Le risque étant d’appliquer aveuglément ces contraintes en perdant de vue votre objectif initial.

En appliquant ces différentes contraintes, j’ai bon espoir que vos logiciels deviennent plus simples, plus respectueux d’un environnement mal en point et d’utilisateurices souvent malmené·es. In fine, ce sont vos logiciels qui deviendront plus libres. Pour rappel, ce n’est pas vraiment le logiciel qui doit être libre (lui il s’en fout, vous pouvez lui demander mais il y a peu de chances qu’il réponde), c’est son utilisateur ou utilisatrice. Alors la prochaine fois que vous concevrez un logiciel, merci de penser à sa liberté à ellui.

Et vous, quels usages vous semble prendre tout leur sens dans le numérique ? Qu’est-ce qui vous fait vibrer là-dedans ? Et comment le concevriez-vous ?

Conclusion

J’ai évoqué à un moment donné que je faisais parti de l’association Framasoft. Bien que les questions posées lors de cette conférence et les esquisses d’un monde numérique plus sobre fassent parties des réflexions qu’on mène dans l’asso et plus spécifiquement dans le cadre de notre campage Contributopia, je voulais souligner le fait que le sujet ne nous appartient pas. À partir du moment où vous vous sentez concerné·e, alors vous êtes légitime pour traiter le sujet et probablement tout aussi pertinent·e que nous. Je voulais faire ce petit aparte car il semble y avoir de plus en plus d’attentes envers l’association pour porter ces réflexions. Cette confiance nous fait certes plaisir, mais notre monde à nous (celui de demain) est émancipé et ne repose pas sur un groupe de quelques copain·ines. Alors n’hésitez surtout pas à cogiter sur tout ça dans votre coin et à lancer ensuite d’autres structures collectives pour imaginer d’autres imaginaires. C’est en les multipliant qu’on avancera !

Conception de la v8 du site

2019-03-01T13:20:00+01:00

Au fil des années, j’ai pris le temps d’annoncer les changements importants du site, je ne vais donc pas non plus déroger à la règle cette fois-ci. Cette huitième version (quand même) arrive presque deux ans après la dernière. C’est avant tout pour moi un retour au « fait-maison » qui était la base lorsque j’ai démarré. J’avais été lassé de maintenir des outils souvent complexes ; la cinquième version introduisait notamment une idée un peu fumeuse consistant à agréger les éléments que je partageais via 3 outils que j’avais moi-même développé…

En revenant à un outil plus simple (je vous renvoie à ma série d’articles), je reviens aussi à une idée de l’informatique qui me plaît : maîtriser (ou au moins comprendre) les outils que j’utilise.

Cet article, donc, revient sur les grandes lignes directrices que j’ai souhaitées pour cette énième version de mon site. Notez que le contenu n’est pas terminé, il manque notamment le manifeste qu’il me reste à rédiger et la liste des projets que je souhaite mettre en avant. J’envisage aussi une page « à propos » mais je ne suis pas certain de son intérêt.

Une approche pédagogique et ouverte

Si j’ai toujours tenté d’adopter une démarche pédagogique, je crois que je commence à avoir une certaine maturité sur le sujet. La série d’articles dans laquelle s’inscrit celui-ci en est la preuve la plus évidente puisque j’y explique toute la démarche qui se cache derrière ce site. Un autre exemple que j’aime bien est celui de la partie « Traitement des données » de ma page « Mentions légales » dans laquelle j’explique que malgré le fait que je ne collecte pas de données… et bien j’en collecte quand même ; j’en profite pour expliquer la raison et les circonstances.

Le côté ouverture est quant à lui illustré par les liens qui renvoient à chaque fois vers les articles qui décrivent la raison de tel ou tel paragraphe, ou pour compléter en informations. J’ai aussi insisté sur les liens renvoyant au code source. J’envisage, pour aller plus loin, d’ajouter pour chaque page des liens discrets vers les fichiers sources correspondants.

L’une des conséquences de cette approche est que cela rend le site plus verbeux. C’est voulu. Celleux qui me connaissent savent que j’écris facilement de gros pavés et cela fait partie intégrante de qui je suis, j’assume. Pour équilibrer cela, j’ai appliqué une série de bonnes pratiques de typographie pour que le contenu reste agréable à lire, notamment le principe du « triangle équilatéral du paragraphe parfait » (c’est-à-dire équilibrer la taille de la police d’écriture avec la largeur et l’espacement des lignes). Le choix de couleurs qui contrastent bien entre elles a pris un peu de temps, mais l’outil d’accessibilité intégré à Firefox a été d’une aide précieuse.

Le but de tout cela est aussi d’apposer une « patte » particulière sur mon site, pour faire en sorte que la forme du blog épouse le fond de ce que je veux promouvoir.

Navigation restreinte

Deux choses m’agacent souvent dans la navigation des sites :

trop de liens différents donnés sans aucun contexte (pourquoi cliquerais-je sur tel ou tel lien ?) ;
et le menu « hamburger » (du moins sur grand écran), celui caché derrière une icône représentée par trois barres horizontales.

Pour cette nouvelle version du site, la navigation se passe en majorité « dans le texte ». C’est-à-dire que la majorité des liens vers les autres pages sont (ou seront) contextualisés au sein du texte de la page d’accueil. Dans l’en-tête du site, seulement deux liens : l’un pour revenir à l’accueil, l’autre pour accéder au blog (qui reste le « lieu de vie » du site). Cette économie de navigation m’évite en plus le fameux menu « hamburger ».

Conscient que ce type de navigation est là encore verbeux, les différents liens sont accessibles depuis le pied de page pour avoir une vue d’ensemble du site.

Le dernier élément de navigation présent sur le site est le bouton qui apparaît en bas de la page une fois que vous l’avez faite défiler un peu et qui permet de remonter en haut de la page. Pour le créer, je me suis basé sur un article de Signal v. Noise. J’ai dû légérement adapter le code qui s’appuie sur leur cadriciel JavaScript, ce qui donne un petit script d’une dizaine de lignes. Le code CSS quant à lui est un peu plus long, mais principalement pour l’apparence.

Un thème moins bleu

Le thème de ce site a toujours été bleu, voire très bleu. Chose révolue donc puisque je suis parti sur du rouge brique (il y aura bien quelqu’un·e pour me dire que c’est orange, non ? /private-jock). Pourquoi ce rouge ? Pas de raison particulière pour le coup, ça ne transmet pas de message particulier. On pourra toujours disserter sur la signification des couleurs qui irait, dans le cas présent, à l’encontre de ce que je veux transmettre ; mon pari est que ça ne joue qu’à la marge et qu’on peut bien choisir un peu les couleurs que l’on veut tant qu’elles nous plaisent ! Si quelqu’un vient argumenter sur le fait qu’il trouve le thème agressif, je reconsidèrerai toutefois volontier mon sentiment.

La « charte » se décline ainsi :

la couleur principale (#2a2230), utilisée principalement pour le texte, ainsi qu’une variante légèrement plus clair (#665e6c) ;
une couleur secondaire (#c02b43) pour réhausser le ton du site ;
une couleur spécifique pour les liens (#a6253a), proche de la couleur secondaire ;
et une couleur de contraste (#f8f6ff), utilisée notamment en arrière-plan.

La règle est de ne jamais superposer deux couleurs différentes, à part la couleur de contraste qui est prévue pour cela (son ratio avec les autres couleurs est suffisant pour assurer une bonne lisibilité).

Mobile avant tout

J’ai pensé le site pour fonctionner sur mobile. Même si je n’utilise plus que très peu le téléphone pour aller sur Internet, il est toujours plus agréable de naviguer sur les sites prévus pour (c’est quand même l’une des promesses des technologies web, de pouvoir être accessibles quel que soit le périphérique).

Pour cela j’ai utilisé le mode « mobile » de Firefox (le raccourci pour l’utiliser est ctrl+maj+M). J’ai commencé par faire en sorte de supporter la largeur d’écran la plus petite que je souhaitais pouvoir gérer (360 pixels), puis j’ai ajouté quelques points de « rupture » (c’est-à-dire des largeurs d’écran pour lesquelles le style doit changer). Par exemple, pour les blocs des séries sur la page de blog, les blocs sont affichés en colonne par défaut :

.blog-series {
    display: flex;
    flex-direction: column;
}
.blog-serie {
    margin-bottom: 1rem;
}

Ce qui donne :

Mais à partir d’une largeur de 40rem (qui correspond à 640 pixels dans ce cas), on les affiche en lignes avec retour à la ligne autorisée.

@media(min-width: 40rem) {
    .blog-series {
        flex-direction: row;
        flex-wrap: wrap;
        justify-content: center;
    }
    .blog-serie {
        width: 30%;
        margin-right: .5%;
        margin-left: .5%;
    }
}

Ce qui donne donc :

Mise en production imminente

Ayant suffisamment repoussé la mise en production jusque-là, j'envisage de le faire dès la semaine prochaine même si je n’ai pas tout à fait fini le contenu du site. Tout viendra en temps et en heure. J’ai pu tester que l’importation des articles de l’ancien site se faisait sans soucis. À part quelques flux RSS, les liens ne devraient donc pas se casser.

Vous pouvez donc supprimer ce site de votre agrégateur de flux RSS et repasser sur celui du site initial, tous les articles y seront transférés.

Construire un site complet à base de Boop!

2019-02-26T09:30:00+01:00

Après une petite pause d’un mois sur la refonte de ce site, il est temps pour moi de m’y remettre. La dernière phase avait consisté à imaginer un prototype pour me donner une vision globale de l’architecture du site. Cela devait aussi me permettre de pointer du doigt les manques de Boop!, mon générateur de sites statiques. Et il y en avait, des manques ! Je reviendrai prochainement sur les évolutions du contenu du site ainsi que sur son habillage (qui n’est d’ailleurs pas terminé). Pour l’instant je vais me contenter de détailler les dernières évolutions techniques.

Des améliorations dans le processus de développement

L’une des choses qui me tenait à cœur avec Boop! était de pouvoir travailler de la manière la plus agréable possible sur mon site. Le mieux dans cette situation étant de s’observer râler.

Premièrement, lors de la génération du site, je voulais pouvoir ouvrir rapidement les fichiers générés. Comme la plupart du temps je travaille sur un article, je veux pouvoir l’ouvrir immédiatement. J’ai donc fini par afficher le nom des fichiers dans la console, et comme il s’agit de chemins absolus commençant par file://, je n’ai plus qu’à cliquer dessus pour ouvrir mon article. Une exécution de Boop! ressemble grosso-modo à ça :

[marien@pizza marienfressinaud.fr]$ boop.py --development
Written page: file:///home/marien/marienfressinaud.fr/site/index.html
Written page: file:///home/marien/marienfressinaud.fr/site/blog.html
Written article: file:///home/marien/marienfressinaud.fr/site/construire-un-site-complet-a-base-de-boop.html
Written article: file:///home/marien/marienfressinaud.fr/site/suivre-le-boop-blog.html
Written article: file:///home/marien/marienfressinaud.fr/site/simplifier-la-redaction-darticles-dans-boop.html
Written article: file:///home/marien/marienfressinaud.fr/site/boop-une-introduction.html
Written feed: file:///home/marien/marienfressinaud.fr/site/feeds/all.atom.xml
Static files copied
Boop!

Ici vous ne pouvez évidemment pas cliquer sur les noms des fichiers, mais ça fonctionne dans un terminal.

À noter que lorsque je génère les fichiers pour la mise en production, ce sont les URL finales qui sont affichées (voir le code), ce qui me permet d’ouvrir l’article directement une fois en ligne.

Le deuxième point agaçant était que je devais quitter mon éditeur de texte régulièrement pour générer les fichiers et vérifier que le résultat me convenait. Lors de la phase de relecture d’un article par exemple, je peux vouloir regénérer le site plusieurs fois en quelques secondes : passer de la fenêtre de mon éditeur à celle de mon terminal pour revenir de nouveau à l’éditeur est très pénible. Utilisant Vim, j’ai ajouté deux raccourcis dans mon .vimrc : l’un pour générer le site (,,) et un autre pour publier le site en ligne (,p).

autocmd BufRead,BufNewFile */*marienfressinaud.fr/* nnoremap <leader><leader> !boop.py --development<CR>
autocmd BufRead,BufNewFile */*marienfressinaud.fr/* nnoremap <leader>p make publish<CR>

Habituellement les générateurs de sites statiques proposent un serveur surveillant les changements faits dans les fichiers et qui les regénère à la volée… mais je trouvais cette solution bien compliquée pour un intérêt limité. Cela me permet aussi de garder Boop! concentré sur une seule tâche : générer un site statique.

Enfin, notons que je dispose d’un fichier Makefile dans le répertoire du site qui me permet d’effectuer des tâches usuelles de manière unifiée :

$ make boop    # génère le site en mode développement
$ make publish # génère le site en mode production et le téléverse sur le serveur
$ make clean   # nettoie le répertoire `site`
$ make open    # ouvre la page d'index du site dans le navigateur
$ make tree    # affiche la structure des fichiers en excluant le répertoire `site`

Une réécriture partielle de Boopsy

Si vous vous souvenez, Boopsy est mon système de template maison. Jusque-là, il se contentait d’afficher des variables au sein de fichiers HTML. Cependant, j’ai très vite eu besoin de pouvoir écrire des conditions (if) et des boucles (for). Ces structures ont cela de particulier qu’elles ont un impact sur la portée des variables. La boucle en particulier pose un problème, par exemple dans le cas suivant :

{% for article in liste_articles %}
    <div>{{ article.title }}</div>
{% endfor %}

Avant d’entrer dans la boucle for, la variable article n’existe pas, il faut donc gérer le contexte. L’article sur lequel je me base depuis le début gère cela de manière relativement maline : il transforme le template en mini-programme Python. Le for est donc transformé en syntaxe Python, ce qui permet de déléguer la gestion de la portée des variables à l’interpréteur de ce dernier. J’avais fort justement décidé de ne pas partir sur cette solution initialement (ne la comprenant pas, j’étais allé au plus simple), et j’ai donc réécrit en partie ce que j’avais fait.

Une fois ce travail fait, l’ajout du if et du for a ensuite été très facile vu que je n’avais plus qu’à traduire le code récupéré depuis le template en code Python.

L’apparition des pages…

J’en avais besoin pour avancer : les pages ont été ajoutées très rapidement après mon dernier article. Jusque-là, je ne pouvais avoir qu’une unique page (d’accueil) et des articles. Pourtant, les pages statiques sont bien pratiques pour donner des informations « intemporelles ».

Contrairement aux articles, les pages sont écrites exclusivement en HTML et se trouvent dans un répertoire qui se nomme… pages. Elles peuvent partager elles-aussi un template commun (voir le code).

Le problème auquel j’ai alors fait face a été de pouvoir définir des variables dans les pages pour pouvoir les utiliser dans le template. En effet, le HTML ne permet pas de définir de variables. Je suis donc parti sur la solution utilisée par Jekyll, celle d’accepter un en-tête YAML en haut des fichiers HTML. Je trouvais cette solution d’autant plus élégante qu’au final il s’agissait de la même façon de faire dans les fichiers Markdown.

… d’une page de blog…

Une fois tout cela en place, je n’avais plus grand chose à faire pour avoir le site de mes rêves. Une chose toutefois continuait de m’embêter : je devais lister les articles à la main, un par un, manuellement sur une page de blog.

Disposant désormais de tout ce qu’il me fallait pour construire une liste d’articles automatiquement, il m’a fallu très peu de temps pour ajouter une page de blog générée par Boop!.

… et des séries.

La dernière fonctionnalité que j’ai développée a été celle des « séries ». Une série est une sorte de catégorie regroupant une liste d’articles. La différence avec le système de catégories que l’on peut retrouver ailleurs est que la série liste les articles dans un ordre décidé par l’auteur. C’est-à-dire, dans mon cas actuel, du plus ancien au plus récent (l’inverse donc de la page de blog). Mais on pourrait imaginer que cet ordre soit encore différent ; c’est à l’auteur de voir ce qu’il préfère.

La conséquence de cela est que les liens vers les articles sont aujourd’hui à faire manuellement sur les pages des séries (c’est dommage alors que je viens de vanter les mérites de l’automatisation dans la partie d’avant). J’envisage toutefois un système un peu plus sympathique à terme, sans perdre pour autant en flexibilité.

Une série dispose aussi d’un flux Atom spécifique, de la même manière que les catégories dans Pelican. Je sais qu’ils étaient utilisés sur mon ancien site (pour Lessy notamment), je voulais donc retrouver ce système sur le nouveau. Dans le flux, les articles continuent par contre d’être listés du plus récent au plus ancien.

Une série est créée en regroupant des articles dans un répertoire et en créant une page nommée serie.html dans ce répertoire (voir l’exemple du « Boop! blog »).

Et une grosse réorganisation du code

Vous vous doutez que tous ces changements ont apporté leur lot de dette technique et le fichier presque unique qui contenait le code de Boop! commençait à devenir hors de contrôle (500 lignes de code dont 220 pour la seule fonction principale). Il était grand temps de faire quelque chose, mais pas n’importe comment.

Une chose que je n’aime pas quand je lis le code d’une autre personne, c’est lorsqu’il y a des indirections dans tous les sens et que je dois ouvrir 5 fichiers pour comprendre ce qu’il se passe. Dans mon cas, je voulais que le fichier principal contienne l’ensemble de la logique métier, c’est-à-dire :

chargement de la configuration du site ;
collecte de l’ensemble des articles et des pages ;
écriture des articles et des pages ;
écriture des flux Atom (le principal ainsi que ceux des séries) ;
copie des fichiers contenus dans static.

Ensuite, les fonctions qui ne revêtent pas un caractère important dans la logique métier sont extraites vers un fichier utils.py. Ce fichier apporte néanmoins des informations importantes quant au fonctionnement de Boop!.

Les derniers fichiers quant à eux contiennent quelques classes utiles au fonctionnement, notamment Article, Page et Feed.

Pour les plus curieuses et curieux d’entre vous, vous pouvez retrouver les différents commits de cette réorganisation de code de cette manière :

$ git clone git@framagit.org:marienfressinaud/boop.git && cd boop
$ git log --reverse --oneline 694c4e3f..7bfac8f4
e3c382a Move extension filtering in utility functions
9a2c645 Extract function to build an article from filepath
...
7bfac8f Refactor feeds generation
$ git show [le commit que vous voulez voir]

Je pense toutefois que l’intérêt reste limité, mais c’est vous qui voyez si ça vous intéresse.

Un outil taillé au poil

Boop! a cela de bien qu’il fait très exactement ce dont j’ai besoin : pas une fonctionnalité n’est superflue. Et s’il manque très certainement des choses, ce sont pour d’autres besoins que les miens. Alors, oui, ça m’a pris un certain temps à développer ; je ne conseille évidemment pas à tout le monde de développer son propre générateur de sites statiques. Il y avait avant tout une visée pédagogique dans ma démarche, en montrant comment en partant de zéro on peut concevoir un outil qui fonctionne tout aussi bien qu’un « plus connu ». J’ai d’ailleurs pris le soin au fur et à mesure de l’article (ainsi que des précédents) d’ajouter des liens vers les commits correspondants à ce dont je parlais, pour comprendre « comment j’ai fait ». Je voulais aussi montrer qu’en restant le plus simple possible, on obtient une meilleure maîtrise sur l’outil et on peut le faire évoluer plus facilement. On favorise ainsi la liberté 1 du logiciel libre.

Boop! n’est pas pour autant totalement terminé. Il me reste à l’utiliser régulièrement sur une longue période de temps, comprendre là où ça bloque, fluidifier mon processus de travail, fignoler les morceaux de code toujours pas très élégants, améliorer la documentation que je n’ai jamais pris le temps de structurer correctement… Cela pourrait presque être comparé à du travail d’orfèvre à ce niveau de précision, mais j’aime être pointilleux quand je peux me le permettre. Et je peux.

Introspection professionnelle : communication et site

2019-01-11T11:45:00+01:00

Pour ce dernier article de mon « introspection professionnelle », je vais aborder le sujet de la communication et dessiner une esquisse de ce que sera l’architecture du site. Pour rappel, le premier article définissait mes valeurs et ma raison d’être, tandis que le second décrivait les compétences que je souhaite appliquer dans mon futur métier ainsi que l’objectif que je me fixe.

Les choses commencent doucement à se clarifier pour moi, ce troisième article aborde enfin la phase concrète de la démarche et les premiers traits du site seront tirés dans la dernière partie. J’ignore encore qu’elles seront les missions sur lesquelles je serai amené à travailler, mais l’accueil qui a été réservé à mes deux premiers articles me conforte dans la voie que j’ai commencé à emprunter.

Différents supports pour communiquer

J’ai commencé à me poser la question du support de communication lorsque j’ai réalisé la diversité des médias que j’utilisais jusque-là : mon site évidemment, Twitter, Mastodon, Diaspora* (plus trop maintenant), mais aussi GitHub, sans compter les différents blogs ou espaces où j’ai été amené à écrire au compte-goutte. Je me posais régulièrement la question de quelle information devait être partagée où et sur quel ton. Il est grand temps de remettre tout cela à plat.

Pour commencer, parlons de ce dont je ne veux plus avoir à m’occuper : GitHub et Gitlab, et en particulier du premier. Il s’agit là de forges logicielles, c’est-à-dire d’espaces où l’on dépose du code source, agrémentés d’outils pour contribuer à ce code (notamment un bugtracker ainsi qu’un système de pull requests permettant de proposer des modifications du code). Mais ce n’est pas tout : GitHub en particulier n’est pas une simple forge, ce qui en fait sa force se trouve aussi dans ses aspects communautaires. On y met en avant les projets sur lesquels on travaille, notre activité quantifiée sous forme de beaux diagrammes et on peut même suivre ou être suivi par d’autres développeurs et développeuses pour voir ce qu’ils font. Gitlab est sans doute légèrement moins orienté vers cela, mais intègre tout de même certains de ces méchanismes. Le défaut de ces deux plateformes, c’est qu’elles sont orientées exclusivement vers le code, vers la technique. Si vous avez suivi mes articles précédents, vous aurez compris que cela m’intéresse assez peu au final. Quantifier le nombre de lignes de code ou de tickets que j’ai ouverts ne m’intéresse pas, cela flatte tout juste l’égo lorsque l’on est « productif ». Utiliser GitHub ou Gitlab pour communiquer m’apparaît donc comme trop restrictif et orienté vers un but qui n’est pas le mien. Je ferai donc désormais le minimum pour maintenir mes profils à jour sur ces plateformes.

Ensuite, le couple Twitter / Mastodon est légèrement plus compliqué. Ces deux médias sociaux se ressemblent énormément dans leur mode de fonctionnement (c’est-à-dire le partage de courts messages instantanés). Toutefois, Mastodon possède une communauté plus petite et plus ouverte où l’on trouve des personnes avec qui échanger de façon plus proche. Twitter me fait l’impression d’une population très (trop ?) hétérogène, où n’importe qui peut s’immiscer dans une conversation dans laquelle il n’est pas le ou la bienvenu·e (et s’y accrocher en plus, le bougre !) Dans les deux cas, l’argumentation est compliquée de part la limite du nombre de caractères dans les messages (280 sur Twitter, 500 sur Mastodon), alors autant privilégier la plateforme qui offre le cadre le plus accueillant pour échanger. Par conséquent, j’utiliserai Mastodon pour partager des choses professionnelles et plus personnelles. Je conserverai toutefois mon compte Twitter pour partager des choses exclusivement professionnelles et pour continuer ma veille de l’actualité. Quant à mon compte Diaspora* qui est à l’abandon depuis un moment, il risque de disparaître pour de bon un de ces jours.

Le dernier support de communication d’importance que je souhaite utiliser est bien entendu mon site Internet. Je le souhaite au centre de mes partages, en espérant écrire plus qu’auparavant (la fin de l’année 2018 m’a montré que j’en étais capable). Je détaille plus en détails comment j’imagine mon site dans la dernière partie de cet article.

Les petits à-côtés de la communication

En travaillant les supports de communication, quelques éléments sont ressortis que je n’ai pas encore traités.

En premier lieu, le CV est un support que je trouve intéressant. Il est surtout utilisé pour postuler en tant que salarié, mais aussi pour faire de la prestation chez des clients. J’aime bien y jeter un coup d’œil pour savoir comment les gens se présentent de manière succincte. D’un point de vue plus personnel, je trouve qu’il s’agit d’un exercice de synthèse assez intéressant et j’aime bien me limiter à une page A4 bien qu’aujourd’hui j’aurais sans doute matière à déborder un peu. Il ne s’agit toutefois pas d’un besoin urgent, bien que je m’y pencherai sans doute avec intérêt d’ici quelques mois.

Un autre sujet facultatif dans l’immédiat est celui des cartes de visite. Je vais sans doute rencontrer des gens qui chercheront à me contacter et la carte est dans ces cas-là intéressante pour donner les informations essentielles. Je devrais toutefois être capable de découper un bout de papier dans un coin de nappe et y écrire mon nom ainsi qu’une adresse courriel. Il manquera l’aspect « objet à collectionner », mais je suis persuadé que les gens sauront s’en passer. La fin du monde est pour demain après tout.

En parlant d’adresse courriel, se pose la question du moyen de me contacter. Je ne privilégie pas Twitter et je risque d’oublier des choses si les gens me contactent par Mastodon. De plus, j’aime centraliser ma correspondance, et le courriel est idéal pour cela. Ainsi, je compte mettre en évidence sur mon site une adresse unique pour me contacter. Certains préfèrent passer par un formulaire pour éviter que des personnes ne récupèrent leur adresse et limiter ainsi le spam, mais la mienne traîne déjà depuis plusieurs années sur mon site et j’arrive à peu près à limiter le spam. Je me suis aussi posé la question de proposer un numéro de téléphone, à Sogilis cela était fait car certains clients appellent plus volontiers qu’ils ne rédigent un courriel. Le téléphone est toutefois pour moi un élément relativement intrusif de par la présence physique qu’il requiert et je le réserve à un cadre privé.

Enfin, le dernier sujet que je souhaitais aborder est la photo de profil. Si je ne compte pas en mettre une en évidence sur le site, j’apprécie toujours de pouvoir me faire une idée du visage d’une personne avant de la rencontrer, ne serait-ce que pour la reconnaître plus facilement. La photo que j’utilise aujourd’hui commence à dater un petit peu, et les personnes qui m’ont croisé récement seront sans doute d’accord pour dire qu’elle n’est plus vraiment au goût du jour. J’ai vu à plusieurs reprises le conseil de passer par un photographe professionnel, mais je vais encore laisser le sujet de côté quelques semaines avant de me décider sur ce que je fais.

L’architecture du site, pour me représenter

Mon futur site aura deux objectifs : me servir de vitrine professionnelle (et donc me présenter) et à partager ce sur quoi je travaille. La structure de base de la page d’accueil que j’envisage n’a rien de très originale :

présentation en une phrase de qui je suis, ainsi que mise en avant de mon objectif ;
énumération de mes compétences pour indiquer sur quoi je peux travailler et comment ;
présentation de mon manifeste pour mettre en évidence mes valeurs et préciser que je ne travaille pas sur n’importe quoi ;
indication de mon adresse courriel ainsi que les médias sociaux sur lesquels on peut me trouver ;
enumération des projets sur lesquels j’ai travaillé et que je souhaite mettre en avant (limités à environ 5) ;
enfin, un pied de page pour servir de rappel (liens vers les différentes pages du site, rappel des informations de contact, etc.)

Il existera des pages supplémentaires pour détailler certaines parties, notamment mes compétences et mon manifeste (qu’il me reste à écrire !) J’intégrerai aussi au niveau de la liste des projets, un lien amenenant vers ma page « now » que je tiens à jour pour indiquer ce sur quoi je travaille en ce moment.

J’aimerais limiter le nombre de liens dans la barre de navigation en haut de la page, et je me contenterais d’ailleurs bien d’un simple lien vers le blog. Au passage, j’essayerai d’effacer la frontière qui peut exister habituellement entre la partie site et le blog. Il paraîtrait en effet logique qu’un lien partant de la liste des projets amène vers une série d’articles liée à un projet en particulier. La page de blog en elle-même se contenterait de présenter la liste complète des articles, mais deviendrait optionnelle pour accéder aux articles. Je souhaite de ce fait les placer dans leur contexte.

Afin d’illustrer ce vers quoi je veux tendre, j’ai créé une page de démonstration relativement complète. Avec cela, j’ai déjà une bonne base de travail pour avancer rapidement. Il me reste encore pas mal de contenu à écrire et Boop!, mon générateur de sites statiques, va encore devoir évoluer un peu, mais je peux dorénavant envisager une mise en ligne à la fin du mois.

Introspection professionnelle : compétences et objectif

2019-01-02T15:15:00+01:00

En 2019, je change de vie professionnelle. Afin d’accompagner ce changement, je souhaitais entreprendre la refonte de mon site pour qu’il mette mieux en avant mes aspirations. Dans mon précédent article, j’ai décrit mes valeurs et ma raison d’être (c’est-à-dire ce qui me motive au quotidien), à travers une démarche d’introspection professionnelle. Pour rappel, les différentes étapes que je prévois dans le cadre de cette démarche sont :

définition de mes valeurs ;
définition de ma raison d’être ;
définition de mes compétences ;
établissement d’un objectif personnel ;
définition de mes moyens de communication ;
conception de l’architecture du site.

Les deux premiers points ont donc été détaillés dans le précédent article, je vais désormais aborder les deux points suivants, à savoir mes compétences et mon objectif personnel afin d’étudier comment je compte mettre en œuvre ma raison d’être. Dis autrement, je vois mes compétences comme des outils à mon service pour atteindre un objectif qui saura satisfaire ma raison d’être et mes valeurs.

Aujourd’hui mes compétences sont essentiellement techniques, orientées spécifiquement dans le développement web. À ce niveau-là, je suis plutôt polyvalent et capable d’apprendre assez aisément. Ce qui m’importe toutefois aujourd’hui concerne plutôt le champ de compétences que je souhaite être capable de couvrir en totale autonomie. J’ai relevé trois points principaux (vous remarquerez que j’aime bien ce chiffre !) ainsi que quatre transversaux pour arriver à un total de sept compétences que je pourrai mettre en œuvre au sein d’un projet.

Des compétences fondamentales pour définir mon métier

Tout d’abord, je souhaite monter en compétences dans le domaine de l’acquisition des besoins métiers orientés utilisateurs. Je pense que c’est une démarche saine que de d’abord chercher à comprendre les enjeux d’un métier et en mesurer sa complexité avant de développer une solution logicielle. Cela permet notamment d’être force de propositions pertinentes. J’ai par ailleurs trop souvent vu des clients qui fonçaient bille en tête avec une idée bien définie, sans questionner les usages des autres utilisateurs et utilisatrices. J’ai dans ces moments-là eu l’impression de ne développer que pour une personne et que l’outil ne serait jamais pleinement utilisé ou adopté. Je crois que ce n’est pas une démarche toujours évidente que de questionner un client sur ce qu’il a muri en lui-même, en particulier en tant que développeur, et de lui faire comprendre que sa solution n’est pas forcément la meilleure pour tout le monde. Il sera essentiel que je sache établir une confiance quant à ma capacité à comprendre le métier.

Ensuite, la deuxième compétence que je saurai mettre en pratique au sein d’un projet est celle du développement logiciel. Comme je le disais plus haut, il s’agit d’un domaine où je suis polyvalent et capable d’apprendre ; c’est le cœur de mon expertise aujourd’hui. Je suis à l’aise à la fois en frontend comme en backend. Je connais un certain nombre de bonnes pratiques en matière de déploiement automatisé/continu et connais relativement bien les problèmes qui peuvent se poser aux administrateurs système. J’essaye notamment de mettre en pratique les recommandations de la méthodologie « The Twelve-Factor App ». Ainsi, lorsque je développe une fonctionnalité, je pense à ce qu’elle deviendra une fois en production. Dans cette optique, j’essaye aussi de faire en sorte que ce que je développe arrive le plus rapidement possible en production afin d’éviter un décalage trop important entre mon code et la base initiale. En terme de langages, cela a relativement peu d’importance pour moi vu que je suis capable d’apprendre si la situation le demande. J’ai toutefois plus d’expérience en Ruby (très orienté Ruby on Rails), Python, JavaScript et PHP. Il s’agit là de compétences que je maîtrise suffisamment pour être autonome sur un projet sans aucun soucis. Bien entendu, mon code s’accompagne de tests et je fonctionne souvent en TDD (pour Test-Driven Development). Par ailleurs, j’ai un attachement particulier aux logiciels simples, qui ne cherchent pas à faire trop de choses et dont on peut fouiller le code pour y trouver rapidement ce que l’on cherche.

Enfin, la dernière compétence fondamentale que j’aimerais mettre en application au sein des projets où j’aurai à intervenir porte sur l’accompagnement à la mise en place d’une méthodologie documentaire. J’en parlais lorsque je détaillais mes valeurs, la transmission des connaissances est primordiale pour qu’un groupe ne dépende pas de quelques personnes clés. Je crois qu’il y a aujourd’hui un manque énorme de culture écrite dans nos modes de fonctionnement (je l’ai retrouvé à différents niveaux professionnel et associatif) ou alors cette culture n’est pas orientée vers le partage et la conservation des connaissances. C’est un sujet que j’ai commencé à toucher du doigt et sur lequel j’aimerais véritablement progresser. Et pour progresser, rien de tel que de pratiquer. Les wikis et les blogs sont pour moi deux outils très puissants dans cette recherche du partage mais qui ont le défaut de figer la connaissance à un instant T. J’aimerais étudier des modes de fonctionnement qui font vivre cette connaissance, qui lui permettent véritablement d’évoluer dans le temps et qui replacent la documentation au centre des préoccupations.

Des compétences transverses, au bénéfice des projets

En plus des trois compétences fondamentales listées au-dessus et qui forment un tout dans la vie d’un projet, j’ai voulu ajouter quatre compétences que je peux appliquer de façon générale sur tout type de projet.

Tout d’abord, une communication que je décrirais de transparente. Je parlais plus haut de confiance à établir avec les client·es, cela passe avant tout par la communication (écrite comme orale). Il est notamment important de ne pas cacher des éléments dont on pourrait avoir « honte ». Par exemple, la production est tombée, on l’a réparée en catimini sans que la cliente n’en sache rien mais on la tient quand même informée de ce qu’il s’est passé, par transparence. Savoir communiquer peut notamment servir à désamorcer des sujets qui pourraient être tabous et donc dangereux dans la vie d’un projet. Afin de communiquer de façon efficace, j’essaye de me placer tout d’abord dans une position d’écoute. Cette position me sert à comprendre mon interloteur ou interlocutrice, comprendre comment il ou elle intéragit avec moi, quel degré de familiarité je peux me permettre, si elle est sensible à mon argumentaire ou s’il est plutôt fermé à des approches différentes. Ce n’est pas toujours chose aisée, mais en exprimant aussi ce que l’on ressent, en partageant les doutes qui peuvent surgir en nous, on arrive à poser un terrain propice à la collaboration.

La deuxième compétence dont je pense pouvoir tirer partie est ma capacité à rendre compte de façon claire et argumentée un travail que j’ai produit. Que ce soit à l’oral ou à l’écrit, j’essaye toujours de me rendre compréhensible et je n’hésite pas à reformuler si je sens que je ne suis pas clair. Cela peut toutefois me demander un certain temps de préparation pour me laisser le temps de répéter ou de me relire au minimum deux à trois fois. Je suis par ailleurs très attaché à la pratique de la langue française et j’aime jouer sur les nuances que peuvent porter des mots ou la construction d’une phrase. Cela peut paraître anecdotique vis-à-vis d’autres compétences, mais j’ai réalisé il y a peu que le fait de savoir exprimer correctement ses idées joue un rôle très important dans la façon dont on est perçu par les autres. Cela affecte notre capacité à convaincre et à être suivi.

Ensuite, la gestion de projet intervient à tout les instants d’un projet. Afin d’être efficaces, il me semble que les méthodes agiles sont idéales. Je n’ai commencé à pratiquer qu’en arrivant au sein de Sogilis où j’ai pratiqué un mélange de Scrum et d’Extreme programming, mais j’ai très rapidement saisi un certain nombre d’avantages que ces pratiques offraient. Ce que j’en retire avant tout, c’est le fait de partir du constat que nos méthodes de travail ne fonctionneront pas parfaitement au démarrage d’un projet, et donc d’intégrer dans le processus de travail les outils qui permettront d’améliorer et corriger le processus lui-même, en cours de route. De plus, et cela rejoint mon premier point, la communication est placée au centre des préoccupations ce qui permet une bonne compréhension des enjeux par tout le monde et facilite la détection des problèmes qui ne manquent pas d’arriver au fil de l’eau. Les méthodes agiles offrent donc un cadre sain et malléable pour gérer et faire vivre un projet, elles seront donc au cœur de ma façon de travailler.

Enfin, le dernier point que je souhaitais aborder est l’intégration aux équipes. Il est pour moi important de faire partie d’une équipe et de ne pas travailler dans mon coin. Cela aide à mieux communiquer (encore !), à partager les connaissances pour ne pas devenir indispensable et à améliorer la qualité du produit final. La confrontation des points de vue sur un sujet donné, un bout de code par exemple, aide à penser un problème sous différents angles et prendre du recul sur ce que l’on fait. Je n’ai quasiment jamais travaillé ces trois dernières années tout seul sur un projet, et même sur Lessy qui reste un projet très personnel, j’ai eu à cœur de demander conseil autour de moi. Je pense être capable de m’intégrer facilement à une équipe, mais cela dépend aussi beaucoup des personnalités au sein de l’équipe ; je ne saurais donc en faire une règle absolue.

Un objectif au service de ma raison d’être

Arrive donc le moment où je dois résumer les quelques 3 200 mots de mes deux articles abordant mon introspection professionnelle ainsi qu’un an de réflexions plus ou moins poussées, en une phrase d’accroche qui définira la façon dont je veux aborder mon travail durant les prochains mois et/ou prochaines années.

Après plusieurs reformulations, je suis arrivé à déterminer un objectif qui me convient plutôt bien :

J’accompagne les humain·es de notre société de demain dans une démarche de résilience en participant à la conception de leurs outils numériques et en les aidant à améliorer leurs méthodes de travail, le tout dans un esprit de sobriété.

J’ai essayé d’y insuffler un maximum d’éléments issus des étapes précédentes sans pour autant en abuser pour que le message reste clair. Tout d’abord, la notion de « société de demain » fait directement référence à un monde post-effondrement que j’évoquais dans mon article précédent. J’y fais aussi référence en tentant de dessiner une première esquisse d’une société que je souhaite résiliente et sobre. La sobriété fait aussi référence à ma volonté de développer des logiciels simples et « bidouillables ». Mes compétences sont lisibles au creux de mon objectif : la conception d’outils numériques et l’amélioration des méthodes de travail qui incluent les méthodes agiles et une démarche de documentation. Aussi, je m’inscris dans une position de complémentarité (à l’inverse d’être indispensable) des équipes déjà en place en « accompagnant », « participant » et en « aidant ».

Cet objectif pourra être amené à évoluer dans le futur, mais j’espère qu’il saura m’accompagner dans mes premières missions et qu’il permettra de poser sur la table des sujets de discussion que l’on aborde trop peu dans le monde de la technologie. J’espère qu’il véhicule correctement le message politique que je lui ai imaginé.

J’entrevois d’ailleurs déjà des limites à cet objectif très orienté vers un métier que je pense voué à être marginalisé à long terme. Métier par ailleurs pratiqué par et pour une population privilégiée dans le sens où elle possède et maitrise des outils informatiques. Je crois que ces outils doivent s’accompagner d’une démarche complémentaire au risque d’abandonner sur le bord de la route les personnes les moins à l’aise avec le numérique. L’informatique reste un outil à notre service, en aucun cas il ne s’agit d’une fin en soi. Je souhaiterai à terme évoluer vers un métier plus ancré dans le réel. Aujourd’hui je vais toutefois profiter des compétences acquises durant ces dernières années pour orienter le domaine au sein duquel j’agis (le développement logiciel, principalement) vers un horizon qui me semble plus enviable. Ce sera l’occasion aussi de rencontrer des personnes qui pourront me guider vers des voies que je n’imagine pas encore. Mon objectif, tout imparfait soit-il, est une image à cet instant précis de mes envies et une piste à explorer pour pouvoir imaginer et construire « autre chose » par la suite.

Avec cet objectif défini, je considère que le gros du travail introspectif est terminé. Il reste toutefois quelques étapes supplémentaires avant d’attaquer la refonte du site à proprement parler. J’aborderai dans le prochain article les deux derniers points de ma démarche, à savoir de quelle manière je souhaite communiquer et, enfin, la conception de l’architecture du site.

Introspection professionnelle : valeurs et raison d’être

2018-12-28T11:45:00+01:00

Comme je le disais dans un précédent article, la fin de cette année 2018 est pour moi l’occasion de reposer à plat mes motivations professionnelles. Si j’ai décidé de quitter mon emploi chez Sogilis afin de tracer ma propre route, c’est pour différentes raisons parmi lesquelles :

le sens que je ne trouvais pas à mon travail ;
des problèmes sociétaux qui me parlent de plus en plus (ex. urgence climatique, fractures sociale et démocratique) ;
mon implication dans Framasoft qui m’a fait réaliser la dimension politique qui sous-tend le développement logiciel ;
des rencontres multiples qui m’ont aidé à envisager mon travail sous un autre angle ;
de nombreuses discussions avec des amis proches qui n’ont fait que renforcer mes choix.

J’envisage aujourd’hui le travail que je peux fournir uniquement à travers un prisme politique (au sens d’engagement). Les logiciels que je conçois ont un impact sur les personnes qui les utilisent, il est important pour moi qu’ils fonctionnent à leur service et non pas contre eux.

C’est ce genre de réflexions que j’aimerais arriver à faire transparaître sur mon site. Le but est de le transformer en « vitrine » professionnelle en mettant en avant mes valeurs, mon mode de fonctionnement, mes compétences, etc. Mais avant d’entamer cette refonte, je souhaite passer par une phase de réflexions plus approfondie.

Le design de soi, ou l’introspection professionnelle

J’ai découvert le concept de « design de soi » il y a un peu plus d’un an grâce à Marie-Cécile Paccard lorsque je l’ai contactée par rapport à Lessy. Le but est d’effectuer un travail de recherche afin de mieux connaître ses aspirations et de mieux communiquer en conséquence. Vous pouvez en apprendre plus dans sa présentation ou via la présentation de Marie Guillaumet qui en a parlé lors de l’évènement Paris Web 2015.

J’étais personnellement un peu dubitatif sur ce que pouvait m’apporter concrètement une telle démarche. Je me suis toutefois prêté au jeu pour Lessy et le fait de voir émerger le contenu aussi naturellement pour la page d’accueil et les éléments destinés à la communauté m’a encouragé à retenter l’expérience sur moi-même (en le documentant, cette fois-ci !)

Sur le sens toutefois, je suis peu à l’aise avec l’expression « design de soi ». D’une part, le mot « design » continue de véhiculer une confusion avec le graphisme ; d’autre part, et de façon plus ennuyante, même en prenant le mot dans son sens de « conception », ce n’est pas tellement l’objet de la démarche. Cela pourrait en effet laisser penser que le « design de soi » vise à créer (concevoir) une nouvelle personne qui ne correspond pas forcément à l’ancienne. Or, je crois que le but est de tirer des traits qui nous correspondent, à la manière d’un caricaturiste qui cherche à représenter une personne à travers quelques caractéristiques qui ressortent. Dans la suite de ma série d’articles, je troquerai donc l’expression par celle d’introspection professionnelle. Dans mon cas, le but est bien d’identifier les traits de ma personnalité sur lesquels je souhaite communiquer dans un cadre professionnel.

Pour cela, je vais procéder en plusieurs étapes qui devraient me permettre de créer le contenu du site :

définition de mes valeurs ;
définition de ma raison d’être ;
définition de mes compétences ;
établissement d’un objectif personnel (c’est-à-dire comment j’honore ma raison d’être) ;
définition de mes moyens de communication ;
conception de l’architecture du site.

Le dernier point me permettra d’organiser les différents éléments qui auront émergé lors des phases précédentes et potentiellement d’en faire émerger de nouveaux.

Les deux premiers points sont traités dans la suite de cet article.

Des valeurs pour guider mes choix

J’ai en vérité entamé la première phase, celle de la définition de mes valeurs, il y a plusieurs mois. Je souhaitais voir comment la perception que j’avais de moi-même évoluait dans le temps, identifier les éléments qui revenaient, comprendre pourquoi je n’étais pas à l’aise avec d’autres, etc. À titre d’exemple, je n’ai pas conservé l’« éthique » dans mes valeurs car ça ne signifiait pas grand chose pour moi : tout le monde possède une éthique sans pour autant placer la même chose derrière. Revendiquer avoir une éthique est nécessairement perçu à travers un prisme différent selon les personnes avec qui j’intéragis.

À l’éthique, j’ai préféré le terme d’intégrité. Affirmer son intégrité permet de garder un cap et de faciliter la définition de ses priorités. Par exemple, j’ai comme conviction que les licences libres ainsi que le respect de la vie privée sont des conditions sine qua non pour qu’un logiciel soit réellement au service de ses utilisateurs et utilisatrices (c’est-à-dire qu’il fasse bien ce qu’on lui demande, sans malveillance). Vous ne me verrez donc pas demain accepter une mission qui ne respecte pas ces conditions parce qu’elle est mieux payée qu’une autre. Cette notion d’intégrité sera par la suite complétée par un manifeste qui détaillera mieux mes engagements.

Le respect dans mes échanges ou envers les utilisatrices et utilisateurs d’un logiciel m’apparaît ensuite nécessaire à toute relation. Rester à l’écoute, savoir exprimer ses sentiments, considérer la personne en face sur un pied d’égalité ; je n’imagine pas d’autre manière de fonctionner pour tirer le meilleur de mes échanges. D’un point de vue technique cela signifie aussi, pour moi, considérer les techniques d’expérience utilisateur et d’accessibilité comme intrinsèques à un projet, pas seulement comme des ajouts selon un budget sur lequel je n’ai pas la main. À l’inverse, d’un point de vue global, cela signifie prendre aussi en compte les externalités de ce que je développe : hors de question de développer un outil qui nuirait encore un peu plus à l’environnement par exemple.

Enfin, la transmission doit faire partie de chaque processus de création. Après avoir lu un peu autour du concept de compostabilité en septembre (via la super présentation de Claire Zuliani à Sud Web), j’ai mieux réalisé la finitude de notre présence au sein d’un groupe. Transmettre mes connaissances et mes compétences m’est alors apparu comme bien plus essentiel pour ne plus être un rouage « indispensable » sans lequel rien ne fonctionne. Mécaniquement, j’ai le sentiment que cela pousse aussi à plus d’humilité. Nous devenons uniques non pas par nos compétences techniques mais par notre vécu.

En me limitant à trois valeurs, je me suis forcé à creuser toujours plus ce qui compte vraiment pour moi. J’ai écarté plusieurs points qui me tenaient à cœur mais que je n’arrivais pas à définir correctement (notamment le principe de remise en question). Ces valeurs sont évidemment fluctuantes : il s’agit d’un travail sur moi-même à un instant T et je m’attends à redéfinir leur contour dans le futur. En revanche, je ne pense pas m’en départir à moins de changer fondamentalement la personne que je suis.

Une raison d’être pour comprendre où je vais

Se trouver une raison d’être n’est pas la chose la plus évidente à faire. C’est pourtant une question qui me taraude depuis un moment car elle questionne sur le sens que l’on souhaite donner à sa vie. Lorsque j’ai pris une année sabbatique en 2015, c’est quelque chose qui m’a travaillé sans que je n’y trouve une réponse qui me convenait.

Ces derniers mois ont toutefois été plus efficaces, au point que j’arrive à la résumer en une courte phrase : concevoir les outils dont la société aura besoin demain. Pour comprendre cette raison d’être, il me paraît important de bien définir ce dont je parle.

Tout d’abord, lorsque je parle de « concevoir [des] outils », je fais le choix conscient de ne pas utiliser le terme de « développer ». Pour moi, un logiciel n’est pas une fin en soi. Il y a avant tout une phase d’acquisition des besoins et de réflexion qui peut notamment mener à la conclusion qu’un outil informatique ne serait pas une bonne solution. Cela implique aussi que je dois étendre mes compétences au delà de la technique informatique, en acquérant notamment plus de compétences liées à l’expérience utilisateur. Je dispose pour cela de précieuses ressources, notamment deux articles de Raphaël Yharrassarry : « Compétences UX et modèle en T » et « Se former en UX Design ? ».

Ensuite, lorsque je parle de « demain », j’y cache derrière la notion de « collapsologie » (ou d’effondrement). Je ne me suis pas encore énormément penché sur le sujet, mais il revient régulièrement dans les discussions qui m’entourent. Je ressens dans mes échanges une notion d’urgence et d’inévitabilité d’une société en mutation profonde. La question n’est pas forcément de savoir « quand ?», encore moins « si ? », mais plutôt « comment ?». À quoi ressembleront nos sociétés dites « modernes » dans un monde où les catastrophes écologiques prédominent, où la faune et la flore fondent comme neige au soleil et où les mouvements migratoires s’accélèrent ? Et si l’on se prenait en main pour imaginer nous-mêmes ce monde de demain et l’accompagner en douceur ? Il existe trois axes que j’ai identifié et dans lesquels j’aimerais m’investir :

accompagner l’inévitable désastre écologique ;
aider les populations en lutte pour affirmer leur légitimité aux yeux du reste de la société ;
repenser nos espaces démocratiques et l’expression du pouvoir.

Vaste programme que celui-là, j’ignore encore quelles formes peuvent prendre mes actions dans chacun de ces domaines mais je ne me fais pas de soucis pour savoir identifier les missions qui entreront en résonance avec ces sujets.

Enfin, le tout fait référence à ce qui se produit dans la sphère technologique depuis des années : les outils qui sont conçus n’émanent pas de réels besoins mais le deviennent une fois bien installés. Apple est notamment championne dans ce domaine, imposant avec brio et comme évidentes des technologies comme le smartphone ou la tablette. On peut toutefois questionner leurs répercussions sur notre société comme une accoutumance à l’instantanéité ou une addiction aux écrans difficiles à jauger. C’est le fameux « temps de cerveau humain disponible » qui est attaqué ici. En vérité, le futur de nos sociétés est aujourd’hui dessiné par des sociétés commerciales qui souhaitent avant tout vendre leurs produits plutôt que de réfléchir au bien commun ; cela me gêne tout particulièrement.

Une conclusion partielle pour préparer une suite plus concrète

Ce premier article était un peu abstrait : je n’ai abordé ici que des sujets qui me serviront de base pour construire le futur contenu du site. Cet article m’est apparu un peu pompeux à plusieurs reprises lors de sa rédaction, mais je crois que le résultat est avant tout un travail honnête sur mes aspirations et me permettra réellement d’affirmer ma manière de travailler avec d’autres personnes.

Je crois ces engagements indispensables dans nos sociétés toujours plus numériques, où nous perdons peu à peu la main sur nos données et leur traitement. Je suis partisan de réinsuffler plus d’échanges humains et une vision positive dans nos vies numériques, et donc nos vies tout court.

Cet article a une saveure particulière pour moi car j’ai réussi à y condenser toutes les réflexions que je mène depuis plusieurs mois ; réflexions notamment alimentées par mes échanges au sein de Framasoft qui est, pour une bonne partie, à l’origine des graines qui commencent à germer sur ce site.

Le prochain article devrait aborder des sujets un peu plus concrets et mener notamment à la rédaction de contenu qui apparaîtra par la suite sur le site.

Suivre le Boop! blog

2018-12-13T11:10:00+01:00

J’ai décidé de faire vite pour ajouter le flux d’actualités à Boop!, mon générateur de sites statiques, et c’est donc chose faite. Vous pouvez désormais vous abonner à ce site en ajoutant l’adresse dans votre agrégateur d’actualités préféré (qui devrait être capable de trouver l’adresse du flux tout seul, si si, mais si ça ne marche pas le flux est accessible ici).

Petit retour sur comment je m’y suis pris.

Distinguer les pages des articles

La première étape à laquelle je me suis trouvé confronté a été de distinguer les pages (en l’occurence, la page d’accueil) des articles. Jusqu’à maintenant, je n’avais pas eu besoin de faire une telle distinction, mais je ne veux pas me trouver avec la page d’accueil dans mon flux RSS. Pour cela, j’ai réorganisé toute la structure des répertoires, en m’inspirant cette fois-ci de ce qui pouvait se faire dans Jekyll (au lieu de Pelican qui me servait de base jusqu’à maintenant).

Auparavant, tout le contenu du site était déposé dans un répertoire ./content puis copié dans ./output (via une phase de transformation dans le cas des fichiers Markdown), désormais la structure est la suivante :

un fichier index.html à la racine ;
les articles, nécessairement au format Markdown, sont dans un répertoire ./articles (c’est original) ;
le template des articles se trouve dans un répertoire ./templates (toujours très original) ;
les fichiers à copier tels quels, comme les fichiers CSS, sont placés dans ./static ;
et le tout est copié/généré dans un répertoire ./site.

Je trouve personnellement cette structure un poil plus compliquée que la précédente, mais beaucoup plus explicite sur les intentions de chaque répertoire. Vous pouvez voir à quoi cela ressemble en suivant ce lien.

Vous pouvez aussi voir le commit introduisant le changement sachant qu’il en existe quelques autres mais que je n’ai pas envie de faire un lien vers chacun d’entre eux.

Dorénavant, les articles sont donc identifiables aisément car déposés dans un répertoire spécifique. J’ai décidé, en plus de cela, de les abstraire dans une classe particulière (Article) pour qu’ils soient plus faciles à manipuler par la suite (voir le commit).

Récupérer les informations manquantes via la configuration

Les flux RSS et Atom demandent des informations supplémentaires que je ne pouvais pas encore récupérer, notamment l’URL et le titre du site. Je devais aussi figer certains attributs présents dans les métadonnées des articles Markdown comme le titre, l’auteur et la date de publication. Par ailleurs, j’ai voulu correctement gérer les fuseaux horaires sachant la complexité que cela pouvait être par la suite. Il me fallait donc aussi récupérer le fuseau de l’auteur (pour ma part, Europe/Paris).

Je suis tout d’abord parti sur un simple fichier de configuration au format YAML pour indiquer les informations générales du site et alimenter une variable configuration (voir le commit).

J’ai ensuite créé quelques méthodes sur ma classe Article pour accéder facilement aux informations stockées dans les métadonnées. Ça leur donne ainsi un rôle particulier et me permet de faire des manipulations dessus à la volée (voir le commit).

Enfin, les fuseaux horaires sont gérés grâce au paquet externe pytz. Connaissant la complexité du sujet, je ne me suis pas amusé à développer mon propre module donc, là encore, petite entorse à ma règle de ne pas dépendre de code externe.

Les informations sont toutes facultatives, des valeurs par défaut étant générées à chaque fois, mais il est tout de même recommandé de les renseigner.

Générer le flux Atom, enfin !

Avec toutes ces informations en main, je pouvais enfin générer le flux RSS tant attendu. Mais encore un petit choix à faire avant : il existe deux formats « concurrents » pour générer des flux d’actualités, RSS et Atom. D’un point de vue simple utilisateur, les deux se valent et les deux sont très bien supportés par tous les agrégateurs d’actualités. Mon choix s’est porté sur Atom qui se voulait être pendant un temps une amélioration de RSS, mais surtout parce que mon site précédent utilisait déjà ce format. Et pourquoi pas les deux ? Parce que ça ne servirait à rien et que j’ai mieux à faire de mon temps, tout simplement.

Il ne me restait donc plus qu’à générer un document XML suivant le format Atom et l’écrire dans un fichier dans le répertoire ./site (voir le commit suivi de près par un autre destiné à abstraire la génération du XML dans un module nommé Boopfeed).

Et voilà, plus qu’à incorporer un lien dans l’en-tête de mes fichiers HTML vers ce fichier Atom, et c’est terminé !

Dans la tête d’un développeur

Bien entendu, je n’ai pas développé tout cela d’une traite. Entre poser à plat les problèmes que posaient l’implémentation initiale, décider d’une nouvelle structure après plusieurs essais, réfléchir à la meilleure manière de récupérer les informations manquantes, etc., ce travail m’a pris une journée entière durant laquelle je n’ai pas chômé.

Si mon historique Git paraît relativement linéaire, c’est que j’ai pris le soin de le réécrire avant de le publier, cela pour deux raisons :

un rôle pédagogique, si de futurs développeuses ou développeurs veulent comprendre ce que j’ai fait, l’enchaînement des commits leur paraîtront plus logiques ;
un rôle de débogage, si jamais j’ai introduit des bugs à un moment donné, il sera plus simple de retrouver à quel moment et pour quelle raison.

J’ai d’ailleurs fonctionné de manière totalement inverse lors du développement. En effet, j’ai commencé à écrire le code générant le flux Atom, en mettant les valeurs manquantes en dur dans le code, puis en le retravaillant au fur et à mesure.

Je fais cette petite précision pour les développeurs et développeuses moins expérimenté·es qui pourraient se dire qu’il leur est impossible d’arriver à ce résultat de façon aussi directe. Ça l’est effectivement, mais pour les autres aussi !

La technique, c’est fini

Je suis donc arrivé à un point du développement de Boop! qui me satisfait. Il manque bien évidemment plein de choses, et notamment il n’est pas possible de créer des pages qui ne soient pas des articles ; cela viendra plus tard.

Je souhaite désormais me consacrer au contenu du site car il ne sert à rien d’avoir une belle vitrine si ce qu’il transmet est creux et vide de sens. Les prochains articles devraient donc porter sur des réflexions plus personnelles : quel but je souhaite donner à ma vie, quelles sont mes valeurs, quelles pratiques je compte appliquer, etc. ; tout cela pour concevoir une vitrine cohérente avec mes aspirations à la fois personnelles et professionnelles.

Simplifier la rédaction d’articles dans Boop!

2018-12-11T22:00:00+01:00

Fin octobre j’inaugurais la refonte de mon site web personnel en promettant d’expliquer pas à pas les étapes qui mèneraient à une nouvelle version de celui-ci. Le mois de novembre a cependant défilé bien plus vite que je ne le pensais. Mon chômage ayant débuté début décembre, je peux enfin replacer mes priorités sur les projets qui me tiennent à cœur. Alors reprenons.

Simplifier le balisage avec Markdown

La première chose qui m’a émerveillé lorsque j’ai appris à faire du web il y a quelques années, c’est qu’il suffisait d’écrire du texte dans un fichier et de l’ouvrir dans un navigateur pour avoir un site fonctionnel. Mais pour rendre ce site Internet lisible par les navigateurs, il est aussi nécessaire de structurer vos fichiers au format HTML. En soi rien de bien compliqué, mais cela peut vite devenir lourd. Un paragraphe, par exemple, doit être entouré de « balises » <p> :

<p>Mon paragraphe.</p>

Une liste quant à elle se définit de cette manière :

<ul>
    <li>Un élément de la liste</li>
    <li>Un autre élément</li>
    <li>Et un troisième</li>
</ul>

Personnellement, j’ai autre chose à faire que de toujours penser à définir correctement mes balises. C’est là que le Markdown rentre en jeu. Il s’agit aussi d’un langage de balisage, mais celui-ci se veut plus léger et naturel pour un humain. Mes deux exemples précédents deviennent ainsi :

Mon paragraphe.

Il n’y a aucun balisage, c’est normal. Et pour la liste :

- Un élément de la liste
- Un autre élément
- Et un troisième

De simples tirets, c’est beaucoup plus simple, non ? Ce fut donc la première amélioration que j’ai apporté à Boop!, mon générateur de sites statiques. Pour cela, il me suffit de tester l’extension d’un fichier, si celui-ci se termine par .md, je passe le contenu du fichier au parseur Markdown pour qu’il le transforme en HTML, puis j’écris enfin le résultat dans un nouveau fichier (voir le commit introduisant le changement).

Ce fut aussi l’occasion de déroger à ma règle non-officielle de ne reposer sur aucun code extérieur : j’avais mieux à faire que de réécrire un parseur complet de Markdown depuis zéro. Je me base donc sur le paquet Markdown, disponible via la commande pip.

Boopsy, mon système de templating

J’avais ensuite un autre soucis. En effet, je souhaitais que tous les articles partagent la même structure HTML et notamment :

le même fichier de style CSS ;
le titre de l’article dans la balise <title /> ainsi que dans une balise <h1 /> ;
l’affichage de la date de publication de l’article ;
des liens pour revenir à l’accueil en haut et en bas de page.

Pour cela j’ai pas mal tergiversé sur la meilleure manière de faire afin de répondre du mieux possible à mon besoin tout en limitant le plus possible le code à écrire. J’aurais pu me baser sur un système de templating déjà existant tel que Jinja2, mais j’avais envie de créer quelque chose de plus simple.

Après avoir longuement lu l’article de Ned Batchelder, « A template engine » sur AOSA, et avoir joué un petit peu de mon côté, j’ai sorti un système de template (nommé Boopsy) très simplifié par rapport à l’original : en à peine 60 lignes de code, j’avais déjà un système fonctionnel (voir le commit introduisant le changement).

Ce système est évidemment largement améliorable mais constitue une bonne première étape qui fait exactement ce dont j’ai besoin.

Encore un petit effort

Il va me rester une dernière petite étape à terminer avant de commencer à réfléchir au contenu du site : la génération du flux RSS des articles pour permettre de suivre ce blog facilement. Le reste des fonctionnalités que je pourrais envisager ensuite sont plutôt de l’ordre du confort et pourront attendre.

Je devrais en principe mettre moins de temps cette fois-ci pour donner des nouvelles !

Boop! Une introduction

2018-10-29T20:00:00+01:00

Cette fin d’année 2018 marque pour moi un tournant professionnel. Après avoir travaillé trois années chez Sogilis, j’ai décidé, pour diverses raisons, de sortir du sentier qui se dessinait devant moi pour me mettre à mon compte. Ce changement s’accompagne pour moi d’une nécessaire remise en question de mes motivations et engagements : à quoi souhaité-je consacrer mon temps ?

Pour accompagner ce cheminement, j’ai souhaité créer un nouveau site à partir de zéro. Si je ne sais pas encore exactement ce qu’il contiendra, je sais que j’ai envie de renouer avec mes premiers pas sur Internet : c’est-à-dire l’apprentissage et le partage de connaissances.

L’une des choses que j’ai tout de suite aimé en informatique, c’est cette capacité que l’on a de pouvoir nous forger facilement nos propres outils. Mon site Internet en est un que j’ai longtemps laissé de côté mais que je souhaitais ramener dans ma stratégie pour contrôler mon image numérique. Pour cela, j’aurais pu continuer d’utiliser Pelican que j’utilisais jusque-là, mais quelque chose me titillais : et si j’en profitais pour comprendre comment fonctionne un générateur de sites statiques ? La mécanique interne ne me semble pas si compliquée…

Un générateur de sites statiques, pour quoi faire ?

L’une des premières choses à laquelle j’ai pensé a été de me faire un site uniquement à base de HTML et CSS. Quitte à repartir de zéro, autant utiliser les technologies les plus simples du web ; aucun élément généré dynamiquement, uniquement du code moulé au clavier. Mais je me suis vite rendu compte que cela deviendrait très pénible à maintenir : un changement dans la structure HTML ? C’est toutes les pages qu’il faudra modifier. Un nouvel article ? Il faudra écrire le flux RSS à la main. Beurk.

L’avantage du générateur de sites statiques est qu’il peut rester léger tout en automatisant certaines tâches et en facilitant la maintenance. Certaines fonctionnalités deviennent toutefois plus compliquées à gérer, notamment la gestion des commentaires et la recherche, mais le compromis me semble acceptable.

Les premiers pas de Boop!

Je sous-entendais plus haut que je n’y connais rien en générateur de sites statiques. En vérité, Boop! a déjà quatre mois ! En effet, j’ai développé début juillet une première version destinée à générer ma galerie de photos (le code est disponible sur Framagit).

Son but n’était alors pas tout à fait le même, et comme il s’agissait surtout d’une preuve de concept, ça ne me dérange pas plus que ça de repartir de zéro. À terme, j’aimerais que les fonctionnalités de la première version soient intégrées dans ce que je vais désormais développer.

Implémentation d’une version zéro

Bien, maintenant que je sais que je veux me faire un site qui sera généré par un outil du doux nom de Boop!, il est temps de rentrer dans le vif du sujet : par quoi je commence pour obtenir une version zéro ?

Le principe de base d’un générateur de sites statiques est qu’il lit le contenu depuis un répertoire source, qui est passé dans une moulinette qui va transformer ce contenu en fichiers HTML pour les déposer ensuite dans un répertoire destination.

Pour cette première version de Boop!, j’ai décidé de rester extrêmement simple : les fichiers sources seront des fichiers HTML et CSS. Il n’y a donc pas besoin de les transformer et on peut se contenter de les copier dans le répertoire destination. Oui OK, ça ne sert à rien pour le moment, mais c’était histoire de me mettre dans le (petit) bain.

Le code écrit en Python est disponible sur Framagit avec le tag 0.0.0.

Les esprits taquins (et techniques) noteront peut-être que cette première version, aussi simple soit-elle, n’est pas exempt de bugs : on corrigera cela dans la prochaine version !

La mise en ligne du site

Une fois la version zéro de Boop! prête, il est temps de réaliser la première version du site. Une page HTML et un fichier CSS plus tard, le site est prêt pour être mis en ligne. C’est minimaliste mais ça fait bien le boulot tout en étant lisible.

Pour la mise en ligne, je dispose déjà d’un serveur web capable de servir du contenu statique (un serveur nginx), je n’ai qu’à ajouter une entrée DNS de next.marienfressinaud.fr vers mon serveur et ajouter le fichier de configuration qui va bien pour nginx :

# version simplifiée
server {
  listen 80;
  listen [::]:80;

  server_name next.marienfressinaud.fr;

  root /var/www/next.marienfressinaud.fr;
  index index.html;
}

Il ne me reste plus qu’à faciliter le téléversement des fichiers générés par Boop! sur le serveur. Pour cela j’ai créé un fichier Makefile contenant quatre règles :

build qui appelle Boop! pour générer le contenu ;
clean qui supprime les fichiers générés dans ./output ;
publish qui téléverse sur mon serveur avec rsync les fichiers générés ;
help qui affiche une aide générée automatiquement pour la commande make (si je ne dis pas de bêtise, cette commande est issue à la base de chez Marmelab).

Avec ça, j’ai donc désormais un site disponible à l’adresse next.marienfressinaud.fr. Rien de bien compliqué, mais on a déjà les bases pour la suite.

Prochaines étapes

La suite d’ailleurs, quelle est-elle ? J’ai déjà noté quelques besoins liés à l’écriture de cet article :

j’ai dû dupliquer la structure du HTML depuis le fichier index.html, si cela reste gérable avec deux fichiers, je vais vite avoir envie de factoriser mon code ;
pour l’instant j’ai ajouté le lien vers cet article de blog à l’accueil manuellement, ce serait bien si je pouvais automatiser cela ;
je n’ai pas de flux RSS, ce qui va se révéler nécessaire pour que des personnes extérieures s’abonnent au blog ;
lié à l’ajout d’un flux RSS, je vais devoir dissocier le contenu des articles de la structure HTML.

Lorsque cela sera prêt, je pourrai alors aborder des sujets moins techniques pour expliquer où je veux emmener ce nouveau site.

Nouvelle version de Lessy : Ara

2018-09-09T14:35:00+02:00

Quelques jours seulement après l’annonce de la version précédente, voici déjà une nouvelle version. Les deux derniers weekends ont été particulièrement productifs bien que n'abordant pas le cœur de métier de l’application.

Cette fois-ci, les améliorations ont autant porté sur l’interface que sur l’architecture technique. Les principales nouveautés d’un point de vue utilisateur sont :

la possibilité de réinitialiser son mot de passe en cas d’oubli ;
la possibilité de renvoyer le mail pour activer son compte ;
l’ajout d'une page de profil permettant de mettre à jour son identifiant, son adresse email et son mot de passe ;
il est également possible de choisir la langue de l’interface (anglais ou français pour le moment) ;
et la possibilité de supprimer son compte.

Autant vous dire que cela fait un petit paquet de changements.

Au niveau de l’architecture technique, j’ai revu l’organisation des composants de l’interface qui gèrent l’affichage des pages. Ce fut là aussi un gros morceau, mais nécessaire pour garder l’application maintenable sur le long terme. J’envisage d’écrire un article technique pour détailler ma façon de faire.

Cette version marque aussi la fin des travaux portant sur les « à-côtés » de l’application. Je les aurai donc répartis sur deux versions de Lessy, mais en réalité sur neuf mois à cause de la pause que j’ai prise dans le développement. Je vais donc désormais pouvoir me reconcentrer sur le cœur de Lessy en repensant le tableau de bord ainsi que l’accueil des nouveaux utilisateur·trices. Encore une fois, l’avancement est visible sur GitHub.

N’hésitez pas à me faire des retours sur les nouvelles fonctionnalités, comme elles sont toutes neuves, j’ai peut-être oublié de gérer certains cas particuliers !

Nouvelle version de Lessy : Aries

2018-08-30T17:45:00+02:00

Lessy a connu une période de ralentissement ces derniers mois, due à des raisons externes (fonctionnement qui me correspond globalement bien, des choses plus urgentes sur le feu et petit coup de fatigue). Cette pause dans le développement m’a tout de même permis de prendre un peu de recul sur l’outil et me permettra ainsi de réorienter certaines fonctionnalités qui existent aujourd’hui… peut-être. Autant ne pas trop s’avancer sur le sujet.

Malgré le ralentissement évoqué plus haut, j’ai tout de même avancé un petit peu sur quelques fonctionnalités, notamment :

une administration basique ;
la possibilité de bloquer les inscriptions ;
l’arrivée de conditions d’utilisation.

Cette dernière fonctionnalité m’a pris plus de temps que prévu, mais je suis assez fier de ce que j’ai fait. Les conditions en elles-mêmes sont accessibles sur lessy.yuzu.ovh. En résumé : je fais du mieux que je peux, mais je ne m’engage ni sur la qualité, ni sur la pérennité du service (je ne fais pas ça dans un cadre professionnel). Je m’engage évidemment à ne pas toucher à vos données personnelles ni à les revendre.

Pour celles et ceux qui avaient souhaité s’inscrire alors que j’avais fermé les inscriptions, ces conditions d’utilisation marquent la réouverture du service. Notez toutefois que je risque de les refermer au-delà d’un certain nombre d’inscrit·es (mais je ferai du tri avant dans les comptes non activés ou dans ceux qui n’auront pas accepté les conditions d’utilisation d’ici 6 mois).

Les prochains développements porteront sur un espace pour modifier son profil et sur la possibilité de choisir la langue de l’interface (enfin !). Vous pouvez suivre l’avancement sur le projet GitHub.

Je remercie encore une fois celles et ceux qui parlent de Lessy autour d’elleux, qui l’utilisent ou qui me suggèrent des améliorations. C’est aussi ça, contribuer :). Et merci à Sarah pour avoir pris le temps de relire mes conditions d’utilisation et Erwan pour… avoir essayé ;).

Un homme sans rêve

2018-05-31T00:10:00+02:00

Écrire un bouquin de 50 000 mots en un mois, c’était le défi que je m’étais fixé en novembre 2014. Ces mots, je ne les ai jamais publiés nulle part. Ils étaient pourtant là, couchés sur de multiples octets, ces 50 000 mots et le défi du NaNoWriMo relevé. Mais l’excitation redescendue, les deux pieds à nouveau sur Terre, il fallait se rendre à l’évidence : ce n’était vraiment pas terrible. Des fautes, des incohérences, des dialogues pourris, des éléments de l’intrigue avec lesquels je n’étais pas à l’aise… et même une intrigue pas intrigante pour un sou !

Pourtant, au milieu de tout ça il y avait forcément moyen de sauver quelques meubles. En 50 000 mots, il y a forcément des fulgurances, des choses qui fonctionnent mieux que d’autres, un ensemble de mots et de phrases qui « sonnent » bien. C’est en mars 2016 que je relus l’histoire d’Asmara, avec beaucoup de recul et que je reprenais un certain plaisir à me plonger dans un univers que j’avais créé (hey ! C’est pas rien non plus). Un chapitre en particulier (le dernier écrit) retint mon attention : il y avait matière à en tirer une mini-nouvelle.

Quelques relectures et corrections plus tard, elle était prête. Cela m’avait pris seulement 9 jours à retravailler ce court texte, mais il me fallut deux ans de plus pour trouver le courage de le publier. Alors voilà, je pose tout ça là, ignorant si ma nouvelle sera lue ou non. Pour moi il s’agit surtout de mener un peu plus loin ce que j’ai entamé il y a 3 ans et demi avec le NaNoWriMo, bien qu’il reste encore beaucoup de chemin à parcourir avant d’en dévoiler plus sur Asmara.

La nouvelle se nomme Un homme sans rêve et est placée sous licence CC BY.

fichier PDF
fichier EPUB
le dépôt Git (l’historique peut être intéressant si vous vous questionnez sur le processus de réécriture)

Ce chapitre/nouvelle est en fait une réinterprétation d’un chapitre de 1984 de Georges Orwell, toute ressemblance n’est absolument pas fortuite. Le défi lors de cette réécriture était surtout de travailler les dialogues et l’évolution psychologique du personnage. Comme la nouvelle s’inscrit dans un contexte plus global, il subsiste des références au reste de l’histoire que vous ne saisirez probablement pas. J’ai décidé de les conserver pour me laisser des pistes à explorer de nouveau lorsque je souhaiterai me replonger dans Asmara.

Je vous souhaite une bonne lecture !

Ce qui nous pousse au Libre

2018-05-01T16:00:00+02:00

Il y a quelques jours, Maiwann proposait dans un article, de réconcilier designers et logiciels libres. L’article ne manque pas d’intérêt, ne serait-ce que par ses suggestions d’actions. Bien que je partage bon nombre des constats, je souhaitais le « compléter » d’un point de vue de développeur. Je vous propose donc d’entamer une petite mise en perspective à travers mes expériences personnelles, que ce soit celles sur FreshRSS, Lessy, les actions menées au nom de Framasoft ou encore à travers les écrits que j’ai pu lire à droite à gauche.

J’ai décidé de découper ces réflexions en une suite de plusieurs articles (sans me forcer à tenir sur la durée). Et comme l’idée me trottait depuis un moment, j’en profite pour inaugurer une nouvelle catégorie sur ce blog intitulée « Libres ? ».

Le premier sujet que je souhaite aborder en est un que Maiwann n’aborde quasiment pas : pourquoi faire du logiciel libre ? J’aurais en effet aimé mieux comprendre ce qui motive des designers à vouloir contribuer au Libre. J’essaye donc dans mon article de faire le tour de ce qui peut pousser un développeur à en faire, sans prétendre être exhaustif.

Apprentissage

De l’article de Maiwann, la seule référence à une potentielle motivation se trouve au détour d’un paragraphe :

Lors de nos études, […] alors que nous cherchons à nous entraîner, sur notre temps libre ou pour des projets de fin d’année, nous nous plaignons de ne connaître aucun développeur avec qui co-créer des sites ou logiciels.

Voilà une raison qui devrait parler à bon nombre d’étudiants et d’étudiantes ! Appliquer ce que l’on a pu apprendre en cours et donc, par extension, apprendre par la pratique est souvent moteur chez les développeurs. J’ai moi-même développé un certain nombre de programmes avec cette simple motivation. Par exemple, Minz fut ma tentative de comprendre le fonctionnement interne des frameworks web. FreshRSS a été l’occasion de travailler véritablement en communauté, et donc en équipe travaillant à distance et asynchrone. Petit aparté : paraît-il que ce mode de travail est compliqué à mettre en place dans les boîtes, mais cela se fait très naturellement sur les projets communautaires ; peut-être y a-t-il des choses à en tirer ? Sur Lessy, j’ai pu consolider tout un paquet de connaissances que j’ai ensuite pu proposer et appliquer au boulot. Le logiciel libre est une formidable source d’apprentissage que je recommande fortement à toutes et tous.

Cela étant dit, considérer l’apprentissage comme seul moteur dans le développement d’un logiciel libre est bien entendu extrêmement réducteur et j’aurais tendance à dire que ce n’est pas la raison principale (bien qu’il s’agisse probablement de la porte d’entrée principale pour bon nombre d’entre nous). Cherchons donc ailleurs d’autres raisons qui nous poussent, nous développeurs et développeuses, à produire du logiciel libre.

Plaisir

Dans le prologue du bouquin L’Éthique hacker, Linus Torvalds explique les motivations des hackers derrière le système d’exploitation Linux comme ceci :

La raison pour laquelle les hackers derrière Linux se lancent dans quelque chose, c’est qu’ils trouvent ça très intéressant et qu’ils veulent le partager avec d’autres. Tout d’un coup, vous avez le plaisir parce que vous faites quelque chose d’intéressant et vous avez aussi le pendant social.

Il nous dit plusieurs choses ici. Tout d’abord, le développement d’un tel système relève avant tout du plaisir. Et il est vrai qu’on peut se demander ce qui pousse des milliers de développeurs à partager leurs savoirs et leur temps, généralement de façon gratuite, si ce n’est le plaisir de le faire ? D’ailleurs Pekka Himanen (l’auteur du bouquin) cite un peu plus loin Éric Raymond, à l’origine de la popularisation du terme « open source » (j’aurai l’occasion de revenir sur ce terme plus tard) :

La conception de logiciel et sa mise en œuvre devraient être un art jubilatoire, et une sorte de jeu haut de gamme. Si cette attitude te paraît absurde ou quelque peu embarrassante, arrête et réfléchis un peu. Demande-toi ce que tu as pu oublier. Pourquoi développes-tu un logiciel au lieu de faire autre chose pour gagner de l’argent ou passer le temps ?

On y retrouve la notion de plaisir à travers le « jeu haut de gamme ». Je prends souvent l’exemple du Sudoku ou de la grille de mots-croisés : il n’y a, à priori, aucune raison de remplir ces cases de chiffres ou de lettres, si ce n’est le plaisir de résoudre un problème, parfois complexe. Je trouve personnellement que le développement de logiciel peut amener à un état de satisfaction similaire lorsqu’on se trouve face à un problème et qu’on arrive finalement à le résoudre après plusieurs ~~heures~~ ~~jours~~ semaines de recherche.

D’un point de vue personnel, j’ai toujours été attiré par les domaines de « création ». J’ai immédiatement accroché au développement lorsque j’ai découvert que créer un site web était aussi simple que créer un fichier texte avec quelques mots dedans. Les balises HTML ? un simple jeu de légo. Le CSS ? quelques directives de base à connaître et on arrive rapidement à quelque chose de totalement différent. Un serveur web ? un ordinateur avec un logiciel spécifique qui tourne dessus. Un bug ? une « chasse » durant laquelle on déroule le programme qui nous semblait si logique au moment de l’écrire (mais qui l’est maintenant beaucoup moins !). Pour moi, la beauté de l’informatique réside dans sa simplicité et sa logique : il y a un véritable plaisir à comprendre comment toutes ces petites boîtes s’agencent entre elles et que tout devient plus clair.

Partage

Si l’on se tient aux notions d’apprentissage et de plaisir, il n’y a rien qui distingue le logiciel libre du logiciel propriétaire. Vous pouvez très bien apprendre et éprouver du plaisir en développant du code fermé. Il nous faut revenir à la citation de Torvalds pour commencer à percevoir ce qui les différencie :

[…] ils veulent le partager avec d’autres.

Le partage : on a là une valeur fondamentale du logiciel libre qui ne trouve pas véritablement son pendant du côté du logiciel propriétaire. Bien que j’ai plus de mal à identifier clairement ce qui peut motiver l’être humain à partager ses savoirs, c’est quelque chose que je ressens effectivement. Cet aspect coopératif — Torvalds parle d’un « pendant social » — peut créer ou renforcer des liens avec d’autres personnes ce qui rend cette activité profondément humaine.

Partager, c’est donc transmettre. Transmettre à une communauté, donner les clés pour que celle-ci soit indépendante. Partager ses savoirs qui permettront peut-être à d’autres de bâtir autre chose par-dessus. Cela permet aussi de créer du lien humain, rencontrer des personnes et ouvrir ses perspectives en créant son propre réseau. C’est aussi s’offrir un coin de canapé quand on voyage (coucou Alex 👋). Je me suis rendu compte assez récemment de ce que m’offrait aujourd’hui cette décision en IUT de partager les petits programmes que je pouvais développer sur mon temps libre. La liberté n’est pas que celle du code.

Il y a certainement une forme de fierté à avoir exploré un domaine le premier, ou développé une application que d’autres vont utiliser (« Quoi ? Ce que j’ai fabriqué de mes propres mains t’est aussi utile ? »). Si cette fierté est par essence un peu narcissique (je suis toujours un peu pénible lorsque je suis cité chez NextInpact ou chez Korben 😇), elle est aussi bénéfique car elle encourage à rendre son travail public et donc… partager encore.

Éthique

On retrouve aussi cette notion de partage dans les écrits de Richard Stallman lorsqu’il nous parle des quatre libertés du logiciel :

Elles sont essentielles, pas uniquement pour les enjeux individuels des utilisateurs, mais parce qu’elles favorisent le partage et la coopération qui fondent la solidarité sociale.

Ces mots, pris du point de vue de Stallman, sont bien évidemment à interpréter sous la dimension éthique (et donc politique) du logiciel libre, ce qui n’est pas forcément le cas de Torvalds (je ne saurais néanmoins l’affirmer). Puisque Stallman est à l’origine du mouvement du logiciel libre, on ne peut évidemment pas enlever l’éthique de son équation ou alors vous obtenez de l’open source (comme il l’explique dans l’article cité plus haut). On peut toutefois raisonnablement penser que les partisans du logiciel libre sont moins nombreux que ceux de l’open source, ce que j’explique par une peur ou un désintérêt envers cet objet politisé.

Je trouve toutefois dommage de ne pas plus s’y intéresser. En effet, la dimension éthique aide à répondre à une question que beaucoup de personnes peuvent se poser : « ce que je fais au quotidien a-t-il du sens ? ». Stallman y répond par la défense et le respect des utilisateurs et utilisatrices :

Le mouvement du logiciel libre fait campagne pour la liberté des utilisateurs de l’informatique depuis 1983.

Ou encore :

Pour qu’on puisse dire d’un logiciel qu’il sert ses utilisateurs, il doit respecter leur liberté. Que dire s’il est conçu pour les enchaîner ?

Si je souhaitais conclure par cet argument, c’est parce qu’il aide à boucler la boucle avec l’article de Maiwann. En effet, en tant qu’UX designer, elle va avoir à cœur de répondre aux besoins de ses utilisateur·trices et donc d’imaginer des mécanismes pour rendre l’outil le plus utilisable et accessible possible. Aujourd’hui il me semble percevoir dans cette communauté un mouvement de prise de conscience que ces mécanismes doivent respecter (on y revient !) les personnes utilisant le logiciel. Cela est superbement bien illustré par la vidéo « Temps de cerveau disponible » (de la série « (Tr)oppressé » que je recommande vivement) dans laquelle un ancien employé de Google, expert en éthique, témoigne :

Le but est de capter et d’exploiter au maximum l’attention.

Il l’illustre ensuite par le lancement automatique de l’épisode suivant sur Netflix et par le défilement infini sur Facebook ou Twitter (incitant de ce fait à parcourir son fil d’actualité dans son ensemble) ; ces petits riens qui font que nous revenons sans cesse à ces applications et nous en rendent dépendant alors qu’elles n’ont d’intérêt que de nous divertir.

L’un des problèmes que j’identifie aujourd’hui est que le logiciel libre copie beaucoup (trop) ce qui se fait dans le propriétaire, et en particulier chez GAFAM et consorts… jusque dans leurs mécanismes nocifs. On peut ici reprendre l’exemple du mécanisme de défilement infini que l’on retrouve chez Mastodon ou Diaspora (et même sur FreshRSS !). Une certaine forme de dépendance peut donc s’installer au sein même de logiciels libres.

Convergence des buts ?

Les designers peuvent aujourd’hui nous aider, développeurs et développeuses, à repenser l’éthique de nos logiciels en replaçant les usages au centre de nos préoccupations et en imaginant et proposant des mécanismes permettant « d’endiguer » ce flux permanent d’informations qu’il nous faut ingurgiter.

Elles et ils peuvent aussi nous aider à atteindre véritablement nos utilisateurs en rendant nos outils utilisables et… utilisés. Car un logiciel non utilisable peut-il véritablement être considéré comme Libre ? Je ne peux m’empêcher de faire ici le parallèle avec l’association Liberté 0 qui a pour objet de « sensibiliser et de promouvoir le numérique libre et accessible à toutes et tous ». Dans leur charte, il est explicité :

Les membres du groupe « Liberté 0 » considèrent que la liberté d’exécuter un programme n’a de sens que si celui-ci est utilisable effectivement.

L’association est donc dans cette même démarche de promouvoir l’utilisabilité des logiciels, au même titre que les UX designers (mais sous le prisme de l’accessibilité).

N’y aurait-il pas ici une convergence des buts ? N’existe-t-il pas un lieu où nous pourrions nous regrouper tou·tes ensemble pour imaginer des outils autres que ceux issus du « capitalisme de surveillance » ?

Merci à Maiwann pour sa relecture attentive !

Nouvelle version de Lessy : Aquila

2018-01-27T17:35:00+01:00

J’ai désormais adopté un petit rythme de croisière quant aux sorties des nouvelles versions de Lessy et je peux donc annoncer la sortie de la version Aquila.

Cette nouvelle version n’apporte pas énormément de nouvelles fonctionnalités mais le mois de janvier a tout de même été chargé pour moi.

Tout d’abord, l’amélioration phare de cette nouvelle version est l’arrivée d’un mécanisme pour synchroniser différents navigateurs : concrêtement, si vous modifiez une tâche dans un navigateur, cette modification sera aussitôt répercutée si vous avez ouvert Lessy dans un autre navigateur. Cette fonctionnalité est encore expérimentale et elle n’est pas aussi aboutie que ce que je souhaiterais, mais elle impliquait un gros changement dans l’infrastructure du projet (un serveur Redis est maintenant nécessaire). Je souhaitais donc m’en occuper avant d’aller plus loin dans le développement.

Ce qui m’a le plus occupé au final est le soudain coup de projecteur qu’a reçu le projet au début du mois avec la parution d’un article chez Korben. Celui-ci n’a pas eu pour effet de faire tomber mon serveur (ouf !) mais a permis une augmentation du nombre de retours ainsi qu’une apparition temporaire dans le trending Ruby de GitHub. Les retours que j’ai eu ont été particulièrement intéressants puisqu’ils m’ont fait réaliser que je suis encore très loin d’avoir l’outil idéal que je souhaite développer et qu’il y a encore beaucoup à faire malgré le travail réalisé jusqu’à maintenant. Les efforts à fournir vont aussi bien se situer au niveau des fonctionnalités, de l’ergonomie ou encore de l’accueil au sein de la communauté.

Je suis tout de même ravi qu’au bout de seulement un an le projet obtienne un tel coup de projecteur, ça avait été plus compliqué pour FreshRSS par exemple (qui par contre vit très bien aujourd’hui sans mon implication). J’espère que l’intérêt manifesté saura se transformer en contributions actives et régulières ! Merci au passage à toutes celles et tous ceux qui m’ont fait des retours et/ou ont contribué d’une façon ou d’une autre (commentaires dans les tickets GitHub, ouverture de pull requests, etc.)

La prochaine version verra l’apparition d’une administration afin de me permettre de mieux surveiller ce qu’il se passe sur le serveur. Aujourd’hui il y a quelques 2200 comptes sur lessy.yuzu.ovh, dont la moitié ont été activés. J’en profite pour rappeler l’existence d’une page sur Liberapay si vous souhaitez participer aux frais du serveur (merci au passage aux trois valeureux donateurs actuels).

J’ai aussi ouvert un espace sur Framateam si vous souhaitez venir discuter du projet directement avec moi. J’aimerais que les échanges sur celui-ci se déroulent essentiellement en anglais puisque c’est la langue par défaut que j’ai choisi pour le projet, mais un canal pour les Français a été ouvert donc n’hésitez pas à venir et vous présenter !

Pour terminer, je remercie Gavy pour avoir ouvert une notice sur Framalibre à propos de Lessy, non seulement ça permet de faire vivre ce projet historique de Framasoft, mais en plus ça permet de faire encore un peu plus connaître Lessy :).

Nouvelle version de Lessy : Aquarius

2017-12-29T12:15:00+01:00

À peine plus d’un an après l’écriture des premières lignes de code de l’application, je sors la septième version de Lessy. Nom de code : Aquarius.

La principale amélioration qui m’a le plus été demandée est la suppression des contraintes sur les noms des projets : c’est désormais fait ! Il reste des bricoles à peaufiner pour que ça ne pose plus du tout de soucis mais je verrai en fonction des retours.

Ensuite, trois nouveautés liées aux tâches font leur apparition.

Tout d’abord, les tâches liées à des projets non démarrés ne sont plus listées dans le backlog : le projet n’étant pas démarré, inutile de s’encombrer l’esprit avec des tâches qu’on n’a pas besoin de réaliser. Il est toutefois toujours possible de les planifier pour le jour même en se rendant dans le projet, auquel cas celles-ci reprendront le comportement initial. Toutefois, afin de ne pas oublier ces tâches, un indicateur a été ajouté à côté des projets non démarrés.

La seconde nouveauté est que l’on peut désormais changer le projet auquel est attachée une tâche. Très utile si comme moi vous oubliez de créer vos tâches à partir des projets. La dernière nouveauté est la possibilité de transformer une tâche en projet en deux clics. Si vous vous rendez compte que vos tâches sont plus compliquées que prévu, c’est sans doute qu’il faut les redécouper ; vous pourrez maintenant transformer celles-ci en projet puis leur créer des tâches associées ! Ces deux fonctionnalités sont disponibles à partir du menu contextuel, à droite des tâches.

D’autres améliorations mineures sont aussi disponibles, le tout est détaillé dans l’annonce sur GitHub.

Suite à la sortie de la version précédente (Apus), j’avais annoncé avoir ouvert un compte sur Liberapay. Suite à cette annonce, trois personnes m’ont fait le plaisir de participer aux dépenses liées à Lessy à hauteur de 1,35 € par semaine. Merci à elles et eux ! Plus que 65 centimes par semaine et les frais du serveur + nom de domaine seront couverts :).

La prochaine version (Aquila), ne sera pas énorme mais devrait voir l’amélioration de la synchronisation backend - frontend. Plus besoin de rafraîchir votre navigateur sur PC si vous avez modifié des choses depuis votre tablette, tout devrait se faire automatiquement !

Lessy Apus

2017-11-26T17:00:00+01:00

Après un mois de travail il est enfin temps pour moi de sortir cette nouvelle version : Lessy Apus !

Je dois bien avouer que je ne savais pas trop où je mettais les pieds en démarrant cette refonte complète. J’ai failli me contenter de publier un guide de design et de faire la migration des différents composants au fil de l’eau. Mais un problème s’est rapidement posé. Souhaitant que le guide reste au plus proche du code, celui-ci a été développé directement au sein de Lessy. De ce fait, modifier le guide signifiait aussi modifier le reste de l’application. De fil en aiguille, je me suis ainsi trouvé à tout redévelopper.

Travail de longue haleine s’il en est, la refonte a consisté à :

créer un guide accessible sur lessy.yuzu.ovh/design ;
réécrire (tous) les composants de base pour qu’ils correspondent aux règles édictées dans le guide ;
réorganiser le code pour le rendre plus modulaire et plus maintenable ;
mettre en place des tests automatisés pour l’interface (très basiques pour le moment) ;
revoir un certain nombre d’éléments ergonomiques (des boutons plus explicites, une meilleure gestion des erreurs, des comportements moins surprenants, etc.) ;
corriger de nouveaux bugs ou identifier des problèmes de performance (sinon c’est pas marrant) ;
repenser la page d’accueil pour la rendre plus accueillante et présenter le projet.

Il existe toujours des éléments dont je ne suis pas entièrement satisfait, mais l’essentiel est là, le reste suivra durant les prochains jours. Je suis en tout cas extrêmement satisfait d’avoir désormais un guide de design qui rend ce dernier plus facile à faire évoluer et rend plus difficile de sortir des clous.

J’ai profité de sortir cette version pour ouvrir un compte sur Liberapay afin d’essayer de rembourser au moins les frais de serveur + nom de domaine puis éventuellement pouvoir plus tard me dégager un peu plus de temps pour le projet. Il y a mine de rien plus de 250 comptes ouverts sur lessy.yuzu.ovh dont quelques 65 activés, sachant que je suis très loin encore d’avoir mis en place tous les outils pour assurer un service satisfaisant. De la supervision ? Non. Des conditions générales d’utilisation ? Ah ah ! Des backups ? Ah ça oui ! Et ils fonctionnent ? Heuuu… Vous voyez l’idée donc.

Le service est toujours disponible sur lessy.yuzu.ovh, il reste ouvert et gratuit pour le moment, mais sans doute plus pour très longtemps donc. Le code reste hébergé sur GitHub et toujours (et à jamais) sous licence libre.

Pour la prochaine version (Aquarius), je reviendrai à du développement dans le dur en améliorant le lien entre les tâches et les projets.

Lessy Antlia

2017-10-31T13:30:00+01:00

J’expliquais dans mon article du 8 octobre que je souhaitais que Lessy soit un projet s’adressant à une large portion de la population non-geek. Pour cela, je voulais le rendre plus accueillant et plus communautaire. C’est pourquoi je suis très fier d’annoncer la sortie de Lessy Antlia (le nom de cette nouvelle version). Au menu, énormément de documentation.

J’ai passé les dernières semaines à travailler les valeurs que je voulais défendre avec Lessy. Après avoir dessiné, trié et organisé toutes les idées que j’avais en tête, j’ai abouti à une première version de la vision de Lessy (en anglais) :

Lessy is a time manager application built upon strong principles. It is designed to be as intuitive and inclusive as possible. Its goal is to return people their power to manage time, instil self-confidence and challenge their capacity to question themselves. It is built by a diverse and welcoming community.

On peut traduire cela par :

Lessy est un gestionnaire de temps basé sur des principes forts. Il est conçu pour être aussi intuitif et inclusif que possible. Son objectif est de redonner à ses utilisateurs et utilisatrices leur capacité à gérer leur temps, leur confiance en eux et leur capacité à se remettre en question. Il est développé par une communauté accueillante et diversifiée.

Cette vision est donnée en préambule du fichier README de Lessy et est immédiatement suivi d’une précision : toute fonctionnalité développée, toute discussion que nous avons au sein de la communauté, toute décision que nous prenons doit aller dans le sens de cette vision.

Voilà donc pour la mise en bouche. Je regrette souvent le manque de direction dans les projets communautaires qui mène bien souvent à des logiciels qui font beaucoup de choses mais qui manquent de personnalité. Avec Lessy, je veux donner un cap au logiciel et mes engagements personnels transparaissent dans cette vision. Lorsque j’ai commencé à développer cette application, c’était pour me redonner la main sur le temps qui m’échappait, alors pourquoi ne pas complètement l’assumer jusque dans l’ADN de Lessy ?

On m’a demandé l’autre jour en quoi Lessy est-il éthique. J’étendrais la question à en quoi Lessy correspond aujourd’hui à la vision que je viens de donner. Et c’est vrai qu’en utilisant Lessy on voit difficilement une application éthique, inclusive, redonnant un peu de pouvoir à ses utilisateurs et utilisatrices ; tout au plus une todo-list un peu originale. Et c’est effectivement le défi que je me donne pour les mois à venir : faire transparaître la vision dans l’interface. Cependant, je ne pense pas être capable de faire cela à moi seul et c’est pourquoi je voulais rapidement me concentrer sur la documentation communautaire. Cette documentation contient donc désormais :

le README, véritable porte d’entrée du projet ;
un fichier de contribution expliquant comment participer à Lessy, j’ai pris le soin de lister une majorité d’activités ne nécessitant pas de connaissances en développement informatique ;
un code de bonne conduite pour assurer qu’aucun comportement déplacé ne sera jamais accepté au sein de cette communauté ;
une liste des contributeurs pour remercier celles et ceux ayant contribué de près ou de loin au projet.

La documentation technique a elle aussi été largement revue pour aborder plus de sujets différents.

J’espère que tous ces documents sauront attirer une population hétérogène de contributeurs et contributrices, bien que je ne me fasse pas d’illusion : il faut désormais que je me bouge pour rendre l’application réellement attrayante.

Tout cela m’a pris beaucoup de temps à rédiger, surtout que tout a été fait en anglais alors que ce n’est pas ma langue de prédilection. J’ai fait ce choix volontairement en me disant qu’il serait plus facile de trouver des personnes souhaitant contribuer en visant large qu’en visant un public uniquement francophone. De plus, j’ai le sentiment que les Français·e·s sont de plus en plus à l’aise avec l’anglais. Seul l’avenir me le dira !

Lessy : versions et itérations

2017-10-29T10:00:00+01:00

Je me suis intéressé ces derniers jours au système de sortie des nouvelles versions de Lessy. Cela peut paraître étonnant, mais décider d’un tel système est parfois compliqué et pose plusieurs problèmes.

Pour commencer, on peut se poser la question « pourquoi versionner ? ». J’y vois personnellement quatre intérets en particulier :

montre que le projet vit (marketing) ;
donne une indication sur le niveau de modifications au sein du logiciel depuis la version précédente (dépendances) ;
permet de revenir à une version plus ancienne en cas de soucis avec la nouvelle (sécurité) ;
donne l’occasion de célébrer quelque chose au sein de la communauté (motivation).

Lorsque je travaillais encore sur FreshRSS, nous nous étions souciés de la question de la visibilité. Nous avions alors trois versions distinctes : une stable, sortant à intervalles plutôt longs, la bêta qui sortait tous les… hum… deux mois (?) et la version de développement. Nous avions décidé de mettre en avant la version bêta qui était alors moins testée que la version stable mais qui avait l’avantage de garder les utilisateurs accrochés à « l’actualité » de FreshRSS. Ce système avait toutefois le désavantage d’être lourd à maintenir. Je souhaitais par conséquent un système plus simple pour Lessy tout en continuant de mettre en avant le travail quotidien effectué.

Concernant le deuxième point, à savoir que le versionnage donne une indication sur le niveau de modifications depuis la version précédente, je pense évidemment au système « semantic versioning ». Si ce système possède un intéret évident dans le cas de dépendances (ex. le logiciel A dépend du logiciel B dans sa version X), je ne le vois pas dans le cas d’un logiciel en « bout de chaine » tel que Lessy. C’est pourquoi je suis parti sur un système de nommage totalement différent.

La raison consistant à donner des numéros de version pour permettre de revenir en arrière en cas de soucis me paraît évidemment légitime bien que le cas se présente à mon avis de façon assez rare.

Enfin, sortir une nouvelle version est loin d’être uniquement une tâche technique. Il s’agit avant tout de fêter une nouvelle étape franchie dans le développement et de marquer d’une pierre blanche l’avancement pour pouvoir constater plus tard tout le chemin parcouru. Célébrer une nouvelle version, ça motive énormément !

Concrêtement, comment cela va-t-il se passer pour Lessy ?

L’ensemble des tâches à effectuer (fonctionnalités, tâches techniques, corrections de bugs, etc.) sont listées en vrac dans les tickets GitHub, ce qui me sert par conséquent de boite d’entrée. Ces tâches sont ensuite triées par petits groupes au sein d’itérations représentées par les projets GitHub. Les tâches d’une itération forment un ensemble de fonctionnalités ou tâches techniques similaires et leur temps de développement total effectif ne doit pas être excessif (je me fixe 2 ou 3 semaines comme maximum). Ces itérations permettent ainsi de dessiner une pseudo feuille de route du projet. Et comme chacune d’entre elles est nommée (d’après les constellations astronomiques), la fin d’une itération donne son nom à une nouvelle version de Lessy.

Ainsi, des quatre points que je listais plus haut, seule la problématique des dépendances n’est pas du tout adressée. Pour les trois autres :

marketing : des versions sortent régulièrement et leurs noms sont plus sympas qu’un simple nombre ;
sécurité : revenir à une version antérieure est évidemment toujours possible, renforcé par le fait que chaque « commit » dans « master » peut être considéré comme stable ;
motivation : savoir qu’une itération est courte par principe permet de savoir qu’à la fin du mois je pourrais éventuellement passer à autre chose. De plus sortir une version est un processus relativement simple.

Pour terminer, si j’ai choisi de nommer les versions de Lessy par les noms des constellations astronomiques, c’est avant tout parce que je cherchais un système de nommage original permettant de penser à autre chose qu’à seulement du code. Comme lever le nez du clavier ne suffit pas toujours à se changer les idées, je me disais que le lever vers le ciel serait une bonne idée.

Project Zero devient Lessy

2017-10-08T21:00:00+02:00

Il y a quelques jours, j’ai annoncé sur Mastodon que Project Zero devenait officiellement Lessy, il était temps je l’officialise aussi sur ce blog. La raison est multiple et je vais essayer de la détailler ici.

Pour rappel, Lessy (donc) est un gestionnaire de temps à base de gestion de projets et de liste de tâches.

Tout d’abord, cela fait maintenant neuf mois (clairement pas à plein temps !) que je travaille sur ce projet. Cela me prouve que je suis motivé par son développement, d’autant plus que j’ai tout juste gratté les fonctionnalités dont j’ai envie/besoin. Project Zero m’est devenu au fil des mois un outil indispensable. J’en parlerai probablement dans un autre article, mais en très bref, j’ai réussi grâce à lui à démarrer (et mener à bien) plusieurs projets que je laissais trainer depuis des années. Aussi, depuis mai, ma liste de tâches n’en contient plus datant de plus de deux semaines, ce qui est une grande victoire pour moi !

De l’usage de cet outil, j’en ai tiré un tas d’idées un peu en vrac et j’avais besoin de remettre un peu d’ordre dans tout cela. C’est pourquoi j’ai voulu faire appel à une personne sensible à ma démarche et qui pourrait m’apporter un regard extérieur. J’ai eu la chance le mois dernier d’avoir les retours et idées de la part de Marie-Cécile Paccard qui est, en ~~deux~~ quatre mots, UX designer à Lyon. Cela a eu pour effet de rediriger mes efforts vers une toute autre direction… pour le mieux ! En effet, nous avons commencé à identifer ensemble une liste de valeurs et de « missions » que pouvait se donner Project Zero. J’ai ensuite continué de mon côté pour essayer d’identifier un objectif qui n’est pas encore totalement défini (le travail est encore en cours). En revanche, j’ai déjà une bonne vision de l’ensemble et l’un des éléments qui est revenu plusieurs fois est la notion de réduction de la « charge cognitive ». Ce sera en effet l’un des points fondamentaux qui dirigeront les développements futurs du projet. J’y reviendrai en détails dans un futur article.

En parallèle de ce travail, je me suis rendu compte qu’il était essentiel que j’obtienne plus de retours, plus variés, afin de faire émerger d’autres besoins essentiels. Il est important pour moi que Project Zero soit utile à une portion importante de la population non-geek, j’ai donc pour objectif d’orienter mes prochaines actions pour rendre le projet plus accueillant, plus communautaire. C’est pourquoi les deux prochaines « itérations » (j’y reviendrai aussi) seront orientées vers une documentation plus aboutie pour les nouveaux venus et une interface plus accueillante. Dans un tel contexte, le nom devenait donc important pour ne pas rebuter les gens.

Project Zero devient donc Lessy. Le nom ne me plaisait pas depuis le début : je l’avais plutôt utilisé comme nom de code, signifiant qu’il faudrait que je commence par développer celui-ci avant d’attaquer un autre projet. Il était clair depuis le début qu’il ne serait pas définitif. En devenant Lessy, je souhaite faire passer la notion de « moins » (i.e. less en anglais) : moins de stress, moins de charge cognitive. Je souhaite que ce nom soit apaisant en quelque sorte. De plus, Lessy est un nom particulièrement court, qui se retient et qui n’est quasiment pas utilisé aujourd’hui ce qui permettra d’en faciliter le référencement sur Internet.

Le nouveau dépôt de code est toujours sur GitHub (github.com/marienfressinaud/lessy) mais le service que je mets (pour le moment, gracieusement) à disposition s'est déplacé vers l’adresse lessy.yuzu.ovh. Ceci dit, ne vous jetez pas dessus, c’est toujours aussi moche.

Project Zero 0.3

2017-07-23T21:00:00+02:00

Un mois et demi après la 0.2, je suis très content d’annoncer la sortie de la version 0.3 de Project Zero. Pour rappel, il s’agit d’un gestionnaire de projets et de tâches avec un fort parti pris sur la façon de gérer tout cela.

Le code source se trouve sur GitHub, sous licence MIT et vous pouvez l’utiliser sur zero.marienfressinaud.fr, en attendant de migrer vers un nouveau (sous-)domaine que j’ai (enfin !) acheté.

Les nouveautés

Lorsque j’ai annoncé le mois dernier ce que je comptais inclure dans la prochaine version, j’avais prévu toute une liste de choses à faire : « meilleure gestion des petits écrans, emails de rappel, joli logo, amélioration de l’ergonomie et refonte du design, éventuellement ludification ». De tout ça, je n’ai quasiment rien retenu pour me concentrer sur ce qui comptait vraiment dans mon usage, l’idée étant que je l’utilise réellement au quotidien.

Premièrement, le « responsive design » était quasiment primordial vu que j’utilise beaucoup Project Zero sur tablette, voire sur téléphone. Ce n’est pas encore parfait, surtout sur mobile, mais tout est fonctionnel.

Ensuite, j’avais absolument besoin de lier des tâches aux projets pour m’assurer qu’ils avancent correctement. En effet, jusqu’à maintenant ma liste de projets servait surtout de déco et beaucoup d’entre eux dépassaient leur date de fin. Désormais, avec les tâches associées ainsi que les deux indicateurs qui viennent avec, il est désormais beaucoup plus facile de savoir ce qui avance ou non. Les indicateurs sont de deux types :

le nombre de tâches terminées vs. le nombre de tâches associées, cet indicateur devient orange s’il n’y a aucune tâche à faire et est rouge s’il n’y a aucune tâche associée ;
une barre de progression montrant où l’on en est (càd. le jour courant) par rapport à l’échéance de fin.

Ces deux indicateurs se sont révélés indispensables pour mon usage.

Une fonctionnalité de la version 0.3 s’est en revanche montrée moins utile. En effet, les tâches non terminées le jour même se retrouvaient dans une « pending list » qui n’était pas facilement accessible. De ce fait, je perdais de vue bon nombre des tâches qui se trouvaient donc non résolues. J’ai décidé de renvoyer ces tâches dans le « backlog » dans le but de toujours démarrer une journée avec une liste de tâches vide. J’en ai profité pour rendre les tâches du « backlog » directement plannifiable ce qui a rendu le bouton « What will you work on today ? » inutile. C‘est donc un écran qui a sauté.

En résumé, il n’y a plus que deux listes de tâches : la liste du jour même et le « backlog ». Chaque début de journée, vous pouvez aller piocher dans celui-ci les tâches que vous pensez pouvoir réaliser le jour même.

Pour terminer, une fonctionnalité pas tellement essentielle mais que je trouvais sympa : une page de statistiques permettant de retracer sur les 15 derniers jours le nombre de tâches créées comparé au nombre de tâches terminées. Cela permet de me rassurer sur le fait que j’avance dans ce que j’ai à faire.

Pour les plus vigilants, vous noterez que le style est très proche de celui des graphiques GitHub (ceux de l’onglet « Traffic »).

Avec cette nouvelle version, j’ai désormais un outil pleinement fonctionnel pour mon usage quotidien. Je vais désormais sans doute mettre un (petit) coup de frein au développement du projet pour préparer un gros morceau : l’amélioration globale de l’expérience utilisateur et la mise en place d’une charte graphique pour le projet. Je ne sais pas encore quand je pourrai faire cela et il n’est pas impossible que je développe deux trois fonctionnalités autres, mais ce n’est pas dans mes priorités immédiates.

Project Zero 0.2

2017-06-05T21:10:00+02:00

Après une version 0.1 sortie fin janvier, je sors aujourd’hui (avec seulement un mois de retard) la version 0.2 de Project Zero, mon mini-système de gestion de projets et de tâches.

Le code source se trouve sur GitHub, sous licence MIT et vous pouvez toujours l’utiliser sur zero.marienfressinaud.fr. L’adresse n’a pas (encore) changé mais passe désormais en HTTPS.

Les nouveautés de la 0.2

Cette nouvelle version apporte la gestion de listes de tâches (ou « todo lists »), fonctionnalité dont j’avais le plus besoin. J’utilisais auparavant Todoist qui me convenait plutôt bien, mais je souhaitais un système plus proche de mon mode de fonctionnement. Qu’apporte vraiment Project Zero par rapport à n’importe quel autre gestionnaire de tâches ?

Tout d’abord, l’ajout des tâches a été pensé pour se faire le jour même. La plupart du temps, en arrivant le matin au boulot, je me prépare une liste des choses que j’aimerais régler pendant la journée. Quel meilleur moment pour savoir ce que l’on souhaite faire que le matin ?

Bien sûr, il m’arrive aussi souvent d’avoir des idées de choses à faire que je ne réaliserai pas le jour même, pour cela une seconde liste appelée « backlog » vient s’ajouter à la première dans laquelle je peux venir piocher pour préparer ma liste de la journée.

Les tâches que je n’arrive pas à terminer sont marquées en attente et viennent alimenter une troisième liste. En préparant ma liste de la journée, les tâches non réalisées la veille me sont proposées à nouveau et je peux soit indiquer que je l’ai en fait déjà terminée, soit la replanifier pour aujourd’hui. Si je la replanifie, un indicateur est incrémenté. Cet indicateur me sert à me prévenir que j’ai trop replanifié une tâche et me propose au bout de 2 fois de découper la tâche ou de la renommer pour la rendre plus facile à terminer.

Un second indicateur particulièrement utile pour les tâches du « backlog » indique le nombre de semaines depuis que la tâche a été créée. Au bout de 2 semaines, l’indicateur me propose d’abandonner la tâche vu qu’il y a de fortes chances que je ne la termine jamais.

Ces deux indicateurs me permettent d’éviter de conserver des tâches pendant trop longtemps. Cela me permet d’avoir un système de priorisation non basé sur une appréciation subjective mais basé sur le temps et sur la répétition ; ainsi je peux réordonner les tâches au fil du temps.

Les dates d’échéance ?

J’ai décidé de ne pas gérer les dates d’échéance. C’est encore une réflexion en cours car j’avais vraiment dans l’idée de les gérer mais j’ai finalement conclu à la non nécessité de la fonctionnalité. Une date d’échéance peut avoir deux significations :

une date limite permettant d’éviter que la tâche reste indéfiniment dans la liste, rôle déjà porté par les indicateurs ;
une date de réalisation et, dans ce cas, un calendrier fait très bien l’affaire.

De plus, j’avais peur de la complexité car cela m’aurait mené à devoir (vouloir ?) gérer la répétition des tâches dans le temps et la saisie intuitive des dates (taper « demain » pour saisir la date du lendemain par exemple).

En prévoyant la suite…

Cette nouvelle version apporte un gros morceau qui fait que Project Zero me devient de plus en plus utile. Pour autant, je n’ai pas encore vraiment le réflexe de m’y connecter et je n’y ai d’ailleurs pas du tout touché pendant le mois d’avril (ce qui explique le retard pris pour cette sortie). J’ai tout de même ajouté pas mal de choses en mai qui me facilite l’usage (ordonnancement, édition, abandon et indicateurs).

La version à venir (la 0.3 donc) me servira surtout à consolider ce que j’ai fait jusqu’à maintenant et devrait ajouter des mécanismes poussant à la « fidélisation » (meilleure gestion des petits écrans, emails de rappel, joli logo, amélioration de l’ergonomie et refonte du design, éventuellement ludification). Je n’ai aucune idée de la date de la prochaine sortie car j’ai d’abord besoin d’identifier ce qui bloque mon usage.

J’ai pas mal d’idées de ce que pourrait devenir Project Zero et des fonctionnalités qui pourraient m’être utiles, mais je souhaite vraiment monter ce projet petite brique par petite brique en m’assurant que le tout est utilisable et utilisé.

Project Zero 0.1

2017-01-29T19:00:00+01:00

J’en parlais lors de ma rétrospective 2016 sur ma méthodologie de travail, j’ai commencé à bosser sur une application qui devrait me servir de cadre méthodologique. Jusqu’à maintenant j’utilisais le système de fichiers de l’ordinateur pour organiser mes projets, mais c’était trop contraignant et je n’arrivais pas à assurer un suivi suffisant.

Après un mois de travail acharné, j’ai enfin terminé la version 0.1 de « Project Zero ». Le code source est disponible sur GitHub sous licence MIT et vous pouvez même vous créer un compte sur le service que je mets à disposition : zero.marienfressinaud.fr. Attention, l’application n’est pas encore disponible en HTTPS !

Pourquoi Project Zero ?

Cela fait longtemps maintenant que j’imagine un outil de gestion de mes projets. Bien sûr, je suis un éternel insatisfait des outils que j’utilise et il fallait absolument que je développe mon propre logiciel :). Comme il devait s’agir du projet à la base de tous mes autres projets, je l’appelais « Projet Zéro ». Fin 2015 je donnais un coup de frein à ma contribution à FreshRSS pour commencer à bosser sur ce fameux outil… chose que je n’ai jamais concrétisée car mes idées à l’époque n’étaient absolument pas claires sur ce que je voulais faire.

C’est en août, pris dans la tourmente de mes nombreux projets commencés mais dont aucun n’avançait, que je mettais en place quelques actions pour me reconcentrer sur ce que je faisais. Cela a donné une pré-version de ce que je voulais obtenir.

Fin décembre, voyant que ma méthodologie avait globalement bien fonctionné mais que j’avais toujours des soucis à assurer le suivi, j’ai dessiné les premiers écrans d’une application que j’ai donc nommé « Project Zero » (notez le passage à l’anglais).

Les (quelques) fonctionnalités

Il y a aujourd’hui très peu de fonctionnalités car je veux d’abord voir comment évoluent mes besoins. Je préfère avoir très peu de fonctionnalités qui me servent toutes que beaucoup qui ne me servent pas. Ce qu’il est possible de faire :

créer un compte (et s’authentifier, évidemment) ;
gérer ses projets (qui ne consistent qu’en un nom, une description en MarkDown et quelques dates) ;
démarrer jusqu’à trois projets en même temps en précisant une date de fin ;
stopper les projets qui stagnent ;
terminer les projets… terminés.

Il s’agit de la version 0.1 bien sûr, tout reste encore à construire… et j’ai pas mal d’idées pour ça :).

Sous le capôt

J’ai pas mal tergiversé avant de me décider sur les technologies à utiliser pour développer Project Zero. Voulant au départ découvrir de nouvelles choses, je partais sur un backend Django, le frontend en Elm et une API à base de GraphQL.

Mais plus j’hésitais plus je me convainquais que j’allais accumuler les difficultés et que je n’avancerais pas. Au final j’ai décidé de partir sur des bases que je connais et avec lesquelles je suis à l’aise :

Ruby on Rails pour le backend comme cela fait presque 1 an et demi que j’en fais quotidiennement, pas de difficulté à ce niveau ;
une API classique en Json, je savais que j’avais encore besoin de progresser là-dessus mais je n‘exclue pas d’inclure du GraphQL à terme ;
VueJS pour le frontend, pour le coup que je ne connaissais pas mais qui n’est pas trop éloigné conceptuellement de React.

Pour ce qui est de VueJS, la lecture de la documentation m’a convaincu que tous les problèmes que j’avais avec React allaient disparaître comme par magie… et ce n’est pas tout à fait faux :). Bien sûr d’autres questions se sont posées au fur et à mesure que j’avançais, mais je suis tout de même content du résultat ! L’époque où j’écrivais du JS imbitable sur FreshRSS est révolue :D.

Comme je le disais plus haut, le code est hébergé sur GitHub mais il n’est pas exclu que je le déplace sur Framagit. Ce qui me retient de le faire actuellement est de deux ordres :

j’ai dans l’espoir de trouver une troisième solution. Le but de Framasoft n’étant pas de tout centraliser sur ses serveurs, j’aimerais aller voir ailleurs et de préférence chez un chaton local ;
GitHub reste à des années lumières de Gitlab au niveau expérience utilisateur. Gitlab a beau avoir des fonctionnalités (très) intéressantes, son interface reste foutraque et j’ai du mal à m’y faire.

Le service Project Zero

J’expliquais plus haut que j’ai mis à disposition un service à l’adresse zero.marienfressinaud.fr. Si l’adresse est temporaire, j’ai dans l’espoir que le service ne le soit pas. Je ne me fais pas trop d’illusions, actuellement Project Zero est beaucoup trop limité fonctionnellement pour être utile à qui que ce soit, mais je pense qu’à terme il pourrait plaire à quelques-uns.

Attention, le service est aujourd’hui ouvert à n’importe qui et gratuit, mais je n’exclu pas à terme de le rendre payant. On ne pourra pas dire que je n’ai pas prévenu ! Bien sûr le logiciel restera sous licence libre et je ne prévois absolument pas de version alternative « closed-source ». L’idée serait plutôt de rembourser les coûts du serveur et de mettre un petit quelque chose de côté pour me donner un peu plus de temps libre, absolument pas de faire fortune.

Mes idées pour la suite

Voici une liste non-exhaustive de ce que j’ai en tête pour le moment :

gestion de listes de tâches à faire (communément appelées « todo lists ») ;
gestion d’environnements pour distinguer les projets personnels des projets professionels ;
envoi de mails de rappels ;
gestion de sous-projets ;
client en ligne de commande pour notamment synchroniser des dossiers en local, ça permettrait d’avoir par exemple un dépôt Git en local associé à un projet ;
gestion du profil utilisateur et projets publics.

Ma priorité numéro 1 va être la gestion des tâches. J’utilise actuellement Todoist et j’en suis vraiment très satisfait. Ceci dit il y a parfois des petits bugs et je n’aime pas la façon dont il gère le système de karma qui pousse parfois à bacler des tâches seulement pour garder de bonnes statistiques. Et puis c’est toujours rigolo de redévelopper des choses qui existent déjà, non ? :). Je cogite encore pour réfléchir à comment m’y prendre et ne pas faire quelque chose de trop bâteau.

Les projets 2016 de Projet Zéro

2016-12-29T21:00:00+01:00

En septembre j’expliquais comment j’allais essayer de m’organiser pour enfin produire les choses qui me trottaient dans la tête. J’avais mis cela en place un mois plus tôt et je manquais donc nécessairement de recul dessus. Pour rappel, cette méthodologie repose sur les points suivants :

un carton contient l’ensemble de mes projets et est restreint par les quatre règles suivantes :
- je n’ai pas le droit de toucher ou d’avancer les projets qui sont dedans ;
- j’ai le droit d’en sortir trois maximum à la fois ;
- un projet sorti du carton ne peut pas y retourner avant une date limite que j’ai fixée au préalable (ou alors je dois l’avoir terminé) ;
- tout nouveau projet doit le rejoindre ;
chacun des projets en dehors du carton doit avoir un objectif ainsi qu’une date limite de fin ;
un article de blog est publié à chaque fin de projet.

Concernant ce dernier point, je n’ai publié que deux articles concernant mes projets durant ces 4 derniers mois… cela fait donc seulement 2 projets terminés sur pas moins de 7 projets ! Alors, que s’est-il passé ?

SogiMood, l’article qui a eu du mal à sortir

Bien que SogiMood soit un projet que je considère comme terminé, il n’en a pas moins été problématique. En effet, je l’ai terminé fin septembre (donc peu de temps après avoir expliqué ma méthodologie) mais son article est paru au début du mois de décembre. La raison est assez simple : l’article a été réécrit au moins 2 fois en entier et puis est resté en gestation un certain temps. J’ai d’abord eu du mal à trouver le ton et le contenu avant d’avoir l’idée de le proposer sur le blog de Sogilis. Après relecture et correction par les collègues, je me suis retrouvé trop occupé pour avoir vraiment la motivation de m’occuper de la publication finale. 1 mois puis 2 mois sont ainsi passés sans que je ne publie rien.

Conclusion : prévoir un article final n’est pas forcément une bonne idée et je pense que je ne me forcerai plus de la sorte à l’avenir.

Le dessin et le sport, stoppés par perte de motivation

En février je commençais à m’intéresser à la pratique du dessin et en août je me remettais une énième fois à aller courir, plus motivé que jamais.

Dans le premier cas, je me suis même acheté des bouquins et je souhaitais finir un livre d’exercices d’ici février prochain. La pratique assidue ne me faisait pas plus peur que ça et je voyais déjà mes progrès. Autre objectif : changer le dessin moche en arrière-plan du site par quelque chose de plus travaillé. Chaque année devait venir compléter et améliorer cette « fresque ». Je n’avais malheureusement pas pris en compte un élément fondamental : j’ai toujours eu horreur des exercices et je n’avais pas l’impression de m’amuser en suivant les instructions d’un bouquin. Cela a freiné net ma motivation et je me suis arrêté en septembre.

Dans le cas du sport, je ne vous referai pas la même rengaine de la motivation à bloc, etc. J’allais principalement courir le soir voire un petit peu les matins avec des collègues. En revanche, fin octobre, lorsque la nuit a commencé à se faire plus longue et que je n’avais plus le choix que d’aller courir de nuit, j’ai commencé à me démotiver pour faire une pause d’un mois en novembre. Au début du mois toutefois j’ai réussi à me remotiver pour… une seule séance avant de me restopper aussi net à cause de la pollution (bienvenue à Grenoble).

Quoi qu’il en soit, ce sont deux projets que j’ai encore à cœur et il est certain que je les reprendrai, peut-être sous d’autres formes pour ne pas me démotiver à nouveau.

J’ai en revanche abandonné la règle qui m’interdisait de replacer un projet dans le carton : ça n’a aucun sens de s’acharner sur un projet que l’on n’avance pas.

Contribution à Framasoft, les contours trop flous

Ici, à l’inverse des deux précédents, je suis encore sur ce « projet ». Je m’étais fixé plusieurs objectifs : contribuer à l’écriture des articles du lancement de la saison 3 de Dégooglisons, mettre à jour Framaboard avec quelques contributions upstream, aider au support et participer éventuellement à plus d’événements pour tenir les stands. Je souhaitais faire cela durant environ deux mois avant de repasser au régime habituel.

Ce qu’il s’est concrêtement passé, c’est que j’ai légèrement augmenté mon activité sur les projets Framasoft sans pour autant trouver la motivation de m’y impliquer autant que je le souhaitais. De plus, je bloque depuis fin septembre sur ma contribution à Kanboard pour faire en sorte de simplifier les mises à jour de Framaboard. À vrai dire je crois que je ne suis pas hyper emballé à l’idée de devoir faire du PHP ;). J’ai repoussé cela pour après les fêtes, en espérant que je sois plus motivé que pour le moment.

Framasoft reste un projet un peu particulier puisque j’essaye de contribuer tout au long de l’année, ne serait-ce que pour répondre aux questions sur le support ou pour participer aux évènements.

La morale de tout ça c’est qu’il faut que je me force à mieux définir ce que je compte faire au sein du projet pour me donner les moyens de savoir quand celui-ci est véritablement fini.

Voyage et Projet Zéro, les projets pas encore terminés

Pour finir, les projets qui sont en cours. Le premier est un voyage au Royaume-Uni : j’ai dû commencer les préparatifs assez tôt afin d’avoir une réduction sur mon billet Interrail et donc planifier des dates. Rien de très compliqué mais tout ça pour dire que je terminerai ce « projet » en juin, lorsque je serai revenu.

Concernant Projet Zéro, j’ai enfin attaqué une version applicative (web) afin de donner un cadre à ma méthodologie. Ma version actuelle ne me permet pas d’être suffisamment rigoureux dans l’avancement de mes projets et je souhaitais avoir un outil plus manipulable ainsi qu’un système de rappels. L’application est encore dans une version préliminaire mais j’en parlerai dès que j’aurai quelque chose d’utilisable. À l’inverse de Taglibro, je souhaite fournir une version hébergée et permettre à n’importe qui de s’y inscrire… mais j’y reviendrai !

Cela fait donc le tour de mes projets que je m’étais fixé sur cette moitié d’année 2016. Rendez-vous l’année prochaine si jamais je continue à appliquer ma méthodologie « Projet Zéro » :).

Taglibro

2016-12-21T19:00:00+01:00

Vers le milieu de ma seconde année en école d’ingénieur, j’avais eu l’idée un peu bizarre d’un réseau social anonyme. L’idée a longtemps trainé avant que je décide il y a peu de temps de sortir un premier jet de ce que j’avais en tête. Toujours dans le cadre de Projet Zéro, j’ai sorti une petite application en une semaine de boulot : Taglibro.

Je ne ferai pas de long article sur ce projet car il s’agit avant tout de répondre à un besoin personnel : celui de pouvoir consigner des pensées divers en un endroit. Voyez Taglibro avant tout comme un carnet de bord ou un journal intime (Taglibro en Esperanto). Je souhaitais penser l’outil pour un usage avant tout personnel.

Évidemment je n’ai pas fait grand chose en une semaine, juste ce qu’il faut pour permettre de saisir ses pensées, les lister et les publier. Quelques contraintes viennent s’ajouter à cela :

on ne peut publier qu’une fois par jour dans l’optique de favoriser les écrits de qualité (mais c’est quelque chose qui évoluera dans le futur) ;
les pensées publiques ne sont visibles que durant 24h avec dans l’idée de rencontres et d’échanges qui se font de manière ponctuelle ;
toutes les pensées sont anonymisées, aucun nom, aucun signe distinctif si ce n’est le texte que vous tapez.

Imaginez rencontrer un(e) inconnu(e) dans le train, discuter de tout et de rien, prendre du plaisir à parler avec cette personne. Le train arrive à la gare et vous vous dites au revoir. Ce n’est qu’une fois perdu de vue que vous vous rendez compte que vous ne savez pas le nom de votre inconnu(e). Tout ce que vous conservez, c’est cette sensation d’avoir passé un bon moment, riche en échanges, avec cette personne. C’est un peu cet état d’esprit que je souhaite faire émerger dans Taglibro. Exit donc tout système de popularité, tout ce qu'il reste ce sont des mots. Vous vous fondez dans la masse et personne ne sait qui vous êtes.

Pour les aspects plus techniques, Taglibro a été écrit en Rails, a été placé sous licence MIT et le code est hébergé sur GitHub. Pour le moment, le déploiement se fait automatiquement sur Heroku et c’est pourquoi je déconseille fortement l’utilisation de Taglibro, puisque Heroku repose sur AWS de Amazon et que ce n’est pas du tout « Dégooglisons Internet »-compliant ! (je ne partagerai même pas l'URL directement pour tout dire)

Bref, Taglibro n’a pour le moment pas beaucoup d’intérêt (si ce n’est pour moi) et je déconseille même son utilisation. Par contre je suis preneur de suggestions donc n’hésitez pas :).

SogiMood

2016-12-13T21:30:00+01:00

J’ai commencé cet été une petite application que je voulais utiliser dans le cadre du boulot. Le but était de surveiller la santé des projets sur lesquels nous travaillons. Comme on aime bien le logiciel libre chez Sogilis et qu’on est assez libre de faire ce que l’on veut, j’ai proposé de libérer le code de ce logiciel : SogiMood (oui, c’est original).

Il s’agit d’une application web avec un backend écrit en Go et un frontend écrit en ReactJS (il paraît que c’est « hype », c’est donc forcément bien) ; le code est placé sous licence MIT. Plutôt que de faire deux longs articles sur SogiMood, je vous invite à lire l’article que j’ai publié sur le blog de Sogilis où je détaille un peu plus le pourquoi et le comment de SogiMood.

En espérant que ça intéresse !

Note : ce projet s’inscrit dans ma démarche « Projet Zéro ». J’aurais dû publier cet article fin septembre mais comme j’attendais de d’abord écrire celui sur le blog de Sogilis et que je devais attendre mon tour pour être publié, cela a pris un peu plus de temps que prévu ;). En attendant je continue de gérer mes différents projets de la même manière que ce que je décrivais dans mon dernier article bien que cela demande un peu plus de rigueur que ce que j’avais imaginé à la base !

Projet Zéro/README.md

2016-09-14T20:00:00+02:00

Cela fait bien longtemps que je n’ai rien publié sur ce site. En toute logique et parce que je suis fait de plein de contradictions, j’ouvre aujourd’hui une nouvelle catégorie sur celui-ci : Projet Zéro.

Avant de présenter cette catégorie et de m’auto-persuader que je vais l’alimenter, un peu de contexte s’impose.

En septembre de l’année dernière, après un joli petit tour d’Europe, j’ai rejoint la société de services Sogilis (attendez, ce n’est pas ce que vous croyez !). Rejoindre cette boîte a été l’occasion pour moi d’apprendre beaucoup de choses : Ruby et Rails, JavaScript via React, approfondir mes connaissances de Git, me mettre à Vim sous l’impulsion des TupperVims, gratouiller du Go, apprendre et mettre en place pas mal de bonnes pratiques dans différents domaines, etc. Forcément, engranger toutes ces choses m’a donné des idées de projets et des envies d’améliorer ceux existants (si si, j’envisage toujours de revenir sur FreshRSS pour le faire évoluer :)). À côté de ça j’ai eu envie d’apprendre à dessiner, j’ai toujours des projets de nouvelles que je souhaite publier sur ce site et j’ai réussi à me motiver à aller courir régulièrement pour me remettre en forme. Si on n’oublie pas le fait que j’essaye toujours de contribuer aux actions de Framasoft en tant que bénévole, vous comprendrez qu’à un moment je ne savais plus où donner de la tête.

Il y a donc un peu moins d’un mois, après m’être dispersé une nouvelle fois dans un énième projet qui n’aboutira jamais, je me suis amusé à compter les différents projets que j’avais en tête. Après un court brainstorming pour coucher sur papier l’ensemble des choses que j’avais en tête, je finissais avec une grosse vingtaine de projets : des voyages, des nouvelles, des contributions à des logiciels opensource, d’autres plus personnels, etc. Un joyeux fourre-tout que j’ai entièrement rangé… dans un carton. À ce carton j’ai assorti quatre règles simples :

je n’ai pas le droit de toucher ou d’avancer les projets qui sont dedans ;
j’ai le droit d’en sortir trois maximum à la fois ;
un projet sorti du carton ne peut pas y retourner avant une date limite que j’ai fixée au préalable (ou alors je dois l’avoir terminé) ;
tout nouveau projet "méga-top-génial" doit le rejoindre.

Ce carton, c’est ma manière de m’empêcher de me disperser dans tous les sens. Ça fait maintenant un mois que j’ai mis cette méthodologie en place, je manque évidemment encore de recul dessus (j’ignore si cela va durer ou si cela est même efficace) mais j’en suis pour le moment entièrement satisfait.

Le plus intéressant dans la mise en place de ce carton c’est que je me suis rendu compte que j’avais en fait réalisé une première version minimale d’un projet qui se trouvait au sein même du carton ! Son petit nom, c’est « Projet Zéro ».

Projet Zéro part du constat que j’ai toujours trop de projets en parallèle : il me fallait donc un projet pour les gérer tous ~~et dans les ténèbres les lier~~. Projet Zéro c’était le premier projet que je me devais de terminer… Devant la tâche immense qui m’attendait, je n’ai néanmoins jamais trouvé le courage de m’y atteler. Son développement a été repoussé de semaines en semaines et les mois se sont transformés en années.

Alors cette première version de Projet Zéro n’est pas vraiment un logiciel que j’ai développé, mais il ne s’agit pas non plus d’un carton physique. Projet Zéro pour le moment, c’est un banal système de fichiers :

marien@pizza ~$ tree -L 1 ProjetZéro/
ProjetZéro/
├── Blog
├── Carton
├── Dessin
├── SogiMood
└── Sport

5 directories, 0 files

On y trouve 5 répertoires :

Carton/ est mon carton numérique contenant tous les autres projets (de simples fichiers texte) ;
Dessin/, SogiMood/ et Sport/ sont mes trois projets en cours. Chacun contient un fichier README.md qui décrit le projet, donne des liens utiles et fixe une date limite de fin ainsi qu’un objectif (celui qui me fera dire « j’ai fini ce projet ») ;
Blog/ est un raccourci vers les articles du blog. Je me suis dit que ce serait une bonne idée, à chaque fois que j’atteindrai un objectif (i.e. à chaque fin d’un projet), de partager mon expérience sur le blog. Il ne s’agit donc pas vraiment d’un projet mais d’une tâche transversale me servant à poser une vraie conclusion à mes projets.

Projet Zéro c’est donc pour moi le début d’une expérimentation qui se base sur trois points :

un carton contenant l’ensemble de mes projets et restreint par les quatre règles citées plus haut ;
trois projets maximum en dehors du carton avec chacun un objectif ainsi qu’une date limite de fin ;
un article de blog à chaque fin de projet.

Le prochain article ne devrait d’ailleurs pas trop tarder !

La v7 est faite !

2016-04-21T00:00:00+02:00

La précédente version du site qui tournait sous PluXML m’aura survécu plus de deux ans et demi, un record pour moi. Malheureusement, force est de constater que je ne publiais plus grand chose. L’envie me manquait certes un peu, mais j’avoue que devoir me connecter à une interface administateur m’a toujours beaucoup ennuyé alors que je pouvais rédiger mes articles tranquillement sur mon PC.

Écrire en Markdown, le transformer en HTML, vérifier que tout fonctionne, penser à téléverser les images sur le serveur : non seulement c’était casse-pieds, mais en plus c’était idiot ! En effet cela fait un an que j’ai mis en place un blog pour FreshRSS (certes pas très actif) tournant sous Pelican et j’avais déjà réalisé un thème auparavant pour ce moteur de sites statiques, pourquoi ne pas en profiter ?

Prenant mon courage à deux mains, j’ai donc réalisé un nouveau thème à partir de zéro. Objectif : faire quelque chose de simple et joli. Le résultat se trouve sous vos yeux. Pour l’anecdote, je bosse sur cette nouvelle version depuis janvier et j’ai d’ailleurs failli me convaincre moi-même de faire appel à un professionnel pour le design ! Ça aurait été tout de même dommage ;).

Profitant de ce changement je me suis dit que, tant qu’à faire, je pouvais bien faire le tri dans les articles. Ce sont donc 89 articles qui viennent vous dire au revoir. Les 33 articles qui ont survécu correspondaient tous à l’une des trois catégories du blog (informatique, nouvelles et vie du site) et possédaient un intérêt dans mon parcours personnel. Pour chacun d’eux j’ai pris le temps d’écrire un très court résumé (ok, ils sont pour beaucoup identiques), de réparer les liens cassés, de virer des parties plus du tout d’actualité et de corriger quelques fautes d’orthographe. C’était long, c’était fastidieux et j’espère bien que c’est la dernière fois que je fais ça !

Aussi, la partie blog se trouve reléguée en seconde partie du site. La raison est que si je n’ai pas envie de publier pendant plusieurs mois / années, cela se verra un peu moins que lorsque la liste des articles stagnait en première page :).

Pour terminer, je vous propose trois captures d’écran. Il s’agit respectivement des versions 3 (22 novembre 2011, merci Internet Archive), 6 (17 avril 2016) et 7 (21 avril 2016) de ce site.

Notez que le lien de l’ancien flux RSS est redirigé vers le nouveau.

Ray’s day : Celui pour qui sonnent les cloches.

2015-08-21T12:32:00+02:00

On y est, le « Ray’s day » c’est aujourd’hui. Initié l’année dernière par l’auteur Neil Jomunsi, l’évènement regroupe autour d’un site les différentes initiatives visant à promouvoir la passion de la lecture. L’occasion est donnée d’écrire, de lire, de découvrir et, surtout, de partager. Si vous êtes curieux — et vous l’êtes assurément, non ? —, je vous donne rendez-vous sur le site raysday.net.

En novembre dernier, souvenez-vous, je participais au NaNoWriMo. De cette expérience intense, je ne publiais qu’une liste d’intentions (oui, je publierai l’histoire dans X semaines / mois / années). Manque de temps, manque de confiance dans la qualité de mon écrit, prise de risques dans la rédaction qui me laissait dubitatif : je ne suis toujours pas prêt à publier le résultat. Un jour peut-être ?

En attendant, je profite de ce jour un peu spécial pour soumettre à votre lecture attentive un petit essai. J’ai décidé de partir d’une page blanche, d’une idée toute neuve — ou presque —, afin de ne me poser aucune limite. Le résultat ? Une nouvelle qui s’intitule Celui pour qui sonnent les cloches. Il s’agissait pour moi d’expérimenter une forme de récit un peu spéciale (vous comprendrez en lisant la nouvelle ;)) et j’ignore si le résultat est compréhensible ; je l’espère ! Il s’agit pour moi d’une première publication et j’implore donc votre indulgence ! :)

Je vous invite à télécharger le fichier PDF, le fichier EPUB (pour liseuses électroniques) ou encore les sources MarkDown de mon histoire sur Framagit. Celle-ci est publiée sous licence CC-BY. Si vous avez des retours à me faire, mon courriel pour l’occasion est raysday@marienfressinaud.fr.

De plus, l’opportunité m’a été donnée d’ajouter mon histoire à un recueil publié à l’occasion par les membres de Framasoft — dont je fais partie depuis janvier. Nous proposons ainsi 8 histoires toutes (ou presque) inédites. Je me dois de les remercier même si la visibilité donnée à ma nouvelle (et donc la pression :)) risque d’être plus importante que ce que j’imaginais au début.

Je vous souhaite un bon Ray’s Day à tous !

freshrss.org se dote d’un blog !

2015-03-07T10:06:00+01:00

Je l’avais annoncé dans l’article présentant FreshRSS 1.0, c’est désormais chose faite : freshrss.org possède son propre blog !

Par conséquent :

Cet article sera le dernier de ce blog parlant de FreshRSS ;
Cet article sera le dernier en français à propos de FreshRSS ;
Le flux RSS à suivre devient http://freshrss.org/feeds/all.atom.xml ;
Le processus d’écriture devient plus communautaire puisque les articles seront annoncés sur GitHub et pourront être rédigés à plusieurs.

Pour plus de détails, vous pouvez vous rendre sur le premier article paru !

Si vous avez des retours à faire, vous pouvez les faire sur GitHub.

Désormais les articles publiés ici seront beaucoup plus personnels, probablement liés dans un premier temps à mes voyages en France puis en Europe, sûrement peu à peu à mes projets d’écriture aussi. Le temps en jugera :).

FreshRSS un point zéro

2015-01-31T15:35:00+01:00

Elle est là, enfin ! La version 1.0 de FreshRSS, meilleur agrégateur à auto-héberger au monde (du moins selon moi), est sortie.

Ceux qui me suivent un peu savent que je tenais tout particulièrement à cette version. En effet, je ne pouvais considérer mon logiciel terminé sans cette version qui venait clôre un cycle particulièrement important de développement (deux ans et trois mois tout de même !). Cette nouvelle version vient changer un petit paquet de choses. J’expliquerai néanmoins dans un prochain article plus personnel pourquoi j’ai (un peu) précipité la sortie de cette version.

Les liens habituels :

Le site officiel : freshrss.org
La démo en version 1.0 : demo.freshrss.org
Le dépôt de code sur GitHub
Le bugtracker aussi sur GitHub

Les différentes versions bêta

Depuis fin septembre, quatre versions différentes sont sorties. La dernière fut la 0.9.4 sortie à la mi-janvier. Voici un petit tour des ajouts et modifications de chaque version.

FreshRSS 0.9.1

Sortie en même temps que la discrète 0.8.1, il s’agissait en fait d’une version de stabilisation. Pas grand chose de neuf si ce n’est des corrections de bugs et quelques ajouts au système de statistiques.

FreshRSS 0.9.2

Une version qui a demandé pas mal de boulot puisqu’il s’agissait de réécrire toute la partie de gestion des abonnements avec, notamment, la possibilité de réorganiser ses flux par « drag and drop ».

J’en profitai aussi pour revoir la colonne de gauche listant les catégories et flux lors de la consultation des articles. Plus jolie, plus pratique.

Les changements sous le capot n’étaient pas en reste car c’était l’occasion de réécrire des parties importantes comme l’authentification et la récupération des articles. Toute la partie coding style était aussi améliorée.

FreshRSS 0.9.3

Une version un peu moins conséquente que la précédente et pour cause, je participais au NaNoWriMo durant le mois de novembre. Je n’ai pas pu être aussi présent pour cette version. Néanmoins on a vu arriver un nouveau sélecteur de thème (made by @aledeg) et le nouveau thème BlueLagoon (made by @Mister aiR). Une fonctionnalité assez démandée arrivait aussi : la disparition des articles une fois lus.

Sous le capot, j’ai tout de même profité de la première quinzaine de décembre pour réécrire toute la partie qui gérait l’internationalisation de FreshRSS. Un travail long et pénible mais qui facilite pas mal la gestion des langues.

FreshRSS 0.9.4

Une version bien sympathique puisqu’elle apportait avec elle le système d’extensions. Celui-ci n’était pas aussi complet que je l’avais voulu mais ça m’aurait demandé tellement de travail que j’ai préféré le sortir un peu limité dès la mi-janvier. Quelques extensions sont disponibles sur Github.

J’en ai profité pour faire quelques gros changements sous le capot comme la réécriture du système de configuration et du système de partage (qui devrait encore évoluer dans le futur) et une réorganisation des fichiers utilisateurs.

FreshRSS 1.0.0

Pour ceux qui tournent en 0.9.4, vous ne verrez rien de très neuf. En effet, je n’ai pas voulu intégrer trop de changements pour éviter une version majeure toute cassée. La version 1.0 sera donc uniquement une version de stabilisation de la 0.9.4 avec quelques jolis et moins jolis bugs en moins (et notamment celui qui m’aura valu la plus belle prise de tête depuis que je fais du PHP).

Une nouveauté tout de même intéressante, c’est l’arrivée de l’Allemand comme langue supportée par FreshRSS ! (j’en reparle plus loin)

Mise à jour

Depuis la version 0.8.0, FreshRSS dispose d’un système de mise à jour automatique (et ça c’est la grande classe !). Aussi vous n’avez qu’à vous rendre dans l’interface d’administration pour lancer la mise à jour. Note importante : je déconseille fortement d’utiliser une autre méthode au risque de casser votre instance ! Seul le système de mise à jour automatique permet de mettre à jour facilement les fichiers situés dans votre répertoire ./data.

Précision : deux versions sont sorties en même temps, la 1.0.0 (stable) et la 1.1.0 (la même mais dans la branche bêta). Cela permet d’avoir une vraie distinction entre les branches et surtout de faciliter le processus de mise à jour.

La suite : un projet plus communautaire

J’en parlerai plus en détail dans l’article qui suivra mais je compte m’effacer un peu du projet FreshRSS afin de bosser sur d’autres choses et voyager. Je sais que ça sonne un peu comme un Mozilla annonçant l’arrêt des améliorations de Thunderbird ou les développeurs de Diaspora* annonçant leur retrait du projet qu’ils avaient initié, mais cela a plutôt bien réussi pour ce dernier. Comme il serait idiot que FreshRSS coule à cause de mon absence, j’ai déjà entreprit quelques taches pour rendre le projet plus ouvert aux contributions.

Tout d’abord, j’ai déplacé le dépôt de l’adresse https://github.com/marienfressinaud/FreshRSS à l’adresse https://github.com/FreshRSS/FreshRSS. Ça peut paraître assez peu mais cela m’a permis de donner les « clés » officiellement à @Alkarex et @aledeg qui peuvent gérer tous les dépôts associés à l’organisation FreshRSS. De plus cela a impliqué de détacher FreshRSS de mon nom : ça peut paraître assez égoïste mais je suis assez fier d’avoir eu ce succès avec cet agrégateur ; le lier à un compte « global » signifie que je ne suis plus qu’un contributeur comme les autres. Au final je suis content de ce choix qui permet de ne pas avoir une tête qui dépasse mais seulement un projet global avec des contributeurs, c’est la continuation logique d’un projet Libre selon moi.

La prochaine étape va être d’ouvrir un blog spécifique à l’actualité de FreshRSS plutôt que de publier ici.

Une tâche importante que je dois terminer va être de documenter conséquemment le code ainsi que les fonctionnalités pour favoriser les contributions externes. J’ai déjà commencé mais il faut finir maintenant.

Le fait que je me retire un peu du projet ne signifie pas non plus que je ne vais plus y participer : je continuerai de donner mes idées, mes avis et surement même quelques lignes de code. Je me propose aussi pour continuer de gérer les scripts de mise à jour et les sorties de version (mais j’écrirai des tutoriels pour faire ça).

Par contre très concrètement, j’aimerais désormais éviter que l’on me contacte directement par mail par rapport à FreshRSS (même si ça fait toujours plaisir ;)).

Pour conclure, j’ai une véritable volonté de faire de FreshRSS un projet plus communautaire. Je crois qu’il n’existe pas aujourd’hui d’agrégateur libre véritablement bati autour d’une communauté : Kriss Feed et Leed n’ont pas donné signe de vie depuis plusieurs mois, TinyTinyRSS est un gros projet mais son développeur principal est « assez peu ouvert » de ce que j’en ai compris et par contre je ne sais pas ce qu’il en est vraiment de selfoss. Dans tous les cas ces projets restent batis autour d’une personnalité et non pas du logiciel en lui-même.

Les remerciements

Comme à chaque fois, je tiens à remercier les différents contributeurs. En plus d’@Alkarex et d’@aledeg, @Alwaysin et @Draky50110 continuent toujours de beaucoup commenter, tester et donner leur avis. Leur présence permet de tester différents cas et trouver des bugs oubliés.

Nous avons eu aussi dernièrement une forte présence du côté de l’Allemagne avec deux articles coup sur coup et l’arrivée d’un contributeur (@ealdraed) qui a traduit l’ensemble du projet en très peu de temps. Une très bonne surprise !

Autre énorme surprise, celle d’avoir été cité en octobre sur le site opensource.com dans un article de blog présentant cinq logiciels (dont wallabag et shaarli). Trois jours plus tard c’était un tweet de @nixCraft (+40 000 abonnés) qui ramenait du monde.

Suite à la série d’articles qu’il y a pu avoir autour de FreshRSS, j’ai ouvert un ticket spécial listant ces articles. Vous êtes libres de pointer les votres ou ceux que vous croisez :).

Il y a encore des tas de personnes à remercier : dada pour ses articles, @plopoyop pour l’intégration dans Yunohost, toutes les personnes qui remontent des bugs, qui envoient des mails pour remercier et féliciter, Cyrille Borne qui a écrit quelques mots sur son (ses ?) blog, Mister aiR pour ses thèmes et ses idées de continuité du projet (avec @dhoko), Luc Didry qui a apporté des pistes pour améliorer l’aspect multi-utilisateurs… et tous ceux que j’oublie !

NaNoWriMo, deux semaines plus tard.

2014-11-18T00:09:00+01:00

Petite mise à jour par rapport au NaNoWriMo. J’avais prévu un article à la fin de la première semaine mais je n’ai jamais réussi à le terminer. Je l’ai donc jeté et commencé un nouveau !

Pour rappel, le NaNo c’est avant tout un défi personnel. Je me suis fixé comme objectif d’écrire un bouquin que j’imagine depuis plusieurs mois déjà pour l’occasion. Son nom sera probablement Asmara. Il s’agit d’un roman de science fiction et d’anticipation. Pour donner une idée de quoi ça va parler, sachez que j’ai commencé à imaginer l’histoire en partant de zéro mais en référence au roman 1984 de George Orwell. Au fur et à mesure que le scénario s’est mis en place, je me suis rendu compte que l’histoire se rapprochait de plus en plus du film culte des frères (et sœur maintenant) Wachowski, Matrix. Au final, je crois que Asmara tient plus de Matrix alors que ce n’était absolument pas mon but initial ! Je ne prétends pas arriver à une histoire de la qualité et de la profondeur de 1984 ou Matrix, je me suis simplement inspiré de ces œuvres et permis quelques (nombreux ?) clins d’œil ;).

Premier point à retenir sur mon NaNo : ça avance ! Le NaNo c’est (au moins) 50 000 mots en un mois, j’en suis pour l’instant à 36 213, ce qui constitue déjà en soi un petit exploit. Si je devais donner un unique conseil pour le NaNo, c’est de se fixer une limite minimale de nombre de mots à écrire par jour. Cette planification m’a énormément aidé à avancer jusque-là en me forçant, les jours où j’étais moins motivé, à écrire quand même. Si je m’étais fixé au départ 2 000 mots par jour pendant le mois, j’ai décidé de passer en cette troisième semaine à un objectif de 2 700 mots pour finir d’ici dimanche. Ça peut sembler être une augmentation superficielle, mais c’est déjà pas mal sachant que ma moyenne est de 2 130 mots par jour (avec une jolie pointe à 4 156 jeudi dernier !).

La plus grosse difficulté est certainement de gérer correctement sa motivation. Il faut avouer que lorsqu’on se prend une ou deux journées de pause, la reprise est compliquée. Entre le doute (« Est-ce que mon histoire est bonne ? ») et le manque d’inspiration, ce n’est pas toujours facile d’avancer. En un peu plus de deux semaines de NaNo, j’ai tout de même mis en place un certain nombre de mécanismes. Le premier, c’est d’écrire le soir et la nuit : je suis beaucoup moins distrait et donc plus performant entre 17h et 23h que le reste de la journée. Autre point important, c’est la musique. J’évite les chansons dont les paroles ne font que de me distraire. Je me concentre principalement sur des artistes comme Massive Attack, Archive, EZ3kiel (qui vient de sortir un nouvel album au passage :p) ou UNKLE que j’ai découvert pour l’occasion. Le fait de les passer en boucle n’est pas dérangeant car lorsqu’on est concentré sur l’histoire, on n’y fait presque plus attention. À l’inverse, quand on est en perte de motivation, la musique peut avoir un effet dopant qui booste la concentration ! Dernier point pour me motiver et concentrer, c’est de m’enlever le maximum de distraction autour de moi. Ça peut passer par ranger le bureau ou écrire dans un éditeur de texte en plein écran sans aucune notification pour déranger. La semaine dernière, j’ai même rangé l’appartement et fait la vaisselle parce que l’idée que ce n’était pas fait m’obnubilait. Une fois terminé, je me suis rendu compte que je n’avais plus aucun mal à écrire. Alors oui c’est purement psychologique, mais si ça marche, moi, ça me va !

Une chose intéressante dans le NaNo, c’est aussi de voir les autres avancer. Il y a ceux qui peinent et abandonnent rapidement (non non, je ne vise personne :)). Il y a ceux qui doutent, qui avancent difficilement (non je ne vise toujours personne :p). Il y a ceux qui, comme moi, avancent assez bien, tiennent le cap et finiront légèrement en avance. Et enfin, il y a les fusées : eux, ce sont les plus déprimants (je déconseille d’ailleurs d’aller lire certains topics des forums du NaNo si on est en pleine démotivation !). Ceux-là se sont les habitués : ils écrivent leurs 50 000 mots en moins d’une semaine, voire moins d’une journée. J’avoue que je n’ai aucune idée de comment ils font, mais c’est assez beau à voir. Bref, le NaNo ce n’est pas uniquement un défi personnel, c’est aussi une communauté. Pour ma part j’essaye de retranscrire chaque soir mon humeur d’après-séance sur le réseau social Diaspora* pour faire le point sur mon avancement, sur les difficultés, mes bonnes nouvelles et sur comment je sens la suite. Je tiens une sorte de journal de bord et je pense que je remettrai tout ça au propre à la fin et que je le diffuserai en même temps que le bouquin.

En parlant de diffusion, j’ai décidé de placer Asmara sous licence Creative Commons Zéro, c’est-à-dire de l’élever dans le domaine public. On m’a régulièrement demandé ce que je comptais faire du bouquin après l’avoir écrit et le choix de la licence a semblé surprendre (surtout ma famille en fait) : l’écriture de ce roman est pour moi juste l’envie de réaliser un rêve de gosse, je n’ai jamais eu envie de faire de l’argent avec ça (surtout que je ne suis pas encore certain que ça puisse marcher). Plus que l’argent, c’est les lecteurs qui m’importent : avoir un retour construit pour me faire progresser. Diffuser un roman dans le domaine public permet l’accès à l’histoire à un maximum de personnes. Le choix du domaine public c’est une histoire de partage, pas d’argent. C’est aussi une affaire de convictions : je trouve plus « juste » qu’une œuvre soit dans le domaine public que dépendant d’un auteur unique voire de ses descendants. Si vraiment l’histoire vaut le coup d’être publiée chez un éditeur (encore une fois, je n’en suis pas sûr), je verrai ce qu’il est possible de faire.

D’un point de vue technique, comment se passera la mise à disposition du roman ? Je suis encore en train de me tâter mais je pense relire et mettre à disposition un chapitre par semaine sur ce blog. Ça me permettra de corriger les fautes et incohérences au fil de l’eau tout en permettant de ne pas noyer les lecteurs. J’ai essayé de terminer chaque chapitre par une pointe de suspens ce qui, je l’espère, maintiendra l’intérêt pour Asmara durant les semaines de « livraison ». Il devrait y avoir 19 chapitres donc 19 semaines. Une fois que tous les chapitres auront été publiés je referai une dernière grosse relecture et publierai les sources du roman, une version PDF et probablement une version EPUB (format de fichiers pour les livres numériques).

Je vais donc essayer d’augmenter le rythme d’écriture pour essayer de terminer dimanche et commencer la relecture dans la foulée. Ça va être une grosse semaine, mais ça vaut vraiment le coup ! En attendant, j’ai écrit le synopsis du roman sur le site du NaNo (et pour le coup, je n’en suis pas satisfait du tout !).

En novembre, c’est NaNoWriMo

2014-10-31T19:51:00+01:00

Alors que j’ai débuté depuis mi-septembre mes neuf mois sabbatiques sur les chapeaux de roues (développement de FreshRSS principalement), le mois de novembre est maintenant à ma porte.

Comme je l’avais évoqué dans mon article du 14 juin, je me lance dans le NaNoWriMo (que j’abrègerai par NaNo désormais). Le NaNo c’est quoi ? C’est avant tout un défi personnel. Chaque mois de novembre, des milliers de personnes se lancent dans l’écriture d’un roman d’au moins 50 000 mots. Il n’y a pas de sujet imposé, pas de contrainte particulière, seulement 50 000 mots à écrire en l’espace d’un mois.

Ayant découvert ce défi l’année dernière à travers les expériences de Ploum et de Pouhiou, j’ai eu envie de me lancer pour renouer avec une passion que j’avais au collège et au lycée : l’écriture. J’ai donc eu un an pour me motiver et, maintenant, on y est ! Le sujet de mon histoire est désormais arrêté. Je ne détaillerai pas le scénario ici (ni même de visu, j’attends d’avoir fini l’histoire et d’en être satisfait pour cela ! ;)) mais ce sera de la science fiction et l’histoire se nommera probablement Asmara.

Pour le suivi de ce défi, j’essayerai d’écrire régulièrement ici pour tenir au courant mais comme je me connais, je risque de ne pas être très productif. Le mieux reste encore de venir faire un tour sur Diaspora (vous pouvez vous inscrire sur Framasphère, mon identifiant est marienfr@diaspora-fr.org) où je serai probablement plus bavard. Un autre avantage de Diaspora c’est qu’il y a tout un tas de gens qui se sont lancés dans le NaNo cette année que vous pouvez rencontrer en suivant le tag #NaNoWriMo.

Pour finir ce court article, j’ai vraiment hâte de voir le résultat final. Cela doit faire plus de cinq ans que je n’ai pas pris le temps d’écrire une vraie histoire et je me demande vraiment comment je vais gérer le rythme (je me suis fixé 2 000 mots par jour). Vous pourrez me retrouver sur le site du Nano sous le nom de… Marien Fressinaud !

FreshRSS 0.8 : retour sur sept mois de travail

2014-09-23T23:46:00+02:00

Nous y voilà, la nouvelle version de la branche master de FreshRSS sort aujourd’hui, sept mois après la version 0.7.1 !

Comme les grosses nouveautés de cette version ont déjà été annoncées lors des sorties des versions bêta (0.7.2, 0.7.3 et 0.7.4), je ne vais faire qu’un rappel des grosses nouveautés.

Avant de débuter, quelques liens utiles :

Le site officiel : freshrss.org
La démo en version 0.8 : demo.freshrss.org
Le dépôt de code sur GitHub
Le bugtracker aussi sur GitHub

Retour sur les versions bêta

La version 0.7.2 (première bêta) voyait l’arrivée de l’API compatible avec les applications Google Reader. Un gros travail a été fait par Alkarex ici et qui a mené à la possibilité d’utiliser deux applications mobiles différentes sur Android (EasyRSS et News+). Je profitai aussi de cette version pour introduire le nouveau système d’import / export des flux et des articles. Ce nouveau système permet notamment d’exporter ses favoris pour les réimporter ailleurs. Le format utilisé est celui de feu Google Reader (encore lui !) et il est donc possible d’importer les articles que vous avez potentiellement gardé dans un coin de votre ~~disque dur~~ SSD.

La version 0.7.3 ajoutait le support de SQLite pour le système de stockage en plus de MySQL/MariaDB. C’était une très forte demande de la part de nombreuses personnes et j’avoue que c’est agréable de ne pas avoir à taper toutes les informations de base de données à chaque fois (SQLite génère un simple fichier par utilisateur).

La grande nouveauté de la version 0.7.4 était le magnifique thème Screwdriver de Mister aiR. Beaucoup de compliments ont été fait à son sujet et je trouve qu’il permet bien de mettre en valeur FreshRSS.

La version 0.8

Aujourd’hui sort donc la version 0.8, une grande étape pour la suite puisqu’elle signe le début d’une forte activité de ma part dans le développement de FreshRSS. En effet, comme je l’expliquais en juin dernier, j’ai débuté neuf mois sabbatiques (dont trois de voyage) pour me consacrer à mes projets personnels. Une priorité que je me suis donné et de sortir un version 1.0 d’ici la fin de l’année. Cette version 0.8 marque donc la fin de mes études (avec deux semaines de retard, certes). J’ai pas mal travaillé dessus pour corriger des petits détails qui avaient leur importance (que ce soit en termes de sécurité, de design ou de fonctionnalités).

La grosse nouveautés de cette version, c’est le nouveau système de mise à jour. Si auparavant il était nécessaire de faire pas mal de manipulations à la main, désormais il vous suffira de cliquer sur un bouton, éventuellement préciser certaines informations et confirmer la mise à jour. Le reste, c’est FreshRSS qui s’en chargera.

Une plus petite amélioration qui me tenait à cœur, c’est l’affichage des statistiques (que l’on doit par ailleurs à aledeg qui a fait du très bon travail à ce niveau-là !). J’ai donc réorganisé les différents blocs pour une meilleure utilisation de l’écran ce qui, j’espère, rend les choses plus agréables à regarder.

Pour terminer sur les nouveautés de cette version 0.8, j’ai intégré ce matin même un nouveau thème : Pafat par plopoyop. Merci à lui !

Passer d’une 0.7.x en 0.8

Comme le nouveau système de mise à jour n’est présent qu’à partir de la 0.8, il va vous falloir faire une dernière mise à jour à la main ! Avant cela je vous conseille, si vous ne l’avez pas fait régulièrement, de vous assurer d’être en version 0.7.4 (visible dans "À propos"). Changer de version se fait facilement :

Téléchargez FreshRSS : 0.7.4 ou 0.8.0 (stable) ou 0.9.0 (bêta).
Décompressez l’archive.
Supprimez les fichiers et répertoires de votre installation précédente à l'exception du répertoire ./data.
Remplacez ce que vous venez de supprimer par les fichiers extraits de l'archive à l'étape 2.

Une communauté qui s’agrandit

Si je pouvais déjà compter sur le fort soutien d’Alkarex et d’aledeg pour le code et d’Alwaysin pour remonter les bugs et les demandes de fonctionnalités, je remarque que les contributions ponctuelles sont de plus en plus nombreuses. Il y a notamment eu, fin août, en l’espace d’une semaine un Anglais, un Pakistanais et un Allemand qui m’ont chacun envoyé un mail. Fou !

On notera aussi une certaine activité du tag #FreshRSS sur Diaspora*, initié par moi-même évidemment mais avec pas mal de personnes qui semblent en être satisfait :)

En tout cas, je me répète à chaque fois, si vous avez une question, une proposition, un soucis, envie de remercier ou que sais-je d’autre, GitHub et mon adresse mail vous sont ouverts !

Une démarche qualité

Comme je sais que mon maître d’apprentissage de ces trois dernières années a toutes les chances de passer par là, j’en profite pour aborder un sujet qui lui est cher :).

Depuis quelques temps, nous commençons à travailler Alkarex, aledeg et moi à améliorer la qualité globale de FreshRSS. J’avais débuté mon agrégateur comme quelque chose de personnel qui n’intéresserait probablement pas grand monde et cela se ressent. C’est pourquoi :

Les règles de "coding style" ont bien été définies et je m’applique à rendre peu à peu tout le code conforme à celui-ci.
J’ai commencé à m’attaquer plus sérieusement à la documentation sur doc.freshrss.org (en français pour le moment).
Nous allons prochainement mettre en place des tests pour éviter les régressions.
aledeg a initié un mouvement "Commentons le code !".

J’espère que ces différentes initiatives permettront d’y voir plus clair et de faciliter les modifications du code source… C’est le but en tout cas !

La suite

Je l’ai dit : la version 1.0 est prévue d'ici la fin de l'année. Pour être plus précis, voici ce que je prévois pour les mois qui approchent :

Aujourd'hui : sortie des versions 0.8 et 0.9 (son pendant dans la branche bêta).
10 octobre : sortie des versions 0.8.1 et 0.9.1, les versions de maintenance (je ne me fais pas trop d’illusion, il reste toujours quelques bugs).
31 octobre : sortie de la version 0.9.2, uniquement une version bêta donc.
30 novembre : sortie de la version 0.9.3. À noter que durant cette période je participerai aussi au Nanowrimo qui me prendra énormément de temps.
19 décembre : sortie de la version 1.0. J'évite une sortie le 25 décembre parce que je risque d’avoir moins de retours même si la date m'aurait bien plu.

Au programme, beaucoup de choses :

Un système de plugins
Refonte de la gestion des catégories
Un système de web-cron
Une meilleure gestion du mode multi-utilisateurs (qui reste basique actuellement)
Support de PostgreSQL
Le support de l’allemand (initialement prévu pour la 0.8 mais finalement reporté)
Une nouvelle API (basée sur celle de TTRSS) ?
Et plein d’autres choses !

Beaucoup de travail donc, mais contre-balancé par une très forte motivation de ma part. Je vais bientôt fêter les deux ans du projet et je vois enfin le bout du tunnel ! Le plus motivant est que j’ai réussi à amener FreshRSS à un niveau de maturité que je n’imaginais même pas au départ et que mon application connait apparemment un certain succès dans le milieu francophone.

Comme je suis motivé, je prévois quelques suprises pour la sortie de la 1.0 (voire avant) qui devrait permettre à FreshRSS de s’imposer comme une solution incontournable dans le monde des agrégateurs de flux RSS. Ouais, rien que ça. Trust me, I’m an engineer.

FreshRSS 0.7.4 (bêta) : ne ratez plus aucune news

2014-08-24T15:35:00+02:00

Un mois est déjà passé depuis la dernière version et voici donc une nouvelle bêta qui apporte son lot de nouveautés qui, comme d’habitude, devraient vous plaire ;)

Les notifications sont de la partie avec la gestion des notifications HTML5. Cette fonctionnalité est vraiment top pour savoir quand de nouveaux articles sont disponibles et marche parfaitement bien sous Firefox et FirefoxOS.
Combiné à cela, le favicon devient dynamique et affiche le nombre d’articles non lus ! Joli et pratique :)
Petite nouveauté qui est devenue urgente avec l’acquisition d’un FirefoxOS : la case à cocher pour rester connecté. Plus besoin de se reconnecter à chaque lancement du navigateur.
La page de statistiques continue de s’étoffer en permettant de visualiser la répartition des articles par heure, jour et mois.
La grosse nouveauté dont j’ai déjà parlé dans mon Shaarli, c’est le nouveau thème magnifique proposé par Mister aiR déjà à l’origine d’un thème pour Shaarli et… Leed :) Grâce à lui j’ai d’ailleurs pu noter quelques limitations dans la création des thèmes, j’en parlerai dans la documentation.
Tout un tas d’autres petites nouveautés dont des corrections de petits bugs (encore !).

Un mot sur l’avenir de FreshRSS maintenant. Comme déjà évoqué dans mon article "C’est l’histoire d’un break." (edit : cet article n’existe plus), le 14 septembre je termine mes études et mon contrat d’apprentissage pour entamer entre six à douze mois sabbatiques. Je compte bien consacrer le début à FreshRSS afin de sortir une version 1.0 avant la fin de l’année. Pour marquer le coup, je compte sortir la prochaine version stable (la 0.8) le jour de la fin de mon contrat. Comme cela, je on pourra ensuite commencer des gros travaux dont le système de plugins qui attend depuis longtemps.

Pour la version 0.8 je compte notamment sortir un nouveau système de mise à jour complètement automatique. J’ai déjà commencé à travailler dessus dans une branche à part mais accessible. Un dépôt supplémentaire a été créé pour gérer la partie serveur de ce nouveau système de mise à jour. Tout est fonctionnel actuellement mais pas trop testé. Je pense d’ailleurs que ce sera la dernière (voire la seule) grosse amélioration de cette version.

Je tiens encore (et toujours) à remercier les différents contributeurs très actifs (Alexandre, Alexis, Alwaysin, que des A !), les personnes qui parlent de FreshRSS, ceux qui soutiennent, qui font des propositions, qui envoient des mails, qui font des dons, etc. Je suis vraiment ébahi qu’autant de monde participe à FreshRSS :) J’en profite d’ailleurs pour rappeler, si vous voulez donner un coup de pouce, que j’ai ajouté le projet sur AlternativeTo.net. J’étais un peu dubitatif de l’intérêt au début mais finalement j’ai pas mal de visites en provenance de ce site donc ça vaut le coup "de liker" le projet pour le faire connaître encore un peu plus ;)

FreshRSS 0.7.3 (bêta) : libérez-vous de MySQL

2014-07-21T18:47:00+02:00

Comme prévu dans l’un de mes derniers articles, voici, avec (à peine) plus de cinq semaines de développement, une nouvelle version bêta de FreshRSS !

Au programme, des petites nouveautés :

Réécriture des thèmes Flat et Dark pour mieux correspondre aux "standards" définis
Ajout d’une limite configurable pour la fréquence de synchronisation des flux. Je vois souvent des gens qui rafraîchissent leur flux toutes les une ou deux minutes : ça ne sert à rien et vous bouffez les ressources des sites ! Avec cette fonctionnalité, nous vous limitons cette possibilité en vous imposant une fréquence d’au moins 20 minutes entre deux actualisations (une heure par défaut).
Ajout d’un système de filtres (queries en anglais). Ce sont, en gros, des raccourcis que vous créez à partir de vos recherches. Imaginons que vous recherchiez le thème "FreshRSS" apparu dans les articles de la semaine dernière (date:P1W FreshRSS) dans la catégorie "Les trucs que j’aime". Au lieu de devoir taper ça à chaque fois, vous n’avez qu’à créer un filtre à partir de la page courante et le raccourci se glisse dans la barre des filtres.

Ça c’était pour les petites news. Il en reste une qui devrait faire plaisir à pas mal de monde : le support de SQLite ! \o/ Il s’agissait d’une demande de longue date mais qui nécessitait plus de travail que prévu (le langage SQL, bien que standardisé, se trouve géré bien différemment selon les moteurs SQL). Notez bien que SQLite n’est pas la solution que je recommande si vous avez de grosses quantités de données : nos premiers tests sont plutôt concluant mais les requêtes ne sont pas particulièrement optimisées. Si par contre vous ne suivez que quelques flux et / ou que vous ne stockez pas les articles sur de longues durées, ça peut sans doute vous convenir.

Avec le support de SQLite, à priori FreshRSS devrait attirer plus de monde. Par conséquent j’espère avoir encore plus de retours :)

Avec tout ça, j’ai aussi débuté en parallèle la documentation un peu plus sérieusement. Pas grand chose de plus, mais ça va prendre forme au fur et à mesure. Si certains sont motivés pour donner un coup de main, un ticket est ouvert pour en parler.

Niveau communauté, je remercie une fois de plus les contributeurs les plus actifs, Alexandre et Alexis, pour leur super travail ! Il y a aussi tous ceux qui remontent les bugs : je ne les nomme pas individuellement parce que, mine de rien, il commence à y en avoir pas mal. Ce serait d’ailleurs sympa que GitHub propose un système pour voir les plus gros contributeurs en nombre de commentaires dans les tickets. En attendant vous pouvez toujours tous les retrouver sur GitHub… Enfin presque : n’oublions pas tous ceux qui m’envoient des mails que ce soit pour encourager, remercier, remonter des problèmes ou pour suggérer des améliorations.

En guise de conclusion, j’en profite pour diriger les âmes aventureuses vers le projet Freeder que j’ai découvert suite à une discussion (par mail) avec Phyks et qui cherche à "réinventer" le concept d’agrégateur de flux RSS. Ça me semble un projet intéressant et ça pourrait être l’occasion de mettre en application des idées que je ne pourrai pas mettre en place dans FreshRSS.

Nouveau système de sortie pour FreshRSS

2014-06-13T19:52:00+02:00

Il y a environ quatre mois et demi sortait FreshRSS 0.7 et une vingtaine de jours plus tard le patch 0.7.1. Depuis ? Rien de visible à priori puisque la page principale de Github n’affichait plus aucune activité. Néanmoins ne vous méprenez pas : même si je ne suis pas tout le temps très actif, le projet continue de vivre activement grâce à de fantastiques contributeurs ! Tout se passe dans les tréfonds de la branche de développement…

Partant du constat que l’activité n’était pas suffisamment visible, nous avons décidé de créer une branche bêta qui sera mise à jour tous les mois avec les nouveautés de la branche de développement. La branche bêta est désormais celle par défaut, celle qui est visible en atterrissant sur https://github.com/marienfressinaud/FreshRSS. J’espère que cela montrera que FreshRSS est bel et bien vivant !

Voici le nouveau fonctionnement de sortie des versions (inspiré du système mis en place par Gnome) :

Les numéros impairs (0.7.x, 0.9.x) correspondent aux versions bêta et les numéros pairs (0.8.x, 0.10.x) aux versions "stables"
Nous travaillons sur la branche dev avec une feuille de route menant vers une version stable
Chaque mois, la branche dev est stabilisée un minimum et est mergée dans la branche beta avec un nouveau numéro de version (0.7.2 par exemple)
Une fois que toutes les nouveautés prévues pour la version stable sont présentes, on stabilise un maximum le tout et on merge dans la branche master avec un nouveau numéro de version (0.8.0 par exemple)

En résumé : vous préférez la stabilité ? Utilisez la branche master. Vous aimez connaître les nouveautés avant les autres ? Préférez la branche beta qui est celle par défaut. Vous êtes un fou dans votre tête et vous aimez quand tout est cassé ? Alors essayez la branche dev !

Note : je ne préviendrai pas des sorties des versions bêta donc si vous voulez vous tenir au courant, abonnez-vous au flux RSS dédié sur Github.

Les dernières nouveautés

Pour me démentir je vous annonce quand même la sortie de la version bêta 0.7.2. Petite exception car il y a quelques nouveautés sympathiques :

Une API compatible Google Reader pour brancher des applications Android dessus (ça reste peut-être un peu compliqué à utiliser la première fois mais ça fonctionne)
Des boutons pour filtrer plus facilement (le menu se situant au-dessus des articles a été entièrement remanié)
Un système de recherche plus poussé (faites-vous plaisir en filtrant au niveau de la date)
Un nouveau système d’import/export qui permet de sauvegarder aussi les articles ! (basé sur le format Google Reader, normalement compatible)
Le thème Origine a été remanié (entièrement réécrit mais ça ne devrait pas trop se voir ;))
Une option pour ajuster la largeur du contenu des articles (4 options : fine, moyenne, large et pas de limite)

Malgré tout ça, il reste encore pas mal de boulot avant la 0.8 et quelques bugs à corriger. Je reviens avec un nouvel article dans les prochains jours pour prévenir de la suite des événements car il se pourrait que la tant attendue version 1.0 arrive plus tôt que prévu… Wait and see!

Sortie de FreshRSS 0.7.1

2014-02-19T21:12:00+01:00

Un court article pour vous prévenir que FreshRSS 0.7.1 vient tout juste de sortir.

C’est un peu plus qu’une version de maintenance vu qu’il y a quelques nouveautés intéressantes comme les raccourcis pour naviguer dans la liste des catégories / flux, des performances accrues au niveau du cache et quelques corrections visuelles. Toutes les modifications sont indiquées dans le changelog.

Ce qu’apporte vraiment cette version, c’est une correction d’un bug de rechargement infini de la page au niveau de Persona et J’ESPÈRE aussi un bug de redirection infinie au niveau de PHP. Pour ce dernier bug je n’ai pas été capable de le reproduire mais j’ai amélioré le système de redirection de la page d’accueil donc ça devrait fonctionner.

Pour ce qui est du "bug" qui fait que les tables sont dupliquées : en fait ce n’en est pas un. Cela survient lorsque vous changez le préfixe des tables (typiquement en 0.6 vous n’en aviez pas et en 0.7 vous en avez ajouté un) : il est considéré alors qu’on fait une nouvelle installation et les tables ne sont donc pas migrées. Ce sera plus clair pour la 0.8 :)

Pour installer cette version, c’est simple : soit vous faites une installation toute neuve en écrasant tout, soit vous faites un git pull (je suppose que ceux qui ne comprennent pas ce que je dis ne sont pas concernés par cette deuxième méthode) ou alors vous pouvez faire une mise à jour :

Supprimez tous les fichiers sauf ceux du répertoire ./data
Récupérez le code et déployez le tout comme avant
Si vous utilisiez la version 0.7.0, vous pouvez vous permettre de supprimer le fichier ./p/i/install.php, sinon je vous renvois sur mon article précédent pour migrer proprement.

Et comme d’habitude si vous avez une question, une suggestion ou simplement envie de m’envoyer un message pour le plaisir vous avez les commentaires, Github ou encore mon adresse mail :)

FreshRSS 0.7, ça casse et ça passe !

2014-01-29T21:31:00+01:00

FreshRSS, l’agrégateur de flux RSS qui déboite tout, sort aujourd’hui en version 0.7. Au menu, des tas de bonnes choses : un mode multi-utilisateurs, des statistiques, un script de mise à jour et des performances qui s’améliorent encore et encore, parmi tant d’autres (j’y reviens dans le reste de cet article). Comme je sais que vous ne tenez déjà plus en place, je vous invite à vous rendre immédiatement sur la démo (demo / demodemo).

Un nouveau site fait maison

Le précédent site était géré via le système de GitHub. Dans un soucis d’auto-hébergement, j’ai créé un site (en anglais) fait maison avec des saucisses bien de chez nous à l’intérieur. Je pense que celui-ci est plus clair que le précédent et présente mieux les choses. Le lien du site : freshrss.org.

Sauvez votre serveur, lâchez TTRSS !

FreshRSS était déjà du genre plutôt rapide par rapport à certaines alternatives (keufTTRSSkeuf) mais souffrait quand même sur le long terme de ralentissements. Avec les améliorations au niveau de la base de données et des requêtes SQL, FreshRSS semble maintenant pouvoir gérer plus de 100 000 articles sans broncher.

Des améliorations au niveau du code PHP sont aussi au rendez-vous mais je ne rentrerai pas dans les détails (le changelog est là pour ça).

TTRSS n’est pas connu pour ses performances, mais grâce à l’ami @konfiot, on peut se faire une idée des gains qu’apportent FreshRSS. Voici quelques graphiques représentant l’activité de son serveur. Faut-il vous indiquer explicitement le moment de sa migration ?

Activité des entrées-sorties sur le disque dur

Activité des requêtes MySQL

Charge du serveur (c’est un peu moins marqué… mais quand même !)

On me souffle dans le README qu’un Raspberry Pi permet de faire tourner une instance de FreshRSS avec 150 flux (~22k articles) en moins d’une seconde.

Partagez votre instance de FreshRSS

Parmi les demandes récurrentes, on trouvait le mode multi-utilisateurs. Et bien ce mode est désormais disponible ! :) Vous pourrez désormais inviter vos amis, votre famille ou n’importe qui vous rejoindre sur votre instance FreshRSS.

Petit point technique tout de même pour ne pas que vous soyez surpris. FreshRSS n’a pas été pensé à la base pour du multi-utilisateurs. Aussi, nous n’avons pas touché à la structure de la base de données car ça aurait demandé beaucoup de changements. La solution choisie est de créer de nouvelles tables en BDD, préfixées du nom d’utilisateur. Aussi la taille de votre base de données risque d’exploser si vous invitez beaucoup de monde. Vous êtes prévenus ;).

Une autre petite nouveauté : un nouveau moyen d’authentification, plus traditionnel (formulaire à remplir). C’est donc aussi une demande de longue date qui a été comblée là. Petit bonus sécurité : si vous ne possédez pas une instance sécurisée de FreshRSS (protocole HTTPS), le mot de passe ne transite pas pour autant en clair sur le réseau. Celui-ci est d’abord hashé côté client en JavaScript avant d’être envoyé. C’est cadeau, mais ça force l’utilisation du JavaScript (m’enfin, vous me direz, ça fait un moment que JavaScript est requis pour l’utilisation de FreshRSS).

Lisez l’actualité, même la nuit !

La nuit, tous les chats sont gris, mais votre écran d’ordinateur continue d’être blanc comme neige quand vous êtes sur FreshRSS. Dans un soucis de santé publique, un nouveau thème sombre a été développé en association avec les meilleurs contributeurs du moment (merci à @aledeg !). Vos yeux vous remercieront.

Partagez les articles qui vous intéressent

Facebook, Google+, Twitter ? Vous ne connaissez pas et vous préférez Shaarli, Diaspora* ou encore wallabag ? Ces six moyens de partage sont désormais disponibles. Nous avons aussi pensé à ceux qui n’en ont rien à faire : vous pouvez les faire disparaître de la liste si vous n’en voulez pas.

Migrez de la 0.6 à la 0.7 sans tout casser

Il y aurait bien encore des tas de choses à ajouter sur cette version qui est sans doute la plus conséquente de toutes (nous avons dépassé la barre des 1000 commits !), mais je vais finir en évoquant la mise à jour. Comme évoqué plus haut, il y a eu de gros changements tant au niveau base de données qu’architecture des fichiers. J'avais prévenu lors de la sortie de la 0.6 : tout a été cassé.

Attention : VOUS NE POURREZ PAS FAIRE CETTE MISE À JOUR SIMPLEMENT À LA MAIN.

Mais on ne vous laisse pas tout seul pour autant et un script de mise à jour est fourni. Suivez bien ces étapes si vous ne voulez pas tout casser :

Vérifiez que vous êtes bien en version 0.6. Un moyen simple de le savoir est de regarder dans la configuration si vous pouvez gérer les icônes de lecture. Si oui, alors vous êtes en 0.6 (ou alors déjà en 0.7 mais alors vous saurez très bien vous débrouiller tout seul :)).
Faites une copie de ./app/configuration/application.ini et de ./public/data/Configuration.array.php.
Supprimez le reste
Déployez la version v0.7 (depuis l’archive ZIP ou par git)
Placez application.ini et Configuration.array.php dans ./data/
Si vous avez peur, faites une sauvegarde de votre base de données via phpMyAdmin ou grâce à la commande MySQL : mysqldump -u utilisateur -p --databases freshrss > freshrss.sql
Lancez l’installation de la version 0.7 qui fera la mise à jour automatiquement (cette fois donc, il NE FAUT PAS supprimer le fichier d’installation)

Il n’y a eu aucun soucis lors de nos tests, il n’y a pas de raison que vous en ayez :) Et sinon, ce sont les risques de ne pas utiliser les versions 1.0 :p

Ces contributeurs sans qui rien n’aurait été possible

Alors que je révisais, passais mes partiels, rentrais en France, passais les fêtes en famille, déménageais et vivais dans le froid à la recherche d’un appartement, le projet a été maintenu à bout de bras, une fois de plus, par @alkarex. Je veux dire, VRAIMENT. Une (très) grosse partie (quasiment la totalité) des améliorations que vous verrez dans cette version est de son propre crû.

Cette version 0.7 aura aussi vu l’arrivée des contributions d’@aledeg, évoqué plus haut pour son thème "Dark". Ce n’est pas sa seule contribution vu qu’il a aussi ajouté un raccourci pour refermer l’article en cours (la navigation est plus sympa comme ça), créé de nouveaux filtres pour la vue et surtout commencé un travail que j’avais prévu de commencer il y a un petit moment : la page de statistiques ! (j’en parle dans la partie suivante). @Bubbendorf n’est pas à oublier non plus puisqu’il a aidé au formatage des nombres et participé à de nombreuses reprises aux tickets de bug.

Enfin je n’oublie pas, comme toujours, toutes les personnes qui remontent des petits bugs par-ci par-là et/ou qui encouragent et qui font avancer mine de rien FreshRSS. Même si ce n’est pas toujours grand chose, ce sont ces petits trucs qui permettent de parfaire le logiciel. La version 1.0 n’en sera que meilleure ! Puis quand je vois, à chaque nouvelle version, le nombre toujours grandissant d’utilisateurs, on ne peut qu’être confiant dans la qualité de FreshRSS :]

Bonus : tout savoir sur vos abonnements en un clin d’œil

C’est tout chaud, ça sort du four et c’est la dernière "killer feature" de FreshRSS : la page des statistiques. Vous pourrez dorénavant savoir d’un coup d’œil tout un tas de choses sur vos abonnements. Pour l’instant ça reste limité à la répartition des articles (globalement ou par catégorie), à la répartition des flux par catégorie, au nombre d’articles parus par jour sur les 30 derniers jours et aux flux les plus productifs.

D’autres graphiques devraient apparaître dans les prochaines versions, mais si vous avez des idées, n’hésitez pas à nous les faire savoir !

0.8 en approche

Sortir une nouvelle version est synonyme de développement d’une autre. Si vous avez aimé la 0.7, la 0.8 devrait le confirmer. La grosse nouveauté sera l’arrivée d’une API qui permettra donc de connecter d’autres applications sur FreshRSS. Cela sera utile surtout sur mobile où tout le monde ne veut pas utiliser la version mobile de FreshRSS (qui est parfaitement responsive design, je le rappelle).

Je ne m’étend pas sur les autres nouveautés qui pourraient éventuellement arriver (catégories arborescentes, gestion de SQLite, import/export des favoris, etc.) car c’est le genre de choses que j’ai tendance à toujours renvoyer à la version d’après :p

En tout cas, la version 1.0 n’a jamais été aussi proche et j’aimerais la voir arriver dans les six prochains mois ! Y a plus qu’à coder !

FreshRSS 0.6 prend son envol

2013-11-17T13:28:00+01:00

Un mois après la sortie de la version 0.5, je vous présente FreshRSS 0.6. Toujours plus stable, toujours plus performant, toujours plus utile, FreshRSS deviendra très vite votre plus fidèle compagnon au quotidien. Vous ne pourrez bientôt plus vous en passer !

Pour vous en faire une première idée, la démo a été mise à jour.

Des performances accrues

Le gros du travail a porté cette fois-ci sur les performances coté client. On saluera le travail fantastique réalisé par Alexandre Alapetite (à vrai dire, c'est lui qui a quasiment tout fait), désormais contributeur régulier. Les performances ont été améliorées sur deux axes :

Le code JavaScript : celui-ci a été remanié en grande partie et son chargement grandement amélioré. Ce n’est pas encore parfait, mais une grande étape a été franchie
La mise en cache : l’utilisation d’un fichier .htaccess permet de garder en cache de manière plus fine les différents fichiers pour les utilisateurs d’Apache. De plus, pour limiter les requêtes inutiles coté serveur, les pages de FreshRSS sont désormais mises en cache de "manière globale" si aucun changement n'a été effectué depuis le dernier chargement.

Du sucre fonctionnel

En plus des performances, on notera en vrac quelques améliorations sympathiques (issues du changelog) :

Mise à jour automatique du nombre d’articles non lus
Amélioration des retours utilisateur lorsque la configuration n’est pas bonne (vous savez, cette fameuse page blanche...)
Meilleure prise en charge des flux RSS invalides
Amélioration de la vue globale (toujours un peu plus à chaque version)
Possibilité de personnaliser les icônes de lecture
Suppression de deux champs "inutiles" lors de l'installation (base_url et sel)

Toujours pas de version 1.0 !

L’arrivée d’Alexandre en contributeur régulier a amené aussi pas mal de conseils pour améliorer les performances. Ceci a donc encore repoussé en partie certaines fonctionnalités et, par conséquent, l’arrivée de la version 1.0. Je ne m’en plains absolument pas car FreshRSS est de plus en plus agréable à utiliser et cela signifie que lors de la sortie de la version finale, il devrait être particulièrement stable et performant.

Mise à jour

Pas de modification au niveau de la base de données cette fois-ci, tout va bien. Du coup comme d’habitude :

Téléchargez la nouvelle version
Écrasez les fichiers des répertoires "app", "lib" et "public". Faites attention à garder vos anciens app/configuration/application.ini et public/data/Configuration.array.php
Supprimez le fichier public/install.php car vous n’en avez pas besoin dans le cas d’une mise à jour

Ou un simple git pull si vous préférez utiliser Git ;)

Attention : je vous préviens tout de suite, mais ce ne sera pas aussi facile pour mettre à jour vers la version 0.7. Il y aura de très gros changements au niveau de la base de données et de l’architecture des fichiers. Si vous suivez la version de dev, faites attention !

La version 0.7, celle qui va tout casser

Contrairement à ce que je fais d’habitude, je ne vais pas faire de liste des fonctionnalités pour la version 0.7. Je vous redirige plutôt vers le gestionnaire de bugs sur Github qui est toujours à jour.

Néanmoins, comme je le disais juste au-dessus, cette version devrait casser pas mal de choses, donc prenez garde, notamment sur la version de développement.

Pour finir

Merci encore une fois pour tous les retours que vous m’avez fait, c’est très encourageant et je le répète, c’est grâce à ça que FreshRSS est ce qu’il est aujourd’hui. Je profite aussi de cet article pour vous renvoyer sur un journal que j’ai écrit sur LinuxFR pendant que mon site était mort. Je parle surtout de l’année passée à développer mon agrégateur de flux RSS et sur ce que m’a apporté ce travail. C’est un peu long, mais ça peut valoir le coup de le lire si vous souhaitez vous lancer dans un projet personnel.

Puzzle solver et intelligence artificielle

2013-11-09T11:07:00+01:00

Une semaine après avoir publié le code de mon jeu de Quarto, il est temps que je vous parle de mon résolveur de puzzles.

Ce "puzzle solver" a aussi été écrit dans le cadre de mon cours de programmation d’IA et c’est donc mon deuxième projet. Je l’ai écrit pendant le mois d’octobre cette fois-ci. Le code est publié sous licence MIT et est disponible sur Github.

Le principe de ce projet est assez simple : le but est juste de proposer un algorithme permettant de résoudre des jeux (aussi appelés "problèmes") de façon modulaire. Ainsi, l’algo en lui-même doit être capable de résoudre un maximum de jeux avec un minimum d’adaptations.

Deux jeux étaient imposés à la base : le problème des huit dames et le problème de coloration de graphe. Le troisième jeu était libre et j’ai choisi le carré magique qui me semblait bien adapté au sujet (après coup, ce n’était pas forcément le plus simple :p).

Il y avait encore une autre contrainte, et c’est d’ailleurs là le cœur du projet. En fait il s’agissait d’implémenter non pas un seul algorithme, mais deux. Mais avant d'aller plus loin il me faut expliquer comment sont représentés les jeux. Comme je le disais plus haut, un jeu est aussi appelé "problème". Un problème peut donc être défini par :

Des variables. Une variable est la donnée qu’on manipule et est définie par un domaine. Typiquement dans le problème des 8 dames, une variable représente une reine. On va donc avoir 8 dames, chacune positionnée sur une ligne différente des autres. Ainsi, le domaine de ces variables va être représenté par les indices des colonnes (une reine étant assignée à une ligne, elle ne peut se déplacer que de colonne en colonne)
Des contraintes. C’est ce qui va déterminer les règles du jeu. Dans le jeu des 8 dames, le but est qu’aucune des dames ne puisse en "manger" une autre, ni en ligne, ni en colonne, ni en diagonale. Ainsi on va assigner à chacune des dames la contrainte qu’elle ne doit pas se trouver dans la ligne de mir d’une autre dame. Il s’agit simplement d’une petite fonction qui va vérifier l’emplacement des différentes reines.

Au début d’un jeu, on assigne à chaque variable une valeur aléatoire issue de son domaine. Aussi il y a de fortes chances que certaines variables "violent" des contraintes. Le jeu n'est donc pas dans son état optimal et il va falloir appliquer un algorithme pour faire en sorte de réduire le nombre de violations de contrainte.

Min conflicts (minimisation de conflits [il n’y a pas de page Wikipédia en français ! :o]) : ce premier algorithme est assez simple et aussi, la plupart du temps, plus efficace. Il va choisir une variable aléatoirement pourvu qu’elle viole au moins une contrainte. Elle va chercher dans le domaine la valeur qui minimise le nombre de violations et va l’assigner à la variable. Et on continue ainsi jusqu’à ce que plus aucune variable ne viole de contrainte.
Simulated annealing (recuit simulé) : un peu plus compliqué que le premier algorithme, mais ingénieux ! Le principe est d’évaluer le jeu à chacune de ses étapes et de faire en sorte de faire évoluer le jeu de façon à maximiser cette évaluation. Pour faire évoluer le jeu on va simuler des états voisins (un changement de valeurs pour certaines variables). On va ensuite choisir soit d’assigner aléatoirement un de ces états pour la prochaine étape du jeu, soit d’assigner l’état qui possède la meilleure évaluation. Plus on va faire tourner l’algorithme, plus on va choisir l’état maximisant l’évaluation. Pour cela on a à notre disposition une "température" que l’on va réduire au fur et à mesure (d’où l’idée de recuit simulé). Plus la température est basse, plus on va se diriger vers l’état maximal.

L’algorithme du recuit simulé est beaucoup trop compliqué pour arriver à en faire une bonne explication en quelques lignes, je vous invite donc à lire sa page Wikipédia si vous voulez plus d’information dessus :p

Pour y voir plus clair dans l’architecture de mon programme, j’ai fait un diagramme de classes assez global. Il y a pas mal de classes reliées entre elles du coup ce n’était pas super simple de faire un beau diagramme. Sachez juste que la partie "implémentation" (qui représente la phase d’adaptation à un jeu en particulier) ne représente pour chacun des jeux que quelques lignes de code, consistant à assigner les domaines aux variables et à définir les contraintes.

Je m’arrêterai là pour les explications. Sachez juste que je me suis bien éclaté sur ce projet. Au départ j’étais un peu affolé par l’algorithme du recuit simulé sur lequel on avait pas mal bloqué l’année dernière (les explications étaient assez confuses). Finalement je me suis rendu compte qu’il est plutôt simple à implémenter :) (reste le choix de certaines valeurs qui est assez compliqué et c’est là où je n’ai pas été très bon). Au final le projet m’a valu un 100/100, je suppose donc que mon boulot n’est pas mauvais :D

Le dernier projet parlera de particules et d’oiseaux et sera encore plus rigolo :)

Quarto et intelligence artificielle

2013-11-02T12:35:00+01:00

Maintenant que j’ai à peu près fini de réparer mon serveur, je prends un peu de temps pour partager le code source d’un projet que j’ai réalisé pour mon cours de programmation d’Intelligence Artificielle (IA) en septembre : un jeu basique de Quarto.

Pour présenter le Quarto, rien de mieux que de citer Wikipédia :

L’objectif : aligner quatre pièces ayant au moins un point commun entre elles. Mais ne croyez pas que vous jouerez celles que vous voudrez : c’est l’adversaire qui choisit pour vous !

Les seize pièces du jeu, toutes différentes, possèdent chacune quatre caractères distincts : haute ou basse, ronde ou carrée, claire ou foncée, pleine ou creuse. Chacun à son tour choisit et donne une pièce à l’adversaire, qui doit la jouer sur une case libre. Le gagnant est celui qui, avec une pièce reçue, crée un alignement de quatre pièces ayant au moins un caractère commun [...]

Je ne sais pas pour vous, mais je trouve le principe très sympa :) Une sorte de puissance 4 mais avec quelques contraintes supplémentaires. Vous pouvez le tester directement en ligne.

Mon projet, quant à lui, se focalisait sur l’aspect IA et je me suis contenté du strict nécessaire niveau interface utilisateur. L’objectif était d’implémenter l’algorithme Minimax avec optimisation alpha-bêta.

Je crois que j’ai fait quelque chose de pas trop mal mais la fonction d’évaluation (qui est censée donner une "note" à un coup) est loin d’être parfaite et c’est là que j’ai perdu des points. Le code n’est pas non plus spécialement propre, mais il reste lisible (c’est du Python en même temps :p).

Le code est disponible sur Github et est sous licence MIT. J’ai accompagné le code source d’un diagramme de classes très général pour montrer l’architecture globale du jeu.

FreshRSS 0.5, pour ceux qui en veulent toujours plus

2013-10-12T11:17:00+02:00

FreshRSS continue son petit bonhomme de chemin 3 mois après la sortie de la version 0.4. C’est donc avec plaisir que je vous annonce une nouvelle version plus stable que la précédente et quelques nouveautés qui devrait être appréciées (comme d’habitude, évidemment).

Ce que vous devez savoir...

... car il est toujours bon de le rappeler avant de continuer. FreshRSS est un agrégateur de flux RSS à auto-héberger, écrit en PHP et utilisant une base de données MySQL (ou MariaDB). Sa plus grande limitation est, à l’heure actuelle, qu’il n’est pas possible de gérer plusieurs comptes. Cela vient bien évidemment contre-balancer les points positifs :

Une ergonomie pensée par et pour les utilisateurs
Responsive design : FreshRSS s’adapte parfaitement à votre mobile
Recherche par mots ou par #tags (et génération de flux RSS correspondants)
Actualisation possible via CRON
Possibilité de récupérer des flux RSS tronqués (à consommer avec modération !)
Possibilité de changer de thème
Marquage des articles comme lus au défilement de la page
Et bien d’autres ! ☺

Une fois encore, la démo a été mise à jour et est accessible à la même adresse.

Les nouveautés

FreshRSS 0.5 c’est quelques 130 commits de plus que la 0.4, au moins 50 tickets de bugs fermés (je pense que j’en oublie) et 3 mois de développement... Non je déconne, je suis loin d’avoir bossé dessus non-stop. Ça n’en reste pas moins, à l’heure actuelle, la plus grosse version que j’ai eu à développer, bien que n’ayant pas été seul cette fois-ci.

Fonctionnalités

Possibilité d’interdire la lecture anonyme
Option pour garder l’historique d’un flux
Lors d’un clic sur "Marquer tous les articles comme lus", FreshRSS peut désormais sauter à la prochaine catégorie / prochain flux avec des articles non lus. Cela évite bien des clics inutiles !
Ajout d’un token pour accéder aux flux RSS générés par FreshRSS sans nécessiter de connexion. Cela permettra aussi d’accéder à l’API... prochainement ;)
Possibilité de partager vers Facebook, Twitter et Google+
Possibilité de changer de thème, le thème Flat design étant fourni en alternative au thème par défaut

Design

La police OpenSans est désormais appliquée
Amélioration de la page de configuration
Une meilleure sortie pour l’imprimante
Quelques retouches du design par défaut
Un nouveau logo

Base de données

Possibilité d’ajouter un préfixe aux tables lors de l’installation
Ajout d’un champ en base de données (voir la partie sur la mise à jour de la base de données)
Si possible, création automatique de la base de données si elle n’existe pas lors de l’installation
L’utilisation d’UTF-8 est forcée. Cela peut entraîner des problèmes d’encodage lors de la mise à jour, j’en suis sincèrement désolé !

Améliorations

Le marquage automatique au défilement de la page a été amélioré
La vue globale a été énormément améliorée et est beaucoup plus utile
Amélioration des requêtes SQL
Amélioration du Javascript
Et des corrections de bugs en tout genre, comme d’habitude ☺

Et ce qui manque

Malgré tout ça, je n’ai pas intégré tout ce que j’avais prévu au départ. On notera parmi les manques : la page de statistiques, la possibilité d’utiliser SQLite (bien que ça n’était pas dans mes plans initiaux, s’en est devenu une affaire personnelle !) et le nettoyage en profondeur du code Javascript.

Ces manques s’expliquent par le fait qu’il y a eu énormément d’ajouts que je n’avais pas prévu et que j’avais besoin d’une nouvelle version pour stabiliser le tout avant de passer à la suite.

Mise à jour

Attention ! Cette nouvelle version inclut une mise à jour de la base de données et nécessite des actions de votre part.

Base de données

Dans la table entry, il faut supprimer (si ils existent) les champs :

is_public
lastUpdate
annotation

Dans la table feed, il faut ajouter le champ keep_history INT(1).

Pour la prochaine version j’essayerai d’automatiser les mises à jour de base de données ce qui nous simplifiera la vie à tous ☺

Application

une fois la BDD à jour, vous n’avez plus qu’à mettre à jour l’application comme d’habitude, à savoir :

Téléchargez la nouvelle version
Écrasez les fichiers des répertoires "app", "lib" et "public". Faites attention à garder vos anciens app/configuration/application.ini et public/data/Configuration.array.php
Supprimez le fichier public/install.php car vous n’en avez pas besoin dans le cas d’une mise à jour

Et n’hésitez pas à remonter le moindre soucis.

Quelques remerciements

Clairement, cette version a été boostée par les contributions externes et je tiens à remercier tout particulièrement :

Alexandre Alapetite (Alkarex) qui a proposé pas moins de 25 pull requests. Il a notamment amélioré les requêtes SQL, le code Javascript, le saut automatique aux catégories non lues suivantes ainsi que... beaucoup d’autres choses ! D’un coté je trouve ça un peu fou que quelqu’un ait pu passer autant de temps à améliorer FreshRSS, de l’autre je trouve ça génial ! ☺
Cypouz qui a proposé le nouveau logo beaucoup plus sympa que le précédent.
Vincent qui a aussi un peu participé au logo, mais qui est surtout très encourageant et remonte régulièrement des soucis.

J’aimerais d’ailleurs faire remarquer que c’est grâce aux différentes contributions que le projet évolue le plus. Sans cette aide externe et ces retours, sans doute que FreshRSS serait déjà abandonné car je ne verrais pas l’intérêt d’en faire plus. Si c’est le développeur qui insuffle la vie à un projet, c’est la communauté autour qui le fait vivre. Merci donc à tous pour votre aide !

À propos du logo

Tout logo se doit de représenter une idée, un concept. Extraits des discussions à propos du nouveau logo :

Le nouveau logo de FreshRSS

J’ai finalement gardé le logo RSS (principe central du programme), entouré d’autres logo RSS (les autres sections des cercles, symbolisant la multitude de flux à suivre), le tout sous forme circulaire concentrique (symbolisant l’aspect rassembleur du programme, qui centralise les flux suivis). Le côté « fresh » est rappelé par la couleur bleu.

L’avantage [de ce logo] [...] est aussi qu’il est ouvert. [...] Le fait qu’il soit ouvert peut sous-entendre beaucoup de choses : l’ouverture du code source, l’invitation à participer, une porte pour les flux RSS qui peuvent ainsi « entrer », etc.

Le rond pourrait représenter le noyau qu’est FreshRSS et qui agrège les différents flux

Vers la 0.6 et au-delà !

Comme à chaque publication de nouvelle version je rajoute une nouvelle étape avant la version 1.0, je ne ferai donc pas de pronostics cette fois-ci sur une version stable. Voici néanmoins mes plans pour la prochaine version qui sera donc la 0.6 :

Ajout de la page de statistiques prévue pour la 0.5 (#90)
Ajout d’une API "compatible Google Reader" (#13)
Gestion de SQLite en plus de MySQL (+ PostgreSQL ?) (#100)
Refonte du code Javascript (#121)
Permettre l’import / export des articles favoris (#163)
Possibilité de partager un article vers Diaspora* et Poche (#175)
Script de mise à jour automatique de la base de données

Du gros boulot en perspective donc, mais qui devrait me rapprocher toujours plus d’une version finale. Si vous avez des demandes, n’hésitez pas à m’en faire part sur Github. Pour le moment les seules demandes que j’ai refusées (ou reportées à une version ultérieure à la 1.0) sont la gestion multi-utilisateurs et une interface alternative de connexion : ça demanderait beaucoup trop de boulot en profondeur.

J’ai aussi dans mes cartons l’idée de fournir un wiki sous forme de documentation utilisateur ou de FAQ pour présenter les différentes options de FreshRSS et expliquer comment l’utiliser au maximum de ses capacités. Le dernier délai pour m’en occuper est la date de sortie de la version 1.0... autant dire que j’ai le temps :D

En guise de conclusion

J’espère que FreshRSS saura vous satisfaire autant qu’il me satisfait moi-même. Je n’ai pour le moment eu aucun retour réellement négatif, j’ai quelques utilisateurs pleinement (?) satisfaits et je vois même fleurir sur Internet, de temps en temps, quelques articles parlant de mon agrégateur. Ce qui est, disons-le, très bon pour mon ego ☺

Aussi, je vais bientôt fêter les un an du projet (le premier commit date du 21 octobre 2012) et c’est toujours encourageant de voir que de plus en plus de personnes trouvent de l’utilité dans mon travail. Travail qui était au départ totalement personnel et n’était pas parti pour durer dans le temps. Force est de constater que FreshRSS a mué peu à peu vers un projet un peu plus communautaire et ouvert et je suis pleinement satisfait de cette transformation.

Edit

Suite à un bug assez important dans la gestion des catégories (les catégories vides n’apparaissaient plus), je suis passé en version 0.5.1. J’en ai profité pour inclure quelques patchs de traduction et correction ;)

DesperadOS, le système qui fait bang!

2013-10-05T11:16:00+02:00

Aujourd'hui le monde de l'informatique se sépare entre Windows et Mac. Parfois il arrive qu'un barbu sorte de sa salle de serveurs pour râler "Gnu/Linux, pas Linux", mais ça reste anecdotique. Si je prends le clavier ce jour, c'est pour vous parler d'un nouveau système d'exploitation qui va très certainement révolutionner votre vie.

Fonctionnalités

Un système innovant se doit de proposer des technologies à la pointe. DesperadOS ne se contente pas d'être innovant, il est révolutionnaire !

Système multi-processus avec ordonnancement de type Round-Robin
Gestion bas-niveau des sémaphores
Gestion du clavier, de l'écran ET du temps
Écran de veille en mode VGA
Système de fichiers avec arborescence en mémoire
Shell incluant pas moins de 21 commandes

L'authentification par empreinte biométrique est en cours d'intégration, la révolution est en marche.

La vidéo qui va bien

Vous pouvez bien entendu douter de ma parole et remettre en cause le bien-fondé de mon enthousiasme. C'est sans compter que je ne suis pas venu les mains dans les poches. Cette vidéo saura très certainement vous faire changer d'avis.

Genèse du projet

En juin dernier, alors que le soleil et la pluie se faisaient la cour, un certain nombre d'individus savourait les joies de ne pas pouvoir profiter de leur temps libre. Une mission les réunissait : développer le système d'exploitation qui allait maximiser leur note de projet.

Si je vous en parle, c'est parce que j'ai moi-même participé à ce grand beau projet. J'étais là quand les profs ont présenté le sujet. J'étais là aux premières lignes de code. J'étais encore là lors du premier bug. J'étais aussi là les midis, au moment de faire le grand choix "pâtes ou sandwichs". Oui, je peux affirmer que j'étais là car j'ai moi-même subi la première semaine sans clim' en haut de ce bâtiment exposé au soleil en plein milieu de l'après-midi.

Bien entendu, je n'étais pas seul : Paul et Micko complétaient notre groupe.

Le concept

Pour ceux qui ne l'ont pas encore compris, bien entendu DesperadOS n'est en rien révolutionnaire. Encore que sa façon de planter durant la démo... mais Microsoft nous a devancé. Deux fois.

Durant deux semaines et demi en juin dernier, par groupe de trois, nous avons donc eu à développer un système d'exploitation. À savoir que nous partions d'une base de code fournie mais qui ne faisait basiquement... rien (ce qui n'est qu'à moitié faux). À partir de ce rien du tout, il nous a donc fallu gérer l'affichage à l'écran, le temps, l'ordonnancement des processus, le clavier et j'en passe. Autant dire que c'était bien fun ☺

La gestion du projet

Nous étions seulement trois pour ce projet donc la gestion fut assez simple. Nous avons utilisé Trello pour tout ce qui fut gestion des tâches et je dois avouer que c'était plutôt efficace. Selon moi, ça reste néanmoins un outil à utiliser en groupe et je n'ai jamais réussi à l'utiliser (trouvé l'utilité ?) dans un projet perso.

Git fut bien entendu aussi de la partie pour la gestion du code et comme nous avions tous un minimum d'expérience avec, ça n'a pas posé de soucis particulier (j'aime Git <3)

Rapide retour d'expérience

Les deux semaines et demi passées sur ce projet ont vraiment été géniales. Nous avons enfin pu comprendre comment fonctionne un système d'exploitation au plus bas niveau (les joies de l'assembleur :D), la gestion des processus et des ressources. C'est vraiment un projet à ne pas rater et où l'on peut prendre son pied si on s'applique.

Bien sûr il y a eu quelques (nombreuses) difficultés qui nous ont fait désespérer de finir le projet... mais les surmonter ne fut que plus enthousiasmant. Notons tout de même que notre code ne fut pas parfait et nous sommes passés à côté d'un ou deux éléments importants. Mais je pense que le plus important reste d'avoir compris dans les grandes lignes le fonctionnement d'un système d'exploitation.

Depuis j'ai rapidement essayé de me plonger dans le code de Linux. Force est de constater que le code est... dense. J'ai abandonné. Il y a eu quelques articles d'introduction sur LinuxFR à l'époque, mais impossible de les retrouver.

Sans doute plus intéressant et plus facile d'accès, Manux (non, il ne s'agit pas d'un mauvais jeu de mot). Système d'exploitation purement français (les fichiers, le code, les commentaires : tout est en Français) et issu... du projet système de l'Ensimag, il y a déjà quelques années de ça ! Le développeur avait fait une annonce lors de la sortie de la version 0.0.1 sur LinuxFR.

Et la suite

J'aurais voulu pouvoir partager le code qui devrait d'ailleurs être en grande partie (voire totalement) sous licence libre, néanmoins je n'ai pas le droit de fournir les solutions aux futurs étudiants. Et dans le cas où ils passeraient par ici, je ne peux évidemment pas vous mettre le code à disposition. Dans le cas où il m'arriverait par hasard de vouloir reprendre en totalité le projet pour obtenir quelque chose de plus abouti (hum...) et différent du projet de base, je me ferai une joie de partager le code... Mais je ne me fais pas trop d'illusions ;)

Si vous voulez plus d'infos sur ce projet, notre page de (ensi)wiki décrit un peu mieux l'OS. Vous pouvez aussi voir le travail des autres groupes (il y en a des vraiment impressionants, mais ils avaient plus de temps :p). Et enfin, la page qui présente le sujet du projet. C'était en tout cas le projet le plus intéressant que l'on ne m'ait jamais proposé et ce serait avec joie de continuer encore un peu. Je me demande juste pourquoi j'ai mis autant de temps à écrire cet article.

Une v6 qui carbure

2013-08-29T14:22:00+02:00

6 mois. 6 mois seulement que j'avais fait évoluer mon site vers sa cinquième version. Faut dire que j'étais parti dans un petit délire qui rendait le tout pas très pratique à manipuler. Mais c'est de l'histoire ancienne ! Aujourd'hui j'officialise cette v6 de mon cher petit site.

Qu'est ce qui se cache donc sous le capot cette fois-ci ?

Un blog PluXML

Ça y est, j'ai enfin décidé qu'il était temps d'arrêter de vouloir tout redévelopper alors qu'il existe des CMS et des logiciels qui font les choses très bien et même mieux. Depuis le début de ce site je me suis refusé à utiliser un moteur de blog tel que PluXML, Dotclear ou Wordpress parce que je voulais faire les choses moi-même. Force est de constater qu'il est beaucoup plus simple d'utiliser le produit d'un autre quand il est maintenu correctement.

PluXML a tout pour lui : léger, sans base de données, facile à adapter à ses besoins, système de plugins, (vraiment) bien codé. Je peux enfin respirer après des années à utiliser une interface d'administration pour mon site pas terrible.

J'ai quand même pu récupérer l'ensemble de mes anciens articles pour les gérer via PluXML. Bien sûr, les URL pour y accéder ont changé et certains liens dans les articles ne fonctionneront plus. Et vu que cette fois j'ai la flemme de tout vérifier, ça restera ainsi (sauf si la motivation revient).

Un Shaarli

C'est un grand retour. Alors que je l'avais abandonné durant la v5 pour un outil fait maison, j'ai assez vite déchanté. Les bugs et l'interface (là encore assez peu glamour) m'ont forcé à repasser à Shaarli. Mêmes explications que plus haut, ne pas avoir à se charger de la maintenance d'un produit est une épine enlevée du pied.

Je vais donc pouvoir recommencer à partager mes liens comme avant ! :)

Les plus attentifs remarqueront que j'ai abandonné le flux unifié de mes articles de blog / liens partagés. À vrai dire, le fait que mes liens arrivent en première page, de la même manière qu'un article, me gênait. En effet, un lien partagé est censé être moins important qu'un article et devrait rester en seconde page.

Un design fait avec amour

Je parlais de design glamour, et ceux qui connaissent l'interface standard d'un Shaarli me diront que s'en est tout l'inverse. Le design par défaut de PluXML n'est pas non plus des plus enthousiasmant. Et le design précédent de ce site était sans commune mesure plus laid que les autres (alors qu'étrangement j'avais réussi à faire quelque chose de pas mal avec la v4).

Heureux que vous devez être alors d'apprendre que je vous propose au téléchargement le design tout beau (enfin j'espère) que j'ai développé pour ce site. Une partie pour PluXML et une autre pour Shaarli. Attention tout de même pour le Shaarli, j'ai fait des modifications dans le index.php et j'ai remanié entièrement les fichiers TPL (la création d'un thème à part entière pour Shaarli n'est pas encore au point).

Pour les couleurs, le fantastique site Flat UI Colors m'a énormément aidé. Je me suis aussi inspiré de ce que j'ai fait pour FreshRSS pour compléter. Bref, j'espère que ça vous plaira !

Un nouveau départ

Je n'écrit jamais beaucoup sur ce site / blog (à peu près un article par mois depuis le début de l'année !). J'espère que cette nouvelle version avec un vrai moteur de blog va me motiver un peu plus. De toute façon, ce site reste mon site et ma vitrine, aucune chance que je l'abandonne lâchement ! :D

Si toutefois vous souhaitez (me) lire, j'essaye d'être plus régulier (et plus compréhensible) sur mon blog dédié à mon voyage en Norvège.

FreshRSS 0.4, une release qu’elle est bien

2013-07-04T20:38:00+02:00

Cher toutes et tous,

séchez vos larmes, l’an 0 après Google Reader vient de commencer. Séchez vos larmes car vient vers vous une foultitude de nouveaux agrégateurs qui ont essayé de rivaliser ces derniers mois en terme de choix, de fonctionnalités et d’ergonomie. Séchez vos larmes vous dis-je car FreshRSS vient de sortir en version 0.4 et vous apporte plein de bien belles nouveautés.

Les infos utiles

FreshRSS est un agrégateur de flux RSS à auto-héberger sur son propre serveur. Il est relativement rapide et puissant. Il se différencie des autres agrégateurs par quelques fonctionnalités bien utiles et une ergonomie pensée pour un usage quotidien. À titre d’exemple, quelques points forts de mon application :

Une version mobile (que j’adore !)
Chaque recherche (par mot-clé ou par tag) possède son propre flux RSS. Vous pouvez donc vous abonner à un flux RSS généré par FreshRSS avec tous les articles contenant le mot "Linux".
Actualisation possible par CRON
Internationalisation : anglais et français supportés
Marquage des articles comme lu au défilement de la page (optionnel)
Différents modes d’affichage (normal, lecture et global)
Chargement des images en mode lazyload (chargement uniquement lorsque l’image doit apparaître à l’écran)
Possibilité de récupérer des flux RSS tronqués
Et bien d’autres !

Qui dit nouvelle version, dit mise à jour de la démo, toujours accessible à la même adresse pour les plus pressés.

Les grandes nouveautés

Ajout de deux modes de vue

Jusque là, il n’existait qu’un mode de lecture "par défaut" permettant de parcourir, lire, mettre en favoris, etc. les articles. Désormais il y aura aussi la "vue lecture" qui se veut plus agréable quand vous ne souhaitez que lire (pas marquer comme lu ni rien. Juste lire). La troisième vue est la "vue globale" vous permettant de voir d’un coup d’œil les flux possédant des articles non lus. Cette dernière est largement perfectible mais a le mérite d’exister.

Personnellement je continue d’utiliser la vue normale par défaut car plus pratique pour moi, mais sur mobile, la vue lecture est plus agréable par exemple. Le but est de vous proposer différentes approches de FreshRSS pour ne pas vous enfermer dans un mode de fonctionnement unique. Je suis ouvert à toutes suggestions d’amélioration de ces vues, notamment la vue globale que je trouve finalement assez inutile en l’état, bien que j’ai déjà des idées pour l’améliorer.

Possibilité d’optimiser la base de données

L’optimisation de la base de données est une chose d’assez peu connue, et je pense très rarement utilisée dans les applications web "basiques". Ceci dit, à l’aide d’un simple bouton vous pourrez désormais réduire la taille utilisée par votre base de données : je suis passé d’une base de 28Mo à une base de 20Mo. En revanche, j’ignore si toutes les bases de données supportent bien cette commande SQL et je suis intéressé par d’éventuels retours !

Pour information, la requête SQL qui se cache derrière tout ça est (voir la doc MySQL) :

OPTIMIZE TABLE nom_de_la_table

Mode endless

Le mode endless fait son grand retour. Ce mode permet de charger les articles suivants le dernier de la liste en les rajoutant à la suite, sans avoir à recharger la page complètement.

Ça marche beaucoup mieux qu’avant (il y avait des soucis quand on marquait les articles comme (non) lu) mais il se peut qu’il reste quelques soucis car je ne l’utilise pas trop de mon côté.

Chargement des images en mode lazyload

Cette fonctionnalité j’en suis particulièrement content parce que j’étais très dubitatif sur son intérêt avant de l’intégrer... puis finalement je ne peux plus m’en passer !

Le principe est de ne charger les images des articles qu’à partir du moment où elles sont censées apparaître à l’écran. Le gain de temps au chargement de la page est énorme. Le seul soucis est que l’on se retrouve de temps en temps avec un rectangle gris, le temps de charger l’image. Pour cela, il est possible de désactiver la fonction de lazyload, mais je vous conseille quand même de la garder ;)

Possibilité de marquer les articles comme lu au défilement

Là encore une fonctionnalité très intéressante. Grâce à celle-ci, il est possible de marquer un article comme lu lorsque vous en avez lu à peu près les 3/4. Cette fonctionnalité marche très bien lorsqu’on lit avec les articles "dépliés" par défaut, mais peut se coupler aussi avec les articles pliés. Il ne tient qu’à vous de définir les réglages qui vous conviennent le mieux !

Et bien d’autres !

Des corrections de bugs, des améliorations au niveau du design et de l’ergonomie, des petits ajouts par-ci par-là. Je vous laisse découvrir cette nouvelle version qui devrait plaire à pas mal d’entre vous ☺

Mettre à jour votre FreshRSS

Comme pour le passage de la v0.2 à la v0.3, la mise à jour devrait être assez facile puisqu’il n’y a pas de modification de la base de données.

Téléchargez la nouvelle version
Écrasez les fichiers des répertoires app, lib et public. Faites attention de garder vos anciens app/configuration/application.ini, public/data/Configuration.array.php et tout fichier que vous avez pu modifier de votre côté.
Enfin, supprimez le fichier public/install.php car vous n’en avez pas besoin dans le cas de la mise à jour (sauf si vous tenez à refaire l’installation :p)
Un soucis ? Nos équipes se chargent de vous répondre au plus vite.

Fonctionnalités futures (v0.5 ou v1.0 ?)

Autant vous le dire, je pense que FreshRSS n’a plus besoin de beaucoup d’ajouts. Aussi, si je n’ai pas trop de demandes pour la prochaine version, il se peut qu’il s’agisse de la version 1.0 (enfin !)

Et donc, au menu ce que je vous prépare (pas grand chose au final) :

Un sélecteur de thèmes (bug 86). J’essayerai de proposer au moins 3 thèmes différents pour varier les goûts.
Une page de statistiques (bug 90). Au delà du côté bling-bling de la fonctionnalité, je pense que ça peut être utile (/ intéressant) de voir quels sont les sites qui publient le plus, quels jours, etc. J’essayerai de ne pas surcharger en graphiques tout de même ;)
Correction de bugs... comme d’habitude !
Amélioration des nouvelles vues
Et je pense que ce sera tout.

Par la suite (si je m’arrête là) j’assurerai évidemment la maintenance pour corriger les bugs, mais je ne pense pas ajouter de nouvelles fonctionnalités... si vous êtes intéressés par des nouveautés, faites m’en part au plus vite !

N’oublions pas les autres

Car si FreshRSS ne vous convient pas, il existe bien d’autres agrégateurs. Donnez au moins une chance à Kriss Feed ou Leed qui évoluent aussi pas mal de leur côté avec des développeurs à l’écoute des remarques qu’on peut leur faire (c’est important !). Je suis fan du côté facilité d’installation de Kriss Feed et du système de plugins de Leed (ce ne sera pas suffisant pour me faire abandonner FreshRSS ceci dit :p)

Remerciements

J’aimerais remercier toutes les personnes qui m’ont fait des retours ou des suggestions, notamment 4nti-7rust pour l’idée du marquage au défilement de la page, rplanelles pour l’idée du chargement des images en mode lazyload et Vincent pour parler de FreshRSS un peu partout !

Je n’oublie pas les autres qui m’ont demandé de l’aide par mail, notamment la courageuse personne qui a essayé d’installer FreshRSS sur un espace Free (pour information, il n’y a pas PDO sur les serveurs de Free apparemment, on ne peut donc pas y installer FreshRSS -_-)

J’en profite pour conclure que c’est vraiment agréable d’avoir tous ces retours car ça motive le développement et me permet de savoir pour "qui" je travaille (c’est encore plus gratifiant que les 15 étoiles sur Github :p)

Le mot de la fin

Agrégateur. (et non pas aggrégateur comme je peux le voir régulièrement !)

RunPG et géolocalisation font bon ménage

2013-06-19T19:20:00+02:00

Voilà bien longtemps que je n’avais rien écrit et aujourd’hui je m’en viens vous parler donc d’un petit projet : RunPG. Il s’agit d’un projet web que j’ai réalisé pour l’Ensimag, mais avant tout c’est surtout un petit PoC de jeu (Proof of Concept, un petit jeu permettant de mettre en application une idée) auquel je pensais depuis quelques temps. L’idée donc était à la base de "faire courir les geeks" (ou pas). Le concept est simple : vous allez courir avec votre smartphone, une application (web ici) enregistre votre parcours grâce à la géolocalisation et fait progresser votre personnage en fonction de votre vitesse / durée de course / distance parcourue. Pour compléter la présentation, je vais laisser la parole à mon README :

Description

RunPG est un jeu type RPG utilisant la géolocalisation pour faire évoluer votre personnage. Les quêtes consistent à parcourir un certain nombre de kilomètres en un minimum de temps. L’enregistrement se fait grâce à la version web de RunPG et utilise les possibilités de géolocalisation du téléphone et du HTML5.

Les contraintes

Il s’agit d’un projet web pour l’Ensimag, un certain nombre de contraintes m’ont été imposées :

Utilisation du framework Java, Play (obligatoire) : OK
Gestion de droits avec différents niveaux d’utilisateurs (obligatoire) : OK (visiteur, joueur, admin)
Gestion d’un flux RSS (optionnel) : OK (classement et joueur)
Utilisation d’un webservice (souhaitable) : OK (maps et données de OpenStreetMaps)
Une partie du site en GWT (souhaitable) : NOK (choix assumé)
Version mobile de l’application (optionnel) : OK (tout le site est full responsive design)

Voilà donc ce qu’il y a dire sur le projet. Il me faut quand même préciser quelques petites choses :

Comme je le disais plus haut il s’agit d’un PoC, je n’ai donc pas poussé les fonctionnalités jusqu’au bout. L’administration par exemple est vraiment très basique, ne permettant que de supprimer des joueurs ou de modifier leur score / expérience. Néanmoins, la base est là. Il s’agissait en effet de vraiment se concentrer sur l’aspect géolocalisation vers évolution du personnage.
On ne peut pas courir plus de 30 minutes sinon la requête qui synchronise votre parcours avec le serveur est trop grosse (trop de points GPS) et ne passe pas (oups :$)
Il n’y a (pour le moment) aucun serveur hébergeant ce mini-jeu
Mais le code de RunPG est disponible sur Github
J’ai placé le tout sous licence Copyheart mais tout ce qui est images et code incorporé garde sa licence d’origine
Le tout est basé sur le framework Java, Play (version 2.1.1), basé sur les concepts MVC. Il vous faudra donc installer le framework sur votre PC. Je pense qu’en s’y connaissant un peu, on prend rapidement ses marques pour comprendre le code. Si jamais je dois reprendre le concept un jour néanmoins, ce sera en Python (j’ai envie de me mettre à ce langage pour de bon ☺)
Si vous êtes intéressés pour reprendre le code / l’idée du jeu, n’hésitez pas à me poser des questions (notamment pour la phase de débogage qui peut être assez pénible)

Et pour finir, quelques images de la bête :

L’accueil

La page de classement (oui il n’y a que quatre joueurs)

La vue mobile lorsqu’on enregistre un parcours (j’utilise ici le simulateur de Firefox OS, très utile lors du débogage)

La page d’administration (très basique)

Amusez-vous bien ! ☺

Welcome to FreshRSS 0.3!

2013-05-05T13:03:00+02:00

Non je n’écrirai pas cet article en anglais comme peux le laisser penser ce titre, mais il s’agit d’introduire la plus grosse nouveauté de cette nouvelle version toute fraîche de mon agrégateur de flux RSS : l’internationalisation de l’application ! L’anglais et le français sont donc désormais pris en charge intégralement ; FreshRSS va pouvoir partir à la conquête du nouveau continent. N’étant pas forcément bon en orthographe en anglais, n’hésitez pas à me remonter les erreurs de traduction ☺

Nouveautés

Mais s’il s’agit de la plus grosse nouveauté, il ne faut pas oublier toutes les autres qui ne sont pas non plus en reste. Au programme de cette nouvelle version donc :

Une page dédiée qui sert de site officiel
Internationalisation
Création d’un logo temporaire. Je trouve celui que j’ai fait à l’arrache de plus en plus laid mais le problème est que je n’ai aucun talent de graphiste ☹ Je prendrai le temps d’en faire un mieux pour la version 1.0 ou je ferai appel à quelqu’un peut-être...
Meilleure gestion CSS3 pour les navigateurs ne supportant pas les dégradés ou les transitions de façon "officielle" (utilisation des préfixes propriétaires bien que j’en ai horreur)
Possibilité de s’abonner à des flux derrière une authentification HTTP (c’était déjà le cas, mais pas réellement de façon officielle, et les identifiants apparaissaient totalement en clair)
Mise en cache des favicons (le site getFavicon va être soulagé)
Affichage des vidéos incluses dans les articles (SimplePie les enlevait par défaut)
Une bien meilleure gestion de la recherche et du filtrage par tags ! Ça m’a demandé beaucoup de temps et une bonne prise de tête pour en arriver là mais j’en suis assez content. Problème : il se peut que les performances soient fortement dégradées. Si vous vous rendez compte que votre serveur ne tient pas la charge, faites-le moi savoir, j’essayerai de voir ce que je peux faire. Ceci dit, sur mon instance qui stocke pour le moment 1600 articles ça passe très bien. Petit plus : vous pouvez accéder au flux RSS d’une recherche ou d’un filtre. Une fois votre recherche lancée, il suffit de rajouter le paramètre "&output=rss" dans l’url ou de cliquer simplement sur le bouton à côté de "Gestion des abonnements"
J’ai créé un "vrai" script CRON de façon à pouvoir mettre tous les flux à jour d’un coup sans que le serveur vous rejette avec un timeout.
Et bien sûr, divers corrections de bugs avec une revue du code pour qu’il soit plus clair

Mise à jour

À priori la mise à jour se fait très simplement : il vous suffit de télécharger la nouvelle version et d’écraser les anciens fichiers avec les nouveaux. Pensez à supprimer le fichier ./public/install.php qui ne vous sert à rien si vous faites une mise à jour, ou alors on vous redemandera les informations que vous aviez rentré à la première installation (ça marchera quand même, mais ça ne sert à rien ;)). Pas de mise à jour de la base de données cette fois-ci, donc si vous tourniez correctement avec la version 0.2, c’est tout bon.

Et la suite ?

La version 0.4 est en approche, mais il se pourrait que ce soit aussi la version 1.0, tout dépend des idées qui me viendront pour la suite. Les nouveautés à prévoir sont les suivantes :

Changer un flux de catégorie par drag and drop
Version mobile : passer à l’article suivant/précédent par effet de slide (glissement du doigt vers la gauche pour aller à l’article suivant, vers la droite pour passer au précédent)
Ajout de vues "Lecture" et "Globale" : la vue "Lecture" sera dépourvue d’éléments "perturbateurs", la vue "Globale" offrira une vue permettant de voir en un coup d’œil quels sites ont publié depuis votre dernière visite
Optimisation de la table en base de données : c’est un petit truc que j’utilise personnellement pour réduire la place utilisée en base de données par les articles (voir https://dev.mysql.com/doc/refman/5.5/en/optimize-table.html)
Gérer les soucis de flux : permettra de voir quels sont les flux qui n’ont pas réussi à se mettre à jour en le mettant en rouge par exemple
Possibilité de filtrer les tags en cliquant dessus (via "Tags associés" dans un article)

Si vous souhaitez voir apparaître d’autres fonctionnalités, n’hésitez pas à me les soumettre, je suis preneur ! Mais de préférence faites-le d’ici dimanche prochain : après, les demandes seront prises en compte pour la version 0.5.

Mise à jour du site - la v5 est là \o/

2013-02-28T19:20:00+01:00

J’ai mis mon site à jour en fin de semaine dernière. Cette dernière version est très inspirée par Shaarli de Sebsauvage, tout en allant un poil plus loin. Le principe de Shaarli est de partager des liens qui nous paraissent pertinent et de faire un rapide commentaire dessus, le tout, sans se prendre la tête. Mon problème étant que je n’ai pas que des liens à partager, et même si je n’avais que ça, ils se retrouvent assez dispersés.

En gros il m’arrive de publier des liens, mais aussi des articles de blog ainsi que ce que j’appelle des statuts (oui oui, à la façon Facebook). Les liens que je partage passent soit par ma version maison de Shaarli (Links), soit par mon lecteur (maison) de flux RSS (FreshRSS). De plus, je pourrais envisager d’autres outils de partage.

Je me retrouve donc pour le moment avec 3 outils de partage différents. Mon soucis était de tout publier automatiquement sur le site, dans un flux uni. C’est là qu’intervient mon outil Uniflux. Celui-ci permet de s’abonner à différents flux de type Uniflux et regroupe tout ce qu’il trouve dans un flux unique. Je n’ai plus qu’à afficher côté client (le site) les articles, les liens et les statuts.

Ça c’était pour l’introduction... mais maintenant plusieurs questions peuvent se poser et je vais essayer d’y répondre.

Un schéma, un schéma !

Oui, de suite !

Note : il n’y a aujourd’hui plus de schéma, mais ce n’est pas grave, Uniflux n’existe plus :)

Pourquoi avoir développé un Shaarli maison ?

Bien que je pense que Sebsauvage ait fait du bon travail, tout ne me satisfait pas dans Shaarli. Tout d’abord, quasiment tout le code se trouve dans le fichier principal : il en devient presque in-maintenable et pas du tout modulaire. J’ai eu à plusieurs reprises besoin d’un morceau de code venant de Shaarli (génération du nuage de tags, récupération des thumbnails externes, etc.) et bien vite on se retrouve à devoir récupérer d’innombrables fonctions pour que ça fonctionne. C’est dommage parce que ça pourrait être super utile en étant mieux découpé ☹

Autre argument, il y a trop de fonctionnalités que je n’utilise pas du tout et que je ne juge pas pertinentes pour mon usage... d’autant plus que je n’avais besoin de mon côté que de la partie "serveur".

Enfin... j’aime bien tout refaire de mon côté pour manipuler un peu et apprendre par moi-même, et ça, c’est la meilleure des excuses ☺

Pourquoi avoir inventé un nouveau format (Uniflux) alors que RSS pourrait très bien faire l’affaire ?

Oui parce qu’au final Uniflux n’est qu’un agrégateur d’articles et de liens... Il y a tout de même quelques soucis avec RSS (bien que j’en sois un fervent défenseur !). Déjà, le format est lourd (le XML a du bon, mais pas sa verbosité). Uniflux se contente d’une API en JSON que je trouve certes moins lisible, mais plus légère et tout aussi efficace. De plus ça me permet de faire évoluer le format comme je l’entends.

Si j’ai le courage de continuer, Uniflux gérera aussi un jour le flux de commentaires associé à un post (du coup mon site ne gère plus les commentaires, mais le ratio spam / commentaires pertinents était trop élevé pour que je passe du temps là-dessus)

Quel est l’intérêt ?

Mon soucis comme je l’ai dit est que je possède différents outils pour communiquer (le blog, Links et FreshRSS. Vu que j’ai incorporé à chacun l’export au format Uniflux, il me suffit d’ajouter l’url de l’API d’export et mon flux est automatiquement alimenté. Si jamais un jour je décide de créer un outil de gestion de fichiers, je n’aurai qu’à ajouter un export au format Uniflux pour partager des fichiers que je souhaite rendre public. Automatiquement le partage sera disponible sur mon site. À vrai dire, il me suffit d’ajouter un export au format Uniflux à n’importe quelle application web, et mon outil pourra s’y connecter naturellement et alimentera mon site.

C’est un peu ma bataille à moi contre la dispersion de nos informations. En effet, je suis parti du constat que je partageais des choses sur Facebook, Google+, Diaspora*, etc. et que j’aurais bien voulu que tout se retrouve dans un flux unique. Alors j’ai décidé d’arrêter d’utiliser ces outils et de me contenter de mes propres outils. Et ça me convient parfaitement. C’est ce que je cherchais et ça répond à mes besoins. C’est simple, efficace et je l’ai fait avec mes petites mains ☺

Mais... c’est utilisable ?

Franchement ? Non. Enfin si, mais pour le moment, que par moi je pense. Ça manque de documentation, ça manque d’une idée claire sur ce que je veux gérer, ça manque d’une bonne utilisation et ça manque surtout d’énormément de recul. Je publierai le code de tout ça un de ces jours à l’état de proof of concept mais je compte remanier un peu le bouzin afin d’avoir un truc exportable. Si finalement j’arrive à clarifier mes idées, j’intégrerai tout ça dans Minz (mon framework PHP) afin de pouvoir créer des applications connectées en quelques lignes. Maiiis... ça attendra encore un peu, j’ai des partiels avant :p

Conclusion

Voilà donc un rapide état des lieux du boulot fourni depuis plusieurs mois (ça fait quand même pas mal d’applications écrites). J’aime autant préciser (je le fais à la fin, mais j’aurais peut-être dû le faire au début...) : je n’assure aucun suivi sur aucune des applications que j’ai développées, mise à part Minz. Tout ce que j’ai fait a été développé dans un but personnel pour répondre à mes besoins. Néanmoins j’envisage de refondre un peu mon lecteur de flux RSS et d’assurer de la maintenance dessus.

FreshRSS : un agrégateur simple et léger

2012-10-28T14:15:00+01:00

Note importante du 16 mai 2013 : le projet a beaucoup évolué depuis cet article. Comme je vois toujours beaucoup de liens pointant ici, je tiens à vous rediriger vers des liens plus actuels.

L’article original du 28 octobre 2012

Quand on parle d’agrégateurs de flux RSS, on a souvent en tête RSSLounge et TinyTinyRSS, les deux poids lourds du secteur (j’exclue volontairement les solutions qu’on ne peut pas auto-héberger, vous l’avais compris). Pour certains d’entre vous, il y aura aussi Leed, le petit dernier développé par Idleman. Mais aujourd’hui, je vous offre ma propre solution faite maison : FreshRSS (licence AGPL3).

Tout d’abord, expliquons le pourquoi. Ceux qui ont déjà manipulé RSSLounge savent que ce n’est pas franchement ce qu’il y a de plus léger. Je n’ai jamais essayé TinyTinyRSS mais tout le monde s’accorde pour dire qu’il est encore plus lourd que le précédent. J’utilisais personnellement RSSLounge tant bien que mal, en pestant plus qu’autre chose lorsque je voulais ajouter un flux RSS. La surcouche javascript rendant les choses particulièrement indigeste. Puis vint Leed, promesse d’un agrégateur plus clair, plus léger, plus simple. Je pense que cette promesse a été tenue par Idleman. Mais voilà, je suis un éternel insatisfait et il ne m’a pas convaincu, notamment à cause de l’espace pris sur l’écran mal optimisé et le manque de raccourcis.

…

Bon d’accord, je me cherchais juste une excuse pour me développer mon propre agrégateur ! C’était aussi une occasion de prouver que mon framework PHP pouvait s’adapter à plusieurs usages de façon très modulaire.

Bref, pour éviter de tourner autour du pot, voilà ce que peut vous apporter FreshRSS :

Un système léger, non alourdi par une tonne de javascript (beaucoup de choses se font en PHP). Il y a du javascript certes, mais il sert à faciliter la navigation et tout peut fonctionner sans.
Une interface que j’espère optimisée pour la lecture de vos flux
Des raccourcis pour naviguer et pour marquer les articles comme lu / non lus, favoris / non favoris. Ces raccourcis sont paramétrables.
L’importation / exportation OPML (attention, j’ai eu des soucis d’importation avec le fichier exporté par RSSLounge)
La possibilité de lancer une tâche CRON sur l’url mettant à jour les flux
Système d’authentification basé sur Persona de Mozilla (bon, c’est encore assez bancal je trouve et ça utilise du javascript...) Personnellement je bloque l’accés à mon flux RSS par une authentification HTTP.
Catégorisation des flux (comme la plupart des agrégateurs)
Un affichage correct sur écran de smartphones (mais pas optimisé)
Et surtout, pas trop de trucs "bling bling" ☺

Le mieux reste de tester FreshRSS. J’ai bien évidemment bloqué l’accés à la configuration ici pour éviter que vous ne changiez tout (ce sont mes propres flux qui s’affichent ;)). Pour les touches de raccourcis, vous pouvez utiliser :

page down et page up pour naviguer entre les articles
gauche et droit pour naviguer entre les pages
espace pour ouvrir l’article sélectionné dans un nouvel onglet

Petite précision avant de terminer : FreshRSS a été développé dans un but strictement personnel, sans aucune prétention et s’adapte à mes propres besoins. Je n’ai pas immédiatement cherché à faire en sorte qu’il s’adapte à d’autres usages que le mien (l’ajout de la connexion via Persona est la seule exception car je ne l’utilise pas). Néanmoins, si vous souhaitez voir apparaître de nouvelles fonctionnalités vous pouvez me les soumettre... mais ce n’est pas dit que j’y réponde dans l’immédiat :p

Oh, et puis ce n’est qu’une version alpha pour le moment ;)

Le changement, c’est maintenant !

2012-05-19T15:48:00+02:00

Au moins pour le design de mon site. Comme je le disais dans un article précédent, je suis un éternel insatisfait du design de mon site. Mais bon, cette fois-ci c’est la bonne ! (jusqu’à la prochaine) Au menu, une simple épuration du haut du site, l’utilisation d’une police d’écriture plus agréable à l’œil, et une révision de l’affichage des articles du blog.

Sans oublier quelques corrections de bugs et d’une grosse (grosse) faille (je considère que l’affichage de la configuration pour accéder comme on veut à la base de données est une faille ☺)

Sortie de MINZ 1.0 - framework PHP

2012-03-24T22:53:00+01:00

Et bien voilà, après quasiment un an de développement plus qu’irrégulier, j’ai le plaisir d’annoncer la version 1.0 de mon framework PHP : MINZ Is Not Zend.

Pour la petite histoire

J’ai commencé à développer ce framework à la base dans un but totalement personnel. Ayant pratiqué un petit peu Zend durant ma dernière année de DUT informatique, sa lourdeur m’a vite agacé. Puis voulant voir comment développer un framework, je suis parti des idées de Zend pour me bâtir ma propre architecture et manipuler un peu plus de PHP.

Ainsi MINZ a été à la base de mon site personnel depuis tout ce temps, me permettant de tester à plus ou moins grande échelle les fonctionnalités dont j’avais besoin.

La présentation tirée du (court) wiki

MINZ est un framework PHP, c’est-à-dire qu’il propose une architecture particulière pour l’écriture d’applications PHP. On peut le voir comme un squelette, et l’application comme les muscles, cerveaux, peau, etc. Ce framework repose lui-même sur la modélisation MVC (pour Model View Controller). Le modèle MVC permet de séparer logiquement les données (un utilisateur avec un nom, un prénom, un mot de passe par exemple), leur représentation (la façon dont on va les afficher) et leur traitement. Cela permet d’avoir une application facile à maintenir.

MINZ est fortement inspiré de Zend Framework, qui est un autre framework PHP. Bien qu’inspiré, il s’en éloigne par bien des aspects, d’où son nom en clin d’oeil : MINZ Is Not Zend. Il se veut notamment bien plus léger et plus facile à mettre en place afin de faciliter le déploiement d’applications MINZ. De par ce soucis de légèreté, il existe quelques contraintes qui le rendent moins puissant, ce qui n’est pas vraiment un soucis pour des applications simples (un blog, un site ou une galerie photos par exemple). Si vous connaissez déjà Zend Framework, il est certain que vous y trouverez de nombreuses similitudes, notamment au niveau de l’architecture.

Le code de MINZ est sous licence AGPL 3.

Les fonctionnalités en vrac

Routage des urls avec url rewriting géré par PHP. Cela permet de simplifier le processus de réécriture d’urls sans se prendre la tête avec Apache. En contrepartie, le système est moins puissant, même si j’ai pensé à quelques améliorations, qui ne verront sans doute jamais le jour...
En complément du routage, j’ai mis en place un système d’écriture d’urls. Ainsi, on a la possibilité d’activer ou de désactiver l’url rewriting à la volée, sans casser les liens internes au site.
L’historisation du parcours des visiteurs permet de garder un fil de leur visite, permettant de mettre en place facilement des liens de retour aux pages précédentes. Je ne suis pas bien sûr de conseiller cette fonctionnalité puisqu’elle est sujette à pas mal de difficultés de mise en place.
La mise en cache des pages du site basé sur MINZ est gérée automatiquement par le framework sans avoir rien à faire.
L’internationalisation des applications a aussi été prise en compte à travers une classe dédiée permettant de mettre facilement en place différentes langues pour le site.
Un système a été développé pour faciliter la pagination de listes (d’articles de blog par exemple)
Et enfin, une classe pour logguer les erreurs, warnings et autres actions nécessitant d’être logguées ;)

Et la suite ?

Aujourd’hui j’ai sorti la version 1.0 après plus d’un mois en version alpha... J’avoue que j’ai pris mon temps : j’attendais d’avoir terminé la documentation (sous licence CC BY-SA), et ça ne me motivait plus du tout. Alors la suite, je ne pense pas faire de gros changements au framework, seulement des mises à jour de bugs. Même si une roadmap est en place sur la page GitHub dédiée, ce qui y est indiqué ne verra sans doute pas le jour. Sauf si quelqu’un a envie de se lancer là-dedans ;)

À vrai dire je commence à en avoir marre de développer uniquement des applications web, et j’ai envie de passer à autre chose. J’ai d’autres projets qui cogitent, et j’ai envie de me lancer là-dedans.

Au final et en guise de conclusion

Je suis vraiment content d’en être arrivé là avec mon "semblant de framework" comme je l’appelais il y a un an. Au départ c’était totalement un projet pour moi-même, pour voir ce dont j’étais capable et en étant persuadé que j’arrêrais 1 mois plus tard. C’est mon premier vrai gros projet qui peut avoir une réelle utilité. J’ai appris nettement plus de choses en développant mon framework que ce que tous les sites et profs ont pu essayer de m’apprendre en PHP (bien qu’ils m’aient appris beaucoup de choses !). Et puis ça fait toujours du bien d’arriver à mener un projet à son terme, surtout après un an de développement ☺

Sortie de MINZ 0.5

2012-02-12T23:12:00+01:00

Après la mise à jour du site hier, j’ai décidé de mettre à jour mon framework PHP, MINZ.

Au programme, pas mal de grosses nouveautés plus ou moins utiles : gestion de l’internationalisation, amélioration de la gestion des sessions, ajout d’un historique de navigation, des classes toutes faites pour gérer les utilisateurs, arrivée des exceptions et de nombreuses corrections de bugs.

L’application de tests a été revue au passage pour montrer les nouveautés. La connexion se fait à travers le système OpenID que je prends en charge nativement dans MINZ (en plus du protocole XMPP). Ces deux systèmes font leur arrivée par la petite porte ; à comprendre que MINZ ne prend en charge que la phase de connexion. De plus, pour ce qui est de XMPP il y a un problème lorsque je l’utilise sur ce serveur et je suppose que c’est le port 5222 qui est bloqué, ce qui m’empêche de l’utiliser.

Pour ce qui est des exceptions, je n’ai pas encore trop poussé le concept et il y a encore un gros boulot à faire de ce côté là. Mais je pense que dans le futur ce sera bien plus efficace et très utile pour le coeur du framework.

Un petit mot sur l'internationalisation : la classe Translate me permet à partir d'une "clé" d’aller piocher dans des fichiers de traduction la valeur correspondante à la langue désirée. Je ne l’utilise pas sur le site, mais l’application de test permet de montrer le principe.

Un autre petit plus à l’application de tests, c’est l’affichage des logs de l’application.

Pour finir dans les choses importantes, l’historique de navigation permet de créer un lien pointant vers une page déjà visitée précédemment. Je l’utilise sur le site pour mes liens de retour. Cela permet de ne pas perdre la navigation et ça fonctionne à peu près comme l’historique du navigateur (même si des problèmes techniques m’empêchent de pousser le concept jusqu’au bout). Par exemple, si vous cliquez sur le lien pour accéder à la page de présentation de MINZ, le lien "retour" présent sur la page vous permettra de revenir à la page où vous êtes actuellement ☺

Ce qui est prévu pour la suite : amélioration de la structure du framework avec l’utilisation poussée des exceptions PHP, création d’une classe permettant de gérer facilement la mise en cache, création de nouveaux Models, de la documentation (/!) et bien sûr, l’habituelle correction de bugs ☺

À bientôt j’espère pour une version 0.6 !

La v4 nouvelle est arrivée

2012-02-11T16:52:00+01:00

La dernière grosse mise à jour du site datait de juillet dernier. Aujourd’hui, je passe à la v4 du site, et ce n’est pas pour me déplaîre !

Au menu, de nombreuses améliorations pour faciliter la navigation sur le site, et l’administration de mon côté.

Une nouvelle manière de me connecter

C’est une chose qui me trottait en tête depuis un moment, et c’est chose (plus ou moins) faite. L’identification sur le site passe par XMPP. Je n’ai qu’à entrer mes identifiants, le serveur se charge alors d’interroger le serveur XMPP correspondant qui dit si oui ou non les identifiants sont ok. Trouvant la chose bien utile, et permettant de démocratiser le XMPP, j’ai décidé d’intégrer cette façon de faire nativement dans MINZ. Mais malheureusement, vu qu’une bonne nouvelle n’arrive jamais seule, cela ne fonctionne pas comme il faut actuellement sur le serveur. Je suppose que c’est une histoire de pare-feu qui bloque le port 5222 (le port utilisé par XMPP) ☹

Du coup, poussé par ce besoin de ne pas éparpiller mes identifiants, et l’envie de découvrir d’autres choses, je me suis penché sur OpenId... et finalement, ça marche plutôt bien ☺ L’identification se passera donc ainsi, mais j’ai dans l’idée d’offrir le choix. Puis ça me permettra de mettre en place le design pattern Factory :p

Une refonte partielle du design

C’est un de mes principaux défauts, je suis un éternel insatisfait du design. Il me faut toujours le reprendre. Celui-ci, se basant grandement sur le thème précédent voit disparaître la colonne de droite pour l’insérer dans le footer. Le header voit sa place réduite au strict minimum. Du coup, le contenu du site se retrouve vraiment mis en avant.

La flèche permettant de remonter en haut de la page reste désormais toujours affichée en bas à droite de l’écran. À part ça, j’ai essayé d’homogénéiser toute l’interface afin de ne pas avoir une interface trop brouillone.

Du nouveau pour le blog

Le blog se dote aussi de son lot de nouveautés. Les tags tout d’abord : afin de décrire plus précisément mes articles, j’ai toujours trouvé les tags super pratiques. J’ai eu un peu de mal à me décider sur une implémentation mais j’ai décidé de m’inspirer du Shaarli de SebSauvage au final. Un nuage de tags a été intégré en bas de la page, et ~~le gros du travail va être désormais de mettre à jour les différents articles déjà publiés pour les tagger.~~ -> c’est fait ☺

De plus, désormais j’aurai la possibilité d’enregistrer mes articles à venir sous forme de brouillons. Très pratique si je veux revenir sur mes articles tout en pouvant les prévisualiser, sans avoir à passer par un autre éditeur.

Enfin, depuis un petit moment j’ai enlevé les commentaires sur le blog. Le choix s’expliquant par le fait que je n’ai aucun commentaire réellement "intéressant" et que je me fais polluer par le spam (oui je pourrais ajouter un captcha, mais je n’aime pas ce système). Sur le coup je l’ai fait assez "salement", mais désormais, j’ai une option codée à peu près correctement et je pourrai les (dés)activer comme bon me semble. Et pour la peine, ceux-ci sont réouverts (d’autant plus que la suppression du spam n’aura jamais été aussi simple que maintenant ☺)

Des nouveautés en vrac

L’habituelle correction de bugs est bien entendue au rendez-vous. Quelques ajouts par-ci par-là au niveau de l’administration ainsi que quelques révisions dans la manière de coder me permettent d’avoir un code plus propre et un site plus stable ☺

En conclusion

J’ai hésité à estampiller cette version de "4", mais vu que la mécanique du site ressent quand même un gros changement et que j’ai ajouté à peu près toutes les idées qui me restaient en tête, je pense que cette version le mérite ☺

Màj du site sous MINZ 0.4

2011-11-11T20:43:00+01:00

Article rapide pour indiquer que j’ai passé mon site sous la dernière version de mon framework. Avec ça arrive ma nouvelle galerie photos développée par mes soins. Notez que tout ce qui est url rewriting est géré par le framework, et ça c’est top ☺

Bref, la migration s’est bien passée ;)

EDIT. J’en ai profité pour mettre à jour l’application MINZ de tests, et je l’ai passé en version... 0.5 beta ! ☺ C’est donc la version encore en développement. Au programme notamment, l’internationalisation, qui a été plus facile à mettre en place que ce que je ne croyais. J’en ai aussi profité pour épurer encore plus le design de base ^^ ... oh :O je viens de découvrir une grosse faille en l’installant ☺

Sortie de Minz 0.4

2011-10-30T16:31:00+01:00

Suite à la version 0.3 du mois précédent j’avais quelques améliorations à apporter à mon framework.

Tout d’abord, le routage des urls internes au site avait été un gros morceau, mais très incomplet à mes yeux. Aussi j’avais vraiment besoin d’améliorer ceci. C’est désormais chose faite : quelques bugs ont été corrigés et surtout, le routage d’urls dynamiques est désormais possible ! ☺ Ainsi, si on définit le code suivant (tiré de mon appli de galeries photos) dans la table de routage :

array(
    'route'       => '/see/galerie/*/photo/*',
    'controller'  => 'index',
    'action'      => 'see',
    'params'      => array('gal', 'photo')
),

l’url http://test.exemple/see/galerie/2/photo/42 (par exemple) sera routée vers le contrôleur index, l’action see, et avec les paramètres $_GET['gal']=2 et $_GET['photo']=42. C’était vraiment un gros morceau, pas facile à mettre en place, mais je suis content de l’avoir fait !

Un autre morceau que je voulais coder était une classe de configuration, au lieu de passer par des constantes globales. J’en ai profité pour revoir le fichier de configuration qui sera désormais un fichier .ini (même si le fichier de constantes est pris en charge). Les paramètres environment et use_url_rewriting ont été ajoutés et sont indispensables. environment permet de définir un niveau de verbosité (les logs et les erreurs seront plus ou moins bavards). use_url_rewriting quant à lui sert à dire si on souhaite utiliser l’url_rewriting ou non. D’ailleurs il n’existe pas de fonction php servant à savoir si ce module est activé ou non, et c’est bien dommage ☹

Je viens de citer les logs. En effet, je trouvais ça intéressant de les intégrer au cœur du framework afin de débugguer une application. Pour le moment c’est perfectible, mais je suis content du résultat.

J’ai ajouté une classe Url permettant de créer dynamiquement les urls internes au site. En effet, à cause de l’url rewriting et de mon système de routage, il pouvait y avoir des problèmes si jamais le serveur ne permet pas de réécrire les url. Mais maintenant c’est de l’histoire ancienne ! ☺ La classe Url, à travers sa méthode statique display() va s’occuper de voir si on utilise l’url rewriting (à travers le paramètre de configuration déjà nommé plus haut). Si oui, il va chercher dans la table de routage si l’url que l’on souhaite écrire possède une route et si oui, la construit pour l’affichage. Si non, il construit l’url de façon plus basique (du type http://test.exemple/?c=blog&a=voir&id=42 ). Au final ça rend le framework très puissant car il gère tout seul l’url rewriting, et on n’a plus à se soucier de savoir si le module est activé sur le serveur ☺ Et pour construire l’url, la ligne suivante suffit :

echo $this->url->display(array(
    'c' => 'blog',
    'a' => 'see',
    'params' => array('id' => 42)
));

... bon d’accord, ça peut paraître lourd, mais au vu des bénéfices, je pense que ça vaut largement le coup ;)

Enfin, dernière amélioration importante, la gestion des pages d’erreurs a été améliorée. Avant, je me contentais d’afficher une page blanche avec les messages d’erreurs. Désormais, les erreurs peuvent être intégrées au design du site. Comme dit précédemment, les erreurs affichées sont gérées grâce au niveau de verbosité défini par le paramètre de configuration environment.

Et sinon j’ai corrigé plusieurs petits bugs, fait quelques retouches, bricolé par-ci par-là. Bref, cette version 0.4 n’est plus vraiment compatible avec les versions précédentes, bien qu’une migration puisse sans doute se faire sans trop de mal. Je l’ai bien fait pour mon appli de galeries photos ;) Le plus compliqué sera de migrer mon site sur cette version, mais ça vaudra surement le coup ! J’ai vraiment hâte d’intégrer les urls dynamiques et ma galerie photos... malheureusement ma connexion Internet ne me permet pas de faire du ftp ni sftp. Bref, ça va encore devoir attendre ;)

Pour la prochaine version, j’espère pouvoir intégrer une classe pour gérer l’internationalisation du site (ce qui va demander pas mal de boulot), corriger des bugs (en espérant que cela ne soit pas nécessaire :p), améliorer tout ce qui est Model et DAO et surtout, proposer de la documentation conséquente ! J’ai déjà commencé à réaliser un document, mais ça demande pas mal de boulot pour synthétiser, faire des exemples, des schémas, etc. Puis avec cette nouvelle version, il y a quelques bidules à remanier...

Minz 0.3

2011-09-11T11:30:00+02:00

Quelques jours seulement après la version 0.2, je sors cette version 0.3.

Quelles nouveautés alors ? Et bien deux gros morceaux que je voulais absolument implémenter et qui me limitaient un peu dans mes divers développement.

Tout d’abord, la réécriture d’url à travers un module de routes. Comment ça marche ? Et bien regardez l’url dans la barre de votre navigateur qui doit être ici du genre http://marienfressinaud.fr/?c=blog, ce qui signifie que le controller de l’application se nomme blog. Avec cette version, j’aurai la possibilité de transformer cette url en http://marienfressinaud.fr/blog. Ce n’est pas grand chose, et c’est facilement faisable avec un fichier .htaccess, mais j’avais la volonté de le faire directement à travers le framework. Le morceau de code qui fera ça est on ne peut plus simple :

return array(
    array(
        'route'       => '/blog',
        'controller'  => 'blog',
        'action'      => 'index'
    )
);

avec possibilité de rajouter autant de routes que l’on veut évidemment ;) Ainsi, lorsque l’on regarde un article en particulier, par exemple à l’url http://marienfressinaud.fr/?c=blog&a=voir&id=62, on peut rajouter un peu de code :

return array(
    array(
        'route'       => '/blog',
        'controller'  => 'blog',
        'action'      => 'index'
    ),
    array(
        'route'       => '/blog/voir',
        'controller'  => 'blog',
        'action'      => 'voir'
    )
);

et l'url http://marienfressinaud.fr/blog/voir?id=62 emmènera au même article. On voit d'ailleurs ici la limitation avec les urls un peu dynamiques, je ne gère pas encore les paramètres supplémentaires comme ici id, mais j'y pense ;) Bon, je n'utilise pas encore cette nouvelle version sur ce site parce que ça demandera un peu plus de travail pour l'intégrer et que ma connexion internet ne me le permet pas :p

Deuxième fonctionnalité, aussi importante à mes yeux, l'ajout d'un bootstrap d'application. À quoi il sert celui-là ? En fait ce bootstrap pourra être modifié directement par le développeur pour automatiser certaines tâches. Par exemple, dans chacun de mes controllers, j'ai les lignes (entre autres)

$this->view->prependStyle(DOMAIN.'/themes/default/base.css');
$this->view->prependScript(DOMAIN.'/scripts/jquery.js');
$this->view->user = new User();

ce qui devient très vite rébarbatif. Et bien ce bootstrap me permettra de les charger automatiquement grâce à sa méthode run(). De ce fait, je n’aurai qu’à l’écrire une fois, et tous mes controllers seront impactés donc il y a quand même un certain gain en temps ☺

J’espère que ça intéressera quelqu’un, surtout que d’un point de vue personnel, je trouve mon framework très bien et de plus en plus puissant (oui oui, je suis très objectif ! :D)

MINZ 0.2

2011-08-26T22:14:00+02:00

Voilà voilà, j’ai fait quelques améliorations du code aujourd’hui de mon petit framework. Deux ajouts importants : l’ajout de la classe Paginator pour faciliter la pagination et la gestion des magic_quotes. J’en ai aussi profité pour commenter la librairie (pas la partie application qui sert un peu moins je pense) et pour ajouter un fichier FEATURES : en gros ce que j’aimerais ajouter avant de sortir la version 1.0 comme la possibilité de créer des "routes" (indiquer que bidule.com/test/index correspond au contrôleur test et l’action index par exemple et étendre le bootstrap pour que l’utilisateur puisse gérer directement dans son propre bootstrap des actions exécutées fréquemment. Ça ferait que je pourrais avoir de jolies url et, aussi, automatiser certaines tâches qui sont souvent pénibles à recopier.

Vous remarquerez aussi que je ne m’embête pas avec la numérotation des versions... Du moment que ça monte de toutes façons, moi, ça me va ;)

P.S. Si vous comptez l’utiliser, ou juste le tester, n’hésitez pas à me laisser un commentaire histoire que je sache si je bosse que pour moi ou non ☺

MINZ Is Not Zend

2011-08-12T08:55:00+02:00

Voilà voilà ☺ Ça fait un moment que je devais le faire, c’est chose faite : j’ai mis en ligne mon petit framework PHP. Pour son nom c’est évidemment un clin d’oeil au projet GNU (pour GNU’s Not UNIX) et à Zend Framework.

Pour la petite histoire, j’ai découvert Zend cette année durant mon projet tuteuré de DUT et ça m’a pas mal inspiré. J’avais plein de projets en tête et il me fallait un framework. Trouvant que ceux existant ne s’appliquaient pas à mes petits projets, j’ai décidé de m’en coder un tout seul. C’est comme ça qu’est donc né ce framework. À vrai dire ça a été très intéressant car j’ai pu me pencher sur tout un tas de trucs que je ne connaissais pas et qui sont vraiment géniaux ! ☺

Ceci dit, MINZ est certes très léger, mais il manque encore un peu de flexibilité. J’aurai tout un tas de petites choses à ajouter (notamment étendre le bootstrap pour l’application elle-même). Cependant, il se tient déjà très bien comme ça, la preuve, mon site personnel tourne sous MINZ ;)

Je n’ai pas (encore) écrit de documentation, cependant, vu qu’il repose sur plusieurs mécanismes de Zend, si vous connaissez déjà ce dernier, l’utilisation de MINZ en sera très facile. Il repose d’ailleurs aussi sur le modèle MVC. De plus, la mini-application fournie avec celui-ci permet d’en comprendre très facilement le fonctionnement... en tout cas je l’espère. J’ai commenté la partie qui permet de gérer la base de données (dans la configuration et dans le modèle "User") afin que même si je n’utilise pas la BD ici, vous puissiez comprendre facilement comment l’utiliser.

Bref ! N’hésitez pas à l’utiliser, à le modifier, le sécuriser, etc. Je n’ai qu’un souhait, ne pas l’avoir fait pour moi seul. Le code est bien évidemment placé sous licence AGPL 3 comme mes autres applications ;)

v3 du site

2011-07-10T20:38:00+02:00

Sinon, niveau nouveautés, j'ai atteint je crois la v3 de mon site (2 mois après la précédente :D) En fait ça devenait assez urgent parce que la structure précédente n'était pas suffisamment "modulable". Donc en nouveautés, on peut retrouver : le design général (toujours assez bleu, mais avec une pointe de orange), des liens pour me suivre (dans la colonne à droite), une mise en avant de mes projets et de ma galerie photos sur la page d'accueil, l'utilisation de la dernière version de mon "framework" PHP maison (oui il faut que je le mette en ligne lui aussi :$), et enfin, l'utilisation de nouveaux smileys ! :D Pour ces derniers je tiens à remercier Geoffrey Dorne qui m'a gentiment autorisé à utiliser ses smileys sur mon site. Je l'ai ajouté dans ma liste "crédits" de la page "À propos". Les précédents étaient assez encombrants, et vu que j'en utilise toujours en grand nombre, je trouvais ceux de Geoffrey plus sobres et donc mieux adaptés à mon site. Et donc si vous souhaitez pouvoir les utiliser, il faut d'abord lui demander l'autorisation (via son site par exemple), merci de respecter son travail ;)

Tout ça m'a demandé quand même pas mal de travail parce que la dernière version de mon framework m'a imposé de nouvelles règles donc je me suis amusé à tout recoder... Au final je suis plutôt content parce que je trouve le rendu plus sûr et surtout plus "pro". J'ai aussi modifié ma méthode de coder le CSS afin de le rendre plus clair et plus lisible. J'essaye désormais de faire ressortir l'aspect html du site, et je sépare aussi la structure de l'aspect graphique.

Pour terminer, je vous demanderai simplement, si vous remarquez des bugs d'affichage sur le site, de me les indiquer par mail (l'adresse est à droite ;)). Je n'ai en fait testé que sous Mozilla Firefox 5, et Chromium 12, le tout sous Gnu/Linux, donc pas vraiment représentatif ^^ Mais je ne pense pas qu'il y ait trop de problèmes... mais avec Internet Explorer hein :p

P.S. depuis quelques temps j'ai la chance d'avoir une série de spams dans les commentaires, donc il ne faut pas s'inquiéter des messages bizarres. J'ai pas vraiment envie de mettre en place un captcha (trop contraignant), mais si le problème dure trop, j'activerai la modération (un false à passer à true et hop ! :D)

~~Ah oui puis pour le moment le flux rss n'a pas été recodé donc pas accessible, désolé ☹~~ Corrigé ☺

marienfressinaud.fr v2

2011-04-01T20:08:00+02:00

Et voilà une petite v2 du site ! ☺

Côté visiteurs, pas grand chose qui change (mise à part sans doute au niveau du blog qui est mieux intégré, avec possibilité maintenant de laisser des commentaires ;))

Par contre, désormais j’ai une petite zone "administration" qui est tout à fait sympathique et beaucoup plus agréable que de taper du texte en dur !

Tout ça m’aura pris un certain nombre d’heures, mais le jeu en valait la chandelle ☺ J’ai pu améliorer mon semblant de framework pour le sécuriser un peu plus. En effet j’ai récupéré ce que j’avais commencé à faire pour mon projet MyCalendar, qui ne demande pas beaucoup de sécurité puisqu’il est censé être installé uniquement en local dans un but personnel ;) Mais là vu que le site est accessible à n’importe qui, il a fallu que je m’assure de la sécurité... et je suis plutôt content ☺

Le passage de local au serveur s’est très bien passé et j’ai été plutôt bluffé d’ailleurs. Mais je suppose que ça vient du fait que je suis de plus au plus au point niveau PHP et que j’ai pensé à pas mal de choses au préalable. Bon par contre c’est sûr, il reste encore un peu de boulot avant de pouvoir partager les sources, mais une fois que ce sera bon, je mettrai à jour la zone "projets" ;)