<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0"><channel><title><![CDATA[Blog - Rémi Huguet, Software explorer]]></title><description><![CDATA[Feed for the blog of Rémi Huguet, software explorer.]]></description><link>https://remihuguet.dev</link><generator>RSS for Node</generator><lastBuildDate>Tue, 18 Feb 2025 08:19:48 GMT</lastBuildDate><atom:link href="https://remihuguet.dev/rss.xml" rel="self" type="application/rss+xml"/><item><title><![CDATA[Veille de la semaine - N°1]]></title><description><![CDATA[Le récap de ma veille de la semaine - 
Voilà quelques temps que je me disais que ce serait pas mal de rationnaliser un peu ma veille perso et les partages que je fais régulièrement. Jusqu'à présent, cela se passait selon le processus hautement scientifique suivant: 

1. accumuler des contenus dans Pocket au fil de mes pérégrinations sur le réseau
2. lire certains articles tout de suite et d'autre non, sans aucune règle
3. parfois partager tout de suite un contenu, parfois attendre.
4. une fois de temps en temps (genre toutes les 2 semaines, voire 3 semaines), passer la moitié de mon week-end à faire le tri et à lire tout ce qui me paraît en valoir la peine
5. partager tout ce je trouve intéressant au fil de l'eau sur Twitter durant ce week-end
6. recommencer pour un cycle de 2 ou 3 semaines

Le résultat:
- je suis écoeuré de mon week-end, et je n'ai pas envie de recommencer. D'où les 2 semaines minimum pour m'en remettre ... 
- les rares bonnes âmes qui me suivent sur les réseaux sont spammées de mes liens durant le repos dominical... 
- j'oublie aussi sec, à la fois ce que j'ai partagé et une bonne partie du contenu

Voilà comment je vais essayer d'améliorer:

1. accumuler des contenus dans Pocket au fil de mes pérégrinations sur le réseau
2. prévoir un crénau quotidien pour lire ma récolte - au passage, ça permet d'essayer de traiter les problèmes de focus (mais c'est un autre sujet)
3. si ça me plait, préparer un partage sur Buffer - ça me permet d'égrener les partages dans le temps (pour l'instant 2 par jour) et de faire un partage sur plusieurs réseaux en une fois
4. une fois par semaine, faire un récap du tout ici même, agrémenté de commentaires persos si l'envie m'en prend - ça me permet aussi de fixer à plus long terme ce que j'ai lu
5. recommencer

Ça vous paraît bien ? moi aussi. 

## Le récap de la semaine

### Développement

#### [The incredible Growth of Python](https://stackoverflow.blog/2017/09/06/incredible-growth-python/)

Une étude étonnante de la croissance de l'intérêt pour Python dans les statistiques de Stack Overflow. Bien entendu, ce genre de données est toujours à prendre avec beaucoup de précautions.
Cependant, le taux de croissance est impressionnant pour un langage très mature, présent dans l'écosystème depuis longtemps et déjà bien installé. Je suis très curieux d'en connaître les raisons sous-jacentes (spoiler: data science et machine learning, la suite de l'article a été publiée.)

#### [The hard thing about software development](https://www.linkedin.com/pulse/hard-thing-software-development-jesse-watson/)

Une contribution intéressante sur la véritable valeur ajoutée des développeurs. Un plaidoyer de plus pour arrêter de se vendre sous des étiquettes techniques.

#### [The Outrageous Cost of Skipping TDD & Code Reviews](https://medium.com/javascript-scene/the-outrageous-cost-of-skipping-tdd-code-reviews-57887064c412)

Un article de plus pour vanter ( à juste titre ) TDD et les revues de code. Ce n'est pas le premier et pas le dernier. Bien que je ne partage pas toutes les conclusions de l'auteur, l'article s'appuie sur des données qui semblent crédibles. C'est assez rare.

### Web 

#### [Fiabiliser les connexions sécurisées avec HSTS (HTTP Strict Transport Security)](https://blog.dareboost.com/fr/2017/09/hsts-fiabiliser-connexions-securisees/)

Un excellent article de Boris Schapira sur HSTS. J'ai découvert quelquechose, et l'exposé est vraiment de grande qualité et très pédagogique. Si vous gérez un site servi sous HTTPS (et vous ne devriez plus faire autrechose), la problématique devrait vous parler: comment fait-on pour gérer proprement les connexions qui arrivent via HTTP? Il y a toutes les réponses dans l'article.

#### [World Wide Web Consortium abandons consensus, standardizes DRM with 58.4% support, EFF resigns](https://boingboing.net/2017/09/18/antifeatures-for-all.html)
 
Le W3C décide de standardiser DRM, et ça met le bazar. Je suis assez ignare des subtilités de gouvernance du W3C, j'ai donc bien du mal à anticiper les conséquences de l'événement. 
Quoi qu'il en soit, pas besoin d'être expert en la matière pour comprendre que standardiser les DRM, c'est une très mauvaise nouvelle pour la diffusion des contenus sur le web. A suivre ...
 
#### [Pour un web design inefficace](http://sacripant.fr/notes/38/pour-un-web-design-inefficace)

Thomas Jund nous délivre une réflexion intéressante et nous invite à prendre un peu de recul sur les tendances de conception sur le web.

### Startups

#### [Stop Wasting Time Planning Your Business Model](https://salon.thefamily.co/stop-wasting-time-planning-your-business-model-50275e8d054b)

Une nouvelle fois, Oussama Ammar, de la société d'investissement TheFamily, nous gratifie d'un article de grande qualité sur le sujet des startups. Un exposé clair et percutant, qui dessine en creux certains des comportements qui contribuent à pourrir l'écosystème et à lui donner (malheureusement souvent à juste titre) une mauvaise image. 

Mon passage préféré, parce que vous devriez tout simplement ignorer les médias quand il s'agit de startups, et qu'on ne le répétera jamais assez:

> It’s that way for a reason: most everything that the media publishes about startups is a lie (or at least missing so much of the story that it’s indistinguishable from a lie).
]]></description><link>https://remihuguet.dev/blog/2017/09/24/veille-de-la-semaine-n-1</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/09/24/veille-de-la-semaine-n-1</guid><pubDate>Sun, 24 Sep 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 6]]></title><description><![CDATA[Beaucoup de contenus non technique. - 
Cette semaine, peu de liens, mais il y a de bonnes choses. A ne pas rater: [Technical interviews are garbage. Here’s what we do instead](https://be.helpful.com/https-medium-com-fnthawar-helpful-technical-interviews-are-garbage-dc5d9aee5acd) et [No, I have no side code projects to show you](https://www.codementor.io/ezekielbuchheit/no-i-have-no-side-code-projects-to-show-you-cz1tyhgdz)


## Les liens

### [Front-End Checklist](http://frontendchecklist.com/)

Une check-list complète pour vérifier les éléments importants du développement d'une page web. Toujours utile &hellip;

### [Horizontal Attention Leans Left](https://www.nngroup.com/articles/horizontal-attention-leans-left/)

Une étude intéressante sur les zones de l'écran qui concentrent l'attention des utilisateurs. Cette étude fait suite à une étude de 2010. Résultat: la moitié gauche de l'écran ( 1920 pixels de large) mobilise 80% de l'attention des utilisateurs. A garder en tête au moment de créer des mises en page: sauf à avoir de très bonne raisons et de savoir ce que l'on fait, mieux vaut s'en tenir à des layouts conventionnels.

### [If you were born before 1985, most high-tech firms won't hire you.](https://www.inc.com/geoffrey-james/the-unforgivable-sin-in-silicon-valley-being-gen-x.html)

Ok, je me suis senti particulièrement concerné vu que j'ai passé la date de péremption. L'article met en lumière, dans le contexte particulier de la Silicon Valley, le jeunisme bas de plafond souvent à l'oeuvre dans notre industrie. Notamment, l'utilisation à toutes les sauces, que l'on retrouve souvent dans l'éco-système français, du concept fumeux de "digital native".

### [Technical interviews are garbage. Here’s what we do instead](https://be.helpful.com/https-medium-com-fnthawar-helpful-technical-interviews-are-garbage-dc5d9aee5acd)

Un retour d'expérience intéressant sur le problème posé par les procédés classiques de recrutement. Sans même parler des exercices de code pour les développeurs, les entretiens classiques ne constituent pas un moyen très efficace de réussir un recrutement. C'est un problème que j'ai ressenti, tant lorsque j'ai été dans la position du recruteur que dans la position du candidat.

La solution est théoriquement simple — travailler en conditions réelles avec les candidats. En pratique, c'est plus compliqué, à la fois pour des raisons pratiques, culturelles et financières. L'auteur de cet article pousse la logique au bout — après un court entretien destiné à lever des problèmes bloquants, les candidats sont embauchés pour une période de 90 jours. Parfois cinq personnes pour un même poste. Cela exige une communication parfaitement transparente, un accompagnement serré des candidats et une bonne dose d'éthique.

### [No, I have no side code projects to show you](https://www.codementor.io/ezekielbuchheit/no-i-have-no-side-code-projects-to-show-you-cz1tyhgdz)

>There is a small group of people for whom code speaks. They discovered more than a job, they discovered a calling. Code is a craft and they are artists. For every one of those folks there are thousands of amazing, solid developers that will write circles around 90% of the other CS graduates. But they aren't "the best."
><cite>Ezekiel Bucheit — No, I have no side code project to show you</cite>

### [From an internal Basecamp announcement re: pings/IMs](https://m.signalvnoise.com/from-an-internal-basecamp-announcement-re-pings-ims-e0f61ec9e3bd)

Un article comme souvent très pertinent de Jason Fried sur les communications en entreprise. Cette fois, il s'attaque à cette habitude stupide que beaucoup d'entre nous ont pu avoir à l'occasion sur les messageries instantanées: sonner l'interlocuteur via un message inutile, et attendre un retour pour déliver l'information que l'on souhaite communiquer &hellip; 


]]></description><link>https://remihuguet.dev/blog/2017/10/29/les-liens-de-la-veille-6</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/10/29/les-liens-de-la-veille-6</guid><pubDate>Sun, 29 Oct 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Veille de la semaine - N°3]]></title><description><![CDATA[Le récap de ma veille de la semaine - 
Cette semaine, des liens sur GraphQL, WebComponents et Grid Layout côté tech, un peu d'UX et de typo. A ne pas rater, un [brillant debunk de l'IA washing](http://www.oezratty.net/wordpress/2017/douze-mythes-intelligence-artificielle/), et une réflexion de fond pour éviter [l'apocalypse du logiciel](https://www.theatlantic.com/technology/archive/2017/09/saving-the-world-from-code/540393/?utm_source=twb).

### Dev, tech & web

#### [Dive Into GraphQL](https://marmelab.com/blog/2017/09/03/dive-into-graphql.html)

GraphQL est un des buzzword tech du moment. Développé, maintenu et promu par Faceboook, GraphQL est à la base un langage de requêtes pour construire une API. Mais c'est bien plus que ça: un standard, un runtime, de nombreuses implémentations de références et outils d'aide au développement, le tout porté par Facebook. Bref, une solution clés en main (ou presque) pour développer une API, d'où un succès certain auprès des développeurs. Cette série de posts est une introduction à GraphQL très bien construite et riche d'éclairages pertinents sur les avantages et inconvénients de la solution.

#### [I’ve seen the future, it’s full of HTML.](https://medium.com/@mikeal/ive-seen-the-future-it-s-full-of-html-2577246f2210)

Un article très intéressant sur Web components, le standard qui permet de définir des composants riches pour le web. 

#### [Web Truths: JavaScript can’t be trusted](https://christianheilmann.com/2017/09/26/web-truths-javascript-cant-be-trusted/)

Christian Heilmann pose les bonnes questions sur l'avenir de l'écosystème Javascript — sans troll.

#### [Introduction to CSS Grid Layout](https://mozilladevelopers.github.io/playground/)

Un super guide / bac à sable par Mozilla pour démarrer avec CSS Grid Layout. 

### UX

#### [An Overview Of The Most Common UX Design Deliverables](https://www.smashingmagazine.com/2017/09/comprehensive-overview-ux-design-deliverables/)

Une présentation synthétique et rapide des livrables de l'UX Design. C'est un post sponsorisé, ça ne va pas très loin, mais c'est un point de repère utiles pour tous ceux qui, comme moi, doivent faire un peu de conception UX et sont des newbies sur le sujet.

#### [A Five Minutes Guide to Better Typography](http://pierrickcalvez.com/journal/a-five-minutes-guide-to-better-typography)

Un joli petit blog post bien foutu sur les règles de bases pour une bonne typographie. 

### Métiers

#### [Redéfinir le chômage à l’âge des freelances](https://medium.com/@Vitolae/red%C3%A9finir-le-ch%C3%B4mage-%C3%A0-l%C3%A2ge-des-freelances-a3a90a99d7b2)

Une contribution intéressante à la réflexion sur l'évolution des institutions sociales nécessaire pour s'adapter aux évolutions du travail.


#### [The Coming Software Apocalypse](https://www.theatlantic.com/technology/archive/2017/09/saving-the-world-from-code/540393/?utm_source=twb)

Un article long, bien écrit et assez bien documenté sur le problèmes de la conception de logiciels, et les problèmes de qualité.

>The problem is that software engineers don’t understand the problem they’re trying to solve, and don’t care to,” says Leveson, the MIT software-safety expert. The reason is that they’re too wrapped up in getting their code to work. “Software engineers like to provide all kinds of tools and stuff for coding errors,” she says, referring to IDEs. “The serious problems that have happened with software have to do with requirements, not coding errors.” 

Les solutions mises en avant par l'article sont discutables, mais je crois qu'il pose les bonnes questions et les bons enjeux, et donne des éclairages intéressants sur les solutions expérimentées.

Un dernier passage, juste pour troller sur les IDE

>Visual Studio is one of the single largest pieces of software in the world,” he said. “It’s over 55 million lines of code. And one of the things that I found out in this study is more than 98 percent of it is completely irrelevant. All this work had been put into this thing, but it missed the fundamental problems that people faced. And the biggest one that I took away from it was that basically people are playing computer inside their head.

### Startups

#### [Good by Cozy](https://blog.addictedtointer.net/2017/09/26/goodbye-cozy/)

Franck Rousseau, co-fondateur et ex CTO de Cozy Cloud, délivre un retour d'expérience très intéressant.

#### [What’s a Tech Company?](https://salon.thefamily.co/whats-a-tech-company-515960d76c21)

Nicolas Colin propose un cadre pour définir une société tech, sur la base de critères assez simples. Un travail très interessant, qui soulève de nombreuses questions, notamment sur l'usage des data clients et la vie privée.

### Sideways

#### [Douze mythes de l’intelligence artificielle](http://www.oezratty.net/wordpress/2017/douze-mythes-intelligence-artificielle/)

Si comme moi vous êtes une bille sur la question de l'IA, mais que vous flairez le washing médiatique permanent, cet article est un super debunk très documenté et instructif sur le sujet. 


]]></description><link>https://remihuguet.dev/blog/2017/10/08/veille-de-la-semaine-n-3</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/10/08/veille-de-la-semaine-n-3</guid><pubDate>Sun, 08 Oct 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - N°5]]></title><description><![CDATA[Cette semaine, beaucoup de lien autour du développement, de l'architecture, des pratiques Agile. - 
A ne pas rater: [Technical Debt: an Incomplete Metaphor?](https://redmonk.com/rstephens/2017/08/08/technical-debt/) — une analyse remarquable des limites de la métaphore de la dette technique — et [Construire Une Architecture d’Information adaptée au Mobile](https://blog.stephaniewalter.fr/architecture-information-optimisation-mobile/), le compte-rendu très utile d'un atelier donné il y a peu lors de ParisWeb 2017.

### Dev

#### [Software architecture is failing](https://www.alexhudson.com/2017/10/14/software-architecture-failing/)

Une très jolie réflexion sur les choix d'architecture technique, souvent faits sans lien avec les enjeux métiers et sans stratégie technique claire. Microservices partout ?

#### [Technical Debt: an Incomplete Metaphor?](https://redmonk.com/rstephens/2017/08/08/technical-debt/)

Analyse très pertinente des limites et problèmes posés par la métaphore de la dette technique. 

#### [The Software Evolution Hasn’t Happened Yet](http://www.ouarzy.com/2017/10/14/the-software-evolution-hasnt-happened-yet/)

Un point de vue intéressant sur les problèmes de l'industrie logicielle.


#### [Vue.js + Brunch: The Webpack Alternative You've Been Hungry For](https://vuejsdevelopers.com/2017/08/20/vue-js-brunch/)

Brunch est un outil de build front-end très agréable à utiliser: simple, rapide et efficace. Quand on a pas besoin de toute les possibilités de Webpack, c'est une alternative intéressante.

#### [Web Truths: We need granular control over web APIs, not abstractions](https://christianheilmann.com/2017/10/16/web-truths-we-need-granular-control-over-web-apis-not-abstractions/)

Réflexion très intéressante sur les standards et les abstractions dans le web. 

### UX

#### [Construire Une Architecture d’Information adaptée au Mobile – ParisWeb 2017](https://blog.stephaniewalter.fr/architecture-information-optimisation-mobile/)

Un article méthodologique (qui reprend un atelier donné à ParisWeb 2017) pour construire une arcihtecture d'information sur mobile. Super intéressant et utile.

### Métier

#### [Why Isn’t Agile Working?](https://hackernoon.com/why-isnt-agile-working-d7127af1c552)

#### [I haven't experienced imposter syndrome, and maybe you haven't either](https://rachsmith.com/2017/i-dont-have-imposter-syndrome)

Intéressante remise en perspective sur le syndrome de l'imposteur. Il faut faire la part des choses entre ce qui relève du doute normal et ce qui relève de la souffrance psychologique réelle.
]]></description><link>https://remihuguet.dev/blog/2017/10/21/les-liens-de-la-veille-n-5</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/10/21/les-liens-de-la-veille-n-5</guid><pubDate>Sat, 21 Oct 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Veille de la semaine - N°2]]></title><description><![CDATA[Le récap de ma veille de la semaine - 
Cette semaine, beaucoup de liens dans ma veille autour du développement, avec notamment le retour de SQL, un peu de Git et du CSS, mais pas seulement. Ne manquez pas notamment le talk [The full-stack anxiety](http://mixinconf.com/videos/full-stack-anxiety/) et l'article [L’obsession du service client chez Captain Train](https://medium.com/@djo/obsession-service-client-captain-train-cb0b91467fd9). 


### Hors ligne

Vous connaissez le paradoxe de Fermi? Autour de 1950 ( les circonstances exactes ne semblent pas tout à fait connues ), le physicien Enrico Fermi essaye d'évaluer le nombre potentiel de civilisations extraterrestres en mesure d'entrer en contact avec nous. Obtenant un nombre très important, il formule le dit paradoxe: "si le nombre de civilisations en mesure de nous contacter est si grand, comment se fait-il que nous n'en ayons jamais perçu aucun signe ?". 

Un livre [Où sont-ils? Les extraterrestres et le paradoxe de Fermi](https://www.amazon.fr/O%C3%B9-sont-ils-extraterrestres-paradoxe-Fermi/dp/2271116376/ref=sr_1_1?ie=UTF8&qid=1506884973&sr=8-1&keywords=O%C3%B9+sont-ils), publié récemment, propose un état des lieux accessible et passionnant sur le sujet. Co-écrit par deux physiciens, deux astrophysiciens et un économiste, tous les aspects et les dernières connaissances acquises autour du sujet sont balayées: exoplanètes, exobiologie, communication et détection de signaux, stabilité des civilisations, ... 

S'intéresser à cette question, c'est aussi s'intéresser à nos origines et réfléchir aux enjeux posés par notre civilisation. Une excellente lecture que je vous recommande pour un après-midi pluvieux. En plus, l'artwork de couverture vaut son pesant de cacahuètes.

### Dev

#### [Why SQL is beating NoSQL, and what this means for the future of data](https://blog.timescale.com/why-sql-beating-nosql-what-this-means-for-future-of-data-time-series-database-348b777b847a)

Un article très complet et documenté sur l'histoire de SQL, sa disgrâce (relative et passagère) en faveur du mouvement NoSQL, et son retour en force comme langue de base pour l'exploitation de données. Note pour tout développeur: apprenez SQL.

#### [Framework Seams | 8th Light](https://8thlight.com/blog/mike-knepper/2017/09/20/framework-seams.html)

Un article sur l'utilisation des "seams", les coutures en bon français. C'est une forme de pattern de conception qui permet d'isoler différentes couches logicielles. Dans un contexte Ruby on Rails, l'auteur nous présente quelques techniques qu'il utilise, et c'est plutôt intéressant.

#### [Why you should stop using Git rebase](https://medium.com/@fredrikmorken/why-you-should-stop-using-git-rebase-5552bee4fed1)

Un bon article pour rappeler que, si rebase est une fonctionnalité très utile de git, il ne faut pas non plus que cela devienne un marteau pour tout vos clous.

#### [Guide to liberating layout through CSS Grid](https://cssgrid.cc/css-grid-guide.html)

Un sympathique guide pour aborder CSS Grid. Il va être temps de s'y mettre.

#### [Web truths: CSS is not real programming](https://christianheilmann.com/2017/09/19/web-truths-css-is-not-real-programming/amp/)

C'est bien connu, CSS est à peine un langage de programmation, et ça sert juste à faire de la décoration. L'auteur décortique intelligement la spécificité de CSS et, de façon plus générale du développement d'interfaces utilisateurs pour le web, à savoir: vous n'avez pas le contrôle. Faudra faire avec.

#### [Why is Python growing so quickly?](https://stackoverflow.blog/2017/09/14/python-growing-quickly/)

Suite et fin du suspense insoutenable sur les causes de la croissance de l'usage de Python observée chez Stack Overflow. En résumé: data science et machine learning.

### Métiers

#### [The full-stack anxiety](http://mixinconf.com/videos/full-stack-anxiety/)

Une excellente présentation sur un phénomène que nombreux parmi ceux qui travaillent dans le numérique connaissent: comment choisir où nous devons progresser dans une industrie de plus en plus complexe. Et accessoirement, comment ne pas devenir fou.

#### [The Prisoner’s Salary Dilemma](https://www.facebook.com/notes/kent-beck/the-prisoners-salary-dilemma/1655799601119564/)

Kent Beck explique pour vous devrier poliment refuser de dévoiler votre salaire actuel à un possible futur employeur. Je n'ai jamais été à l'aise avec cette question, ni en tant que candidat, ni en tant que recruteur. Je comprends mieux pourquoi.

### Startups

#### [L’obsession du service client chez Captain Train](https://medium.com/@djo/obsession-service-client-captain-train-cb0b91467fd9)

Captain Train est une des plus belles réussites de l'écosystème startups en France, tant du point de vue des valeurs que du point de vue économique. Cet article a le mérite de rappeler une chose essentielle à tous les wannabe entrepreneurs, qui est simple mais pourtant visiblement très difficile à exécuter: quand vous démarrez, seul compte le produit et le client.


#### [Grandes entreprises : la fin de la relation client](https://www.linkedin.com/pulse/grandes-entreprises-la-fin-de-relation-client-yves-cavarec/)

Dans la même veine que précédemment, un article bien senti sur le problème n°1 des entreprises établies: la relation client. Vous le voyez le lien avec l'article du dessus ? 
]]></description><link>https://remihuguet.dev/blog/2017/10/01/veille-de-la-semaine-n-2</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/10/01/veille-de-la-semaine-n-2</guid><pubDate>Sun, 01 Oct 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 9]]></title><description><![CDATA[Ouch, j'ai perdu le rythme de la veille. Deux raisons: je suis pas mal occupé à autre chose et par ailleurs, je dois bien dire que je trouve peu de contenus qui m'accroche ces dernières semaines.   - 
Or donc, une veille légère mais de qualitay. 

## A ne pas rater

### [Running in Circles](https://m.signalvnoise.com/running-in-circles-aae73d79ce19)

>People in our industry think they stopped doing waterfall and switched to agile. In reality they just switched to high-frequency waterfall.
><cite>Ryan Singer</cite>

Comme souvent avec les contenus des gens de Basecamp, les articles sont très bien faits (illustrés et tout). Et pour ne pas gâcher, parce que Basecamp est une belle boîte avec des valeurs solides, le fond est en général à la hauteur. C'est le cas de cet article, mais je vais vous avouer un truc: j'ai partagé dès que j'ai vu la phrase ci-dessus, sans lire la suite.


### [5 conseils pour mettre en place une culture produit dans une startup BtoB](https://medium.com/nerds-hopwork/5-conseils-pour-mettre-en-place-une-culture-produit-dans-une-startup-btob-1f09316e1dce)

Un chouette article plein de bon conseils pour les startups B2B. Je valide et signe des deux mains.

### [Startup Mistakes: Choice of Datastore](https://www.stavros.io/posts/startup-mistakes-datastore/)

Allez hop, un petit contenu de plus dans le grand retour de bâton contre les base de données NoSQL qui a commencé il y a quelques temps. 
Il n'est évidemment pas question de tomber dans l'excès inverse. Chaque solution a un cas d'usage. Mais avec un peu de recul, force est de constater que la frénésie MongoDB il y a quelques années à fait un paquet de dégats. Quand les choix sont dictés par la hype, ça finit en général mal &hellip;

### [Au sujet de l’école 42 et de la publicité dont elle bénéficie](http://binaire.blog.lemonde.fr/2017/11/09/au-sujet-de-lecole-42-et-de-la-publicite-dont-elle-beneficie/)

>Enseigner à une infime minorité sélectionnée est facile. La question difficile est celle de l’enseignement de masse, surtout si celui-ci doit déboucher sur des emplois
><cite>David Monniaux</cite>

Je n'ai rien contre l'école 42. Vraiment. Mais quand la médiocrité journalistique d'un chroniqueur des Échos (Dominique Seux) rencontre la hype marketing du digital, ça donne du grand n'importe quoi. 
Cette mise au point salutaire de David Monniaux remet les choses à leur place: l'enseignement de l'informatique par le service public existe depuis plus de 50 ans en France. La multiplication des écoles privées du domaine répond surtout à une opportunité commerciale de vendre des formations de qualités variables. L'école 42 est, elle, gratuite. Mais d'une part, elle ne forme qu'une ultra minorité — elle ne résoudra pas le manque de compétences à elle seule — et d'autre part, elle doit encore démontrer qu'elle obtient des résultats.

## Les autres liens

- [Declining Complexity in CSS](http://meyerweb.com/eric/thoughts/2017/11/14/declining-complexity-in-css/)
- [HTML & CSS Is Hard (But it doesn’t have to be)](https://internetingishard.com/html-and-css/)
- [Betting on the web](https://joreteg.com/blog/betting-on-the-web)
- [2018's Software Engineering Talent Shortage — It’s quality, not just quantity](https://hackernoon.com/2018s-software-engineering-talent-shortage-its-quality-not-just-quantity-6bdfa366b899)
]]></description><link>https://remihuguet.dev/blog/2017/11/28/les-liens-de-la-veille-9</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/11/28/les-liens-de-la-veille-9</guid><pubDate>Tue, 28 Nov 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Veille de la semaine - N°4]]></title><description><![CDATA[Le récap de ma veille de la semaine - 
Une semaine avec pas mal de liens autour des startups, des liens sur pipenv, le feature flipping, les architectures événementielles. A ne pas rater: [une réflexion sur la professionnalisation des métiers logiciels](https://www.agilealliance.org/agile-and-the-system-of-professions/) et [la foire aux accompagnements pour les startups](https://medium.com/skwid/startup-jungle-la-foire-aux-accompagnements-b78bdf2cb324).

### Dev

#### [pipenv, solution moderne pour remplacer pip et virtualenv](http://sametmax.com/pipenv-solution-moderne-pour-remplacer-pip-et-virtualenv/)

pipenv est un nouvel outil pour gérer plus facilement les environnements virtuels et dépendances, un peu à la façon de npm. Présentation très bien faite par Sam et Max, comme toujours.

#### [Feature branching vs Feature Flipping](http://www.eventuallycoding.com/index.php/feature-branching-vs-feature-flipping/)

Une démarche originale pour cette équipe de dev: remplacer toute la stratégie de branche dans le contrôle de version par des switchs de fonctionnalités. Même si je ne suis pas convaincu, la démarche est intéressante. Comme toujours, tout dépend du contexte.

#### [Event-Driven Architecture](https://herbertograca.com/2017/10/05/event-driven-architecture/)

Un article bien écrit qui reprend de façon assez claire les quelques notions de bases des architectures orientées événements.

#### [The fallacy of DRY](https://dev.to/jeroendedauw/the-fallacy-of-dry)

DRY (pour Don't Repeat Yourself) est probablement le principe de développement le mieux connu. Pour autant, c'est un principe piégeux si on n'y apporte pas quelques clauses complémentaires et, comme toujours, un peu de recul et de mesure dans la pratique. L'auteur expose plutôt bien les limitations et risques du principe — et les dites clauses complèmentaires. Bon, dommage pour le titre clickbait ... 

### Craft

#### [Agile and the System of professions](https://www.agilealliance.org/agile-and-the-system-of-professions/)

Très intéressante exploration par Laurent Bossavit autour du thème de la professionnalisation des métiers du logiciel. C'est une thématique qui revient beaucoup ces derniers temps, notamment avec Robert Martin qui milite assez ouvertement pour une forme de corporation des développeurs.


#### [Your app is an onion: Why software projects spiral out of control](https://medium.com/swlh/your-app-is-an-onion-why-software-projects-spiral-out-of-control-bb9247d9bdbd)

Une variation bien foutue pour expliquer la complexité de la prédiction dans le domain du développement logiciel.

#### [The problem with ‘roadmap first’ teams](https://medium.com/swlh/the-problem-with-roadmap-first-teams-21775e9d4c31)

Evacuons tout de suite le problème: les roadmap c'est bien, il en faut. La thèse de l'auteur est plutôt que la roadmap, en particulier dans des structures qui cherchent encore le bon modèle, la roadmap est un guide, qui évolue et qui ne doit pas faire perdre de vue la véritable priorité:

> In a ‘user first team’, the next thing to work on would actually be determined by this question: ‘What can we do next to make the users most satisfied?’.
><cite>Ariel Verber — The problem with roadmap first teams</cite>

#### [Full-Stack Developers](http://bradfrost.com/blog/post/full-stack-developers/)

Brad Frost nous livre une réflexion non dénuée d'intérêt sur la notion de développeur full-stack. Un sujet qui revient régulièrement, tout comme celui des titres des différents développeurs, et les bisbilles entre "frontenders" et "backenders" (voir par exemple [ce thread sur Twitter](https://twitter.com/ppk/status/918122287940997120)). 

### Startups

#### [Startup jungle: la foire aux accompagnements](https://medium.com/skwid/startup-jungle-la-foire-aux-accompagnements-b78bdf2cb324)

Un retour d'expérience et un point de vue bienvenue sur les startups et surtout les structures d'"accompagnement".
*TL;DR: elles ne servent à rien, pour la plupart.*
Voilà, bonne lecture.

> C’est un véritable symptôme, surtout chez les non-tech, de se dire “oh mon dieu sans la tech j’y arriverai jamais”, ce qui est complètement faux. In fine, le véritable problème de tout business, c’est la vente : vous ne réussirez pas si personne n’achète, point. Et, non, ce n’est pas en écrivant un business plan que vous vendrez mieux 🤔.
><cite>Guillaume Odier, Startup Jungle: la foire aux accompagnements</cite>

#### [Interview en toge - S01- EP02 - Damien MORIN - Save](https://youtu.be/_8MbB4raGg8)

Dans cette interview assez longue, Damien Morin raconte avec beaucoup de détails intéressants l'histoire de Save. 
Si vous ne connaissez pas Save, c'est une entreprise qui répare des téléphones, et qui a beaucoup fait parler depuis deux ans. D'abord pour avoir eu une croissance délirante sur l'année 2015, et une surprésence médiatique de son CEO Damien Morin. Ensuite pour avoir connu une procédure de sauvegarde à l'été 2016. Cela avait donné lieu à un déferlement de critiques et d'articles truffés de bêtises, à la hauteur du buzz absurde autour de Damien Morin quand tout allait bien.

#### [Marcel de Publicis, ou le chant du cygne d’une industrie](https://www.theangle.fr/2017/10/02/marcel-de-publicis-ou-le-chant-du-cygne-dune-industrie/)

Quand Publicis essaye d'aborder sa propre "transformation digitale", ça fait peur &hellip;



]]></description><link>https://remihuguet.dev/blog/2017/10/15/veille-de-la-semaine-n-4</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/10/15/veille-de-la-semaine-n-4</guid><pubDate>Sun, 15 Oct 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 10]]></title><description><![CDATA[ - 
Je deviens fainéant. Mais bon voilà des lectures que je vous recommande, et c'est déjà pas mal.

- [Coders Should Fear What Happened To Writers](https://medium.com/@melissamcewen/coders-should-fear-what-happened-to-writers-d87a895b03db)

- [Remote Programming Jobs: How to Find Them and Why You Should](https://www.daedtech.com/find-remote-programming-jobs/)

- [Unit testing doesn't affect codebases the way you think](https://blog.ndepend.com/unit-testing-affect-codebases/)

- [Freelancing et management : “C’est de notre résilience que dépend notre employabilité future”](https://medium.com/futur-du-travail/freelancing-et-management-cest-de-notre-r%C3%A9silience-que-d%C3%A9pend-notre-employabilit%C3%A9-future-5bee65f6f80d)

- [Keep Your Cap Table Clean](https://salon.thefamily.co/keep-your-cap-table-clean-5e3cb26ea433)
and look at the [video](https://www.youtube.com/watch?v=IMSxYa1dtgE)

- [Learning in a World Where Programming Skills Aren’t That Important](https://www.daedtech.com/programming-skills-arent-important/)

- [Why Developers Become Frustrated And Companies Can’t Find Talent ](https://medium.com/@fagnerbrack/why-developers-become-frustrated-and-companies-cant-find-talent-c4114d8b72ac)

- C'est un peu lien sponso mais bon, l'article est formidable: [Pourquoi ce ou cette développeuse ne veut pas rejoindre votre start up](https://medium.com/@sebastien.carceles/pourquoi-ce-ou-cette-d%C3%A9veloppeuse-ne-veut-pas-rejoindre-votre-start-up-cda736473f65)

  ]]></description><link>https://remihuguet.dev/blog/2017/12/18/les-liens-de-la-veille-10</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/12/18/les-liens-de-la-veille-10</guid><pubDate>Mon, 18 Dec 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 8]]></title><description><![CDATA[Cette semaine, des liens autour du métier de développeur, l'art de la mesure, le web hostile et l'IA. - 
A ne pas rater: [Le temps de chargement est mort !](https://blog.dareboost.com/fr/2017/11/le-temps-de-chargement-est-mort/) et [Against an Increasingly User-Hostile Web](https://www.neustadt.fr/essays/against-a-user-hostile-web/).


### [Pourquoi les jeux-concours pour développeurs m’exaspèrent-ils ?](https://medium.com/arpinum/pourquoi-les-jeux-concours-pour-d%C3%A9veloppeurs-mexasp%C3%A8rent-ils-e85fd87e7463)

Un coup de gueule bienvenu contre les jeux-concours à base d'énigmes de code pour les développeurs. Parmi tous les moyens utilisés pour obtenir de la visibilité et recruter des développeurs, c'est sans doute le pire. 

Comme souligné par Arnaud Lemaire, au-delà de conforter la structuration du marché de l'emploi des développeurs autour d'étiquettes techniques, ces jeux-concours sont taillés sur-mesure pour recruter ceux qui pourraient se révéler le plus toxiques pour l'entreprise.

### [Full Spectrum developer, une étude de cas](https://medium.com/arpinum/full-spectrum-developer-une-%C3%A9tude-de-cas-7efbe2d78130)

J'avoue, je n'ai toujours pas bien compris ce qu'est un "full spectrum developer" après avoir lu l'article. Il s'agit d'un retour d'expérience très utile d'une démarche de conception et de développement orientée métier et création de valeur. C'est d'abord ça le métier de développeur.


### [Le temps de chargement est mort !](https://blog.dareboost.com/fr/2017/11/le-temps-de-chargement-est-mort/)

Les contenus sont nombreux au sujet de l'importance des métriques et de mesurer des choses — pour optimiser un logiciel, un process, un business, &hellip; Beaucoup plus rares sont ceux qui abordent tous les problèmes posés par l'activité de mesure. 

Cet article, dont le sujet est la mesure du temps de chargement des pages web, est absolument brillant de ce point de vue. Les bonnes questions y sont posées et tout les problèmes sont abordés. Superbe.


### [Against an Increasingly User-Hostile Web](https://www.neustadt.fr/essays/against-a-user-hostile-web/)

Une longue réflexion et remise en perspective passionnante sur l'évolution du web, et notamment le problème du respect de la vie privée. En prime, plein de conseils pratiques à la fin.


### [Should we be afraid of AI?](https://aeon.co/amp/essays/true-ai-is-both-logically-possible-and-utterly-implausible)

Un excellent article sur l'intelligence articifielle, qui remet en perspective les positions des deux églises en la matière et nous invite à adopter une attitude plus pragmatique sur le sujet.


### [Frontend Style Guide](https://kaliop.github.io/frontend-style-guide/2.0/)

Un superbe guide de style pour le développement frontend.
]]></description><link>https://remihuguet.dev/blog/2017/11/13/les-liens-de-la-veille-8</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/11/13/les-liens-de-la-veille-8</guid><pubDate>Mon, 13 Nov 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 12]]></title><description><![CDATA[Livraison des liens récents - 
Et hop, voici quelques contenus intéressants des dernières semaines:

- [Pragmatic Releasing: Less Worry, More Shipping](https://blog.algolia.com/pragmatic-releasing/)
- [Defer scripts to speed up rendering](https://blog.dareboost.com/en/2017/12/defer-scripts-to-speed-up-rendering/)
- [Bring clarity to your monolith with Bounded Contexts](https://blog.carbonfive.com/2016/11/01/bring-clarity-to-your-monolith-with-bounded-contexts/)
- [The Death of Microservice Madness in 2018](http://www.dwmkerr.com/the-death-of-microservice-madness-in-2018/)
- [Vue.js : Je suis venu. J’ai Vue. J’ai vaincu.](https://medium.com/nerds-malt/je-suis-venu-jai-vue-j-ai-vaincu-1553ec5ddfe6)
- [A Brief Summary of thoughts on Clean Architecture and MVP](http://wahibhaq.com/blog/clean-architecture-mvp-summary/)

- [You Don’t Find Your Purpose — You Build It](https://hbr.org/2017/10/you-dont-find-your-purpose-you-build-it#)
]]></description><link>https://remihuguet.dev/blog/2018/02/07/les-liens-de-la-veille-12</link><guid isPermaLink="true">https://remihuguet.dev/blog/2018/02/07/les-liens-de-la-veille-12</guid><pubDate>Wed, 07 Feb 2018 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 11]]></title><description><![CDATA[Les premiers liens de l'année. - 
Bon, ce ne sont plus les liens de la semaine mais les liens du mois. Je vais tenter de retrouver un peu de rythme, maintenant la période des fêtes passées. Allez hop, les liens qui vont bien :

- [I Don't Work for a Technology Company](http://blog.howarddierking.com/2017/11/29/i-don-t-work-for-a-technology-company/)

- [Start your open source career](https://blog.algolia.com/start-your-open-source-career/)

- [Why you need domain-driven design (even though you think you don't)](https://techbeacon.com/why-you-need-domain-driven-design)

- [To Serve Man, with Software](https://blog.codinghorror.com/to-serve-man-with-software/)

- [Les critiques des ORM sont à côté de la plaque](http://sametmax.com/les-critiques-des-orm-sont-a-cote-de-la-plaque/)
]]></description><link>https://remihuguet.dev/blog/2018/01/15/les-liens-de-la-veille-11</link><guid isPermaLink="true">https://remihuguet.dev/blog/2018/01/15/les-liens-de-la-veille-11</guid><pubDate>Mon, 15 Jan 2018 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 13]]></title><description><![CDATA[Ma livraison de liens du mois de février - 
A ne pas rater:
- [How Often Should You Ship?](http://thecodist.com/article/how_often_should_you_ship)
- [Technical debt kills your company](https://medium.com/swlh/technical-debt-kills-your-company-bb4ea1cab8cb)
- [Meilleure UX, meilleures performances : la nouvelle donne du web statique](https://blog.dareboost.com/fr/2018/02/site-statique-performance-web/)

D'autres liens qui sont biens quand même:
- [7 Practical Tips for Cheating at Design](https://medium.com/refactoring-ui/7-practical-tips-for-cheating-at-design-40c736799886)
- [Mehdi Medjaoui : “Le design des API conditionne la forme du monde de demain”](https://www.kissmyfrogs.com/mehdi-medjaoui-oauth-api-startup/)
- [JavaScript, I love you, you’re perfect, now change](https://css-tricks.com/javascript-love-youre-perfect-now-change/)

- [Understanding how Design Thinking, Lean and Agile Work Together](https://www.thoughtworks.com/insights/blog/understanding-how-design-thinking-lean-and-agile-work-together)
- [It's perfectly fine to only code at work, don't let anyone tell you otherwise.](https://dev.to/ben/its-perfectly-fine-to-only-code-at-work-dont-let-anyone-tell-you-otherwise--25i3)
- [Why you should stop using product roadmaps and try GIST Planning](https://hackernoon.com/why-i-stopped-using-product-roadmaps-and-switched-to-gist-planning-3b7f54e271d1)
- [Everything easy is hard again](https://frankchimero.com/writing/everything-easy-is-hard-again/)
]]></description><link>https://remihuguet.dev/blog/2018/02/25/les-liens-de-la-veille-13</link><guid isPermaLink="true">https://remihuguet.dev/blog/2018/02/25/les-liens-de-la-veille-13</guid><pubDate>Sun, 25 Feb 2018 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 14]]></title><description><![CDATA[Ma livraison de liens du mois de mars - 
A ne pas rater:
- [Dette technique et entropie du logiciel](https://www.youtube.com/watch?v=VKe9EE4MUxk)
- [You Might Not Need GraphQL](https://blog.runscope.com/posts/you-might-not-need-graphql)
- [A brief tour of Python 3.7 data classes](https://hackernoon.com/a-brief-tour-of-python-3-7-data-classes-22ee5e046517)

D'autres liens qui sont bien:
- [--force considered harmful; understanding git's --force-with-lease](https://developer.atlassian.com/blog/2015/04/force-with-lease/)

- [I am a mediocre developer](https://dev.to/sobolevn/i-am-a-mediocre-developer--30hn)

- [You’re not changing the world](https://m.signalvnoise.com/youre-not-changing-the-world-dc5906819e49)

- [How to Turn Requirements into User Stories](https://www.daedtech.com/how-to-turn-requirements-into-user-stories/)


- [On boredom, attention deficit and the merits of meditation](https://medium.com/@Vitolae/on-boredom-attention-deficit-and-the-merits-of-meditation-d2e929d076be)
]]></description><link>https://remihuguet.dev/blog/2018/04/04/les-liens-de-la-veille-14</link><guid isPermaLink="true">https://remihuguet.dev/blog/2018/04/04/les-liens-de-la-veille-14</guid><pubDate>Wed, 04 Apr 2018 00:00:00 GMT</pubDate></item><item><title><![CDATA[Vous n'êtes pas une startup]]></title><description><![CDATA[Où l'on revient sur la définition d'une startup, et pourquoi tout n'est pas une startup, fort heureusement. - 
Si vous êtes à la tête d'une jeune entreprise en France, plus ou moins dans le domaine techno et / ou innovant, il est fort possible que vous vous donniez le titre de startup.
Malheureusement, les pouvoirs publics, les media, et l'écosystème tech en général poussent à cela. Dans l'ambiance de retour de bâton actuel, j'entends de plus en plus souvent des phrases du type: "Nous ne faisons pas comme les autres startups." Parce que nous ne levons pas des sommes folles. Parce que nous avons une croissance raisonnable. Parce que nous n'avons pas de table de ping pong. Parce que nous avons un comportement éthique.

En fait, si vous ne faites pas comme les autres startup, c'est peut être que vous n'êtes pas une startup. Et c'est très bien ainsi.

La meilleure définition que je connaisse du terme startup reste celle de Steve Blank ([dans cet article](https://steveblank.com/2010/01/25/whats-a-startup-first-principles/)):

>a startup is an organization formed to search for a repeatable and scalable business model.

(_NB: Passez un peu de temps à creuser et à adopter cette grille de lecture. On devient beaucoup plus sain d'esprit, et on comprend beaucoup mieux ce qui se passe une fois qu'on l'a adopté..._)

Cette définition pose le caractère profondément expérimental, faillible et temporaire (_search for..._), et le type d'entreprise que cela produit (_repeatable and scalable_).

C'est un type extrêmement précis, et réduit, d'entreprise.

Toutes les nouvelles entreprises innovantes ne sont pas dans un processus de découverte d'un modèle de création de valeur.
Toutes les jeunes entreprises n'ont pas pour vocation de se dupliquer à l'international, ou d'atteindre la scalabilité, ou les deux.
Toutes les entreprises qui cherchent de nouveaux modèles de création de valeur ne vont pas forcément être répétables. Ou scalables. Il est parfaitement légitime de vouloir développer une entreprise qui reste à dimension humaine, ou locale, ou ce que vous voulez.
Ce n'est pas parce que vous levez des fonds que vous êtes une startup. Et inversement.


Heureusement que toutes les jeunes entreprises ne sont pas des startups. Ce serait invivable.
Et heureusement qu'il existe des startups, avec des ambitions débordantes, des réussites étonnantes et des échecs retentissants.

Le monde est vaste, et il faut de tout.

Et vous n'avez sans doute pas besoin de croire que vous êtes une startup si vous ne l'êtes pas.
]]></description><link>https://remihuguet.dev/blog/2019/10/18/vous-n-etes-pas-une-startup</link><guid isPermaLink="true">https://remihuguet.dev/blog/2019/10/18/vous-n-etes-pas-une-startup</guid><pubDate>Fri, 18 Oct 2019 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens - Complexité logicielle & expérience]]></title><description><![CDATA[Les liens intéressants de ma semaine - 
Je reprends la publication des liens intéressants vus dans ma veille cette semaine.

 ## [Why you should document your tests](https://hynek.me/articles/document-your-tests/)

> If you don’t explain what you’re actually testing, you force the reader (possibly future you) to deduce the main intent by looking at all of its properties.

Hyneck explique dans cet article pourquoi il a mis en place une politique visant à commenter 100% des tests dans les projets open-source dont il s'occupe. Même si l'idée me paraît un peu extrême, il a de bons arguments.

## [Python Developer Survey 2019 results](https://www.jetbrains.com/lp/python-developers-survey-2019/)

Les résultats de l'étude 2019 de la Python Software Foundation sont arrivés. Si on agrége data science et machine learning dans une même catégorie (spoiler: on peut), c'est aujourd'hui le principal cas d'usage des utilisateurs de Python (31%), devant le développement web (28%). Mais ce qui m'interpelle le plus dans cet étude, et cela est lié à l'incroyable essor de la data science ces dernières années, c'est le niveau d'expérience des répondants: 69% (!) ont moins de 5 ans d'expérience en tant que développeur professionnel. A méditer.


## [Savoir faire des choses compliquées ne fait pas de vous un bon développeur](https://www.lilobase.me/savoir-faire-des-choses-compliquees-ne-fait-pas-de-vous-un-bon-developpeur/)

>[...]j’ai pu observer, dans certaines communautés et entreprises, une certaine propension à glorifier des solutions particulièrement compliquées [...] Malheureusement, ce que ces gens prouvent, c’est qu’ils sont capables de travailler dans un contexte de très forte charge cognitive.

[Arnaud Lemaire](lilobase.me) écrit une série d'articles sur la complexité logicielle, que je vous conseille de suivre. L'obsession d'une partie de notre industrie pour la complexité, pour ne pas dire son fétichisme, est un problème que l'on doit affronter. Oui, certains profils de "brilliant jerk", et la fascination qu'ils peuvent exercer, constituent un énorme problème.
]]></description><link>https://remihuguet.dev/blog/2020/05/17/les-liens-complexite-logicielle-and-experience</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/05/17/les-liens-complexite-logicielle-and-experience</guid><pubDate>Sun, 17 May 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Pareto et qualité logicielle]]></title><description><![CDATA[Où il est question de ce que coûte la qualité logicielle. - 
Que coûte de fabriquer du logiciel de bonne qualité?

La plupart des pratiques qui permettent de passer de 0 à 1 sur la qualité logicielle sont avant tout des habitudes à construire. Les pratiques telles que le code propre, le développement dirigé par les tests, la création d'architecture propre ne présentent pas un degré de technicité très élevé. Les intégrer nécessitent de déconstruire de mauvaises habitudes (pour les plus vieux d'entre nous), et beaucoup de pratique.

Une fois ces pratiques intégrées en habitude, le coût marginal pour produire un logiciel de qualité correcte par rapport à son équivalent tout juste fonctionnel est nul. Comme son coût de maintenance est infiniment moindre, l'investissement sur l'équipe éventuellement nécessaire pour atteindre ce niveau de qualité en vaut sans doute la peine.

Il y a là une forme de principe de Pareto: 80% du chemin est parcouru pour un effort minime, voire nul. Le reste par contre c'est une autre histoire.
]]></description><link>https://remihuguet.dev/blog/2020/05/15/pareto-et-qualite-logicielle</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/05/15/pareto-et-qualite-logicielle</guid><pubDate>Fri, 15 May 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[La force des habitudes]]></title><description><![CDATA[Où il est question des habitudes de développeur. - 
La force d'une habitude, c'est que l'on continue à l'avoir en situation de stress. C'est le propre d'une habitude: rendre un comportement tellement automatique qu'il perdure même lorsque le contexte change - dans une certaine mesure.

En particulier, les habitudes des développeurs et équipes sont tout ce qu'il reste quand les contraintes sont plus importantes. Quand il faut sortir le produit, livrer la mise à jour, résoudre ce bug urgent qui met la production en carafe, accélérer un peu la cadence pour tenir la deadline du marketing.

Les pratiques de développement les plus puissantes pour produire du logiciel de qualité sont avant tout des habitudes. Elles ont besoin d'un apprentissage initial minime, et nécessitent une pratique systématique, consciente et répétée sur le long terme. Le développement conduit par les tests est l'exemple typique de pratique qui produit de la valeur parce que c'est avant tout une habitude à acquérir. Cela rend les bonnes pratiques résilientes au changement de contexte - mais c'est aussi plus difficile à construire.

Le habitudes peuvent aussi devenir mauvaises - et l'on sait à quel point il est difficile de s'en débarasser. Pour un développeur, beaucoup de non qualités sont le produit de nos mauvaises habitudes. Nos bonnes habitudes d'hier peuvent devenir les mauvaises habitudes d'aujourd'hui. Ce qui ne nous aide pas. Il semble en plus que la plupart d'entre nous ayons surtout des mauvaises habitudes lorsque nous débutons, mais c'est un autre sujet.

En tant que développeurs, nous devons affronter cette tension permanente: construire des habitudes parce que c'est qui permet d'être efficace et de produire du logiciel de qualité, et déconstruire nos mauvaises habitudes, qui nous retardent. Nous devons aussi rester sains d'esprit - il y a une raison pour lesquelles nous aimons les habitudes. Elles sont bonnes pour notre équilibre.


Avoir l'espace et la possibilité d'expérimenter, de construire et de déconstruire régulièrement les habitudes au sein d'une équipe est important - peut être plus que de faire une formation de trois jours deux fois par an.

Investir sur sa capacité à changer d'habitude rapidement pourrait donc être intéressant. Comme toute pratique, plus on change souvent d'habitude, plus le processus est rapide et moins il est dangereux pour notre équilibre émotionnel.
]]></description><link>https://remihuguet.dev/blog/2020/05/17/la-force-des-habitudes</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/05/17/la-force-des-habitudes</guid><pubDate>Sun, 17 May 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Au revoir eshard, bonjour indépendant!]]></title><description><![CDATA[Où j'annonce mon départ d'eshard et la reprise de ma vie d'indépendant. - 
Je quitte [eshard](https://www.eshard.com) ce 31 janvier, après presque exactement deux ans. 

Lorsque j'ai rejoint eshard début 2018, j'étais indépendant depuis quelques mois. J'ai accepté de rejoindre l'équipe d'eshard, et j'ai mis en sommeil mes activités naissantes d'indépendant, stimulé par un contexte métier que je ne connaissais pas, et une stratégie produit intéressante.

J'étais lead developper pour le produit esdynamic. C'est une plate-forme pour les experts en sécurité qui propose de nombreux outils et contenus autour, notamment, des attaques cryptographiques par canaux auxiliaires. L'équipe qui fait vivre ce produit est très pluridisciplinaire, composée d'experts en crypto et en sécurité, de développeurs Python, et frontend web. Faire vivre un projet aussi riche, avec de nombreuses contributions et profils différents, a été un gros challenge. J'ai découvert en partie l'ecosystème de data science, et contribué à une librairie open-source, [scared](https://gitlab.com/eshard/scared).

J'ai cotoyé une équipe formidable, que je remercie de m'avoir supporté pendant 2 ans.

Mes aspirations personnelles me conduisent à quitter eshard pour reprendre une activité d'indépendant. Avec mon expérience et mes attentes actuelles, je pense que c'est le meilleur positionnement pour moi. Je cherche à accompagner des équipes qui ont besoin de structurer leurs pratiques d'ingénieries et faire grandir leur produit, autour de projets qui me parlent.

Dès lundi, je vais travailler avec une boîte géniale qui s'appelle [Opquast](https://www.opquast.com/), pour quelques mois.

---

PS: mes collègues si gentils m'ont offert ce magnifique visuel. Merci à tous 🥰🚀
![Photomontage de Rémi décollant de la planète eshard](../../static/eshard-depart.jpg)
]]></description><link>https://remihuguet.dev/blog/2020/01/31/au-revoir-eshard-bonjour-independant</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/01/31/au-revoir-eshard-bonjour-independant</guid><pubDate>Fri, 31 Jan 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens - Modern web et architecture]]></title><description><![CDATA[Les liens intéressants de ma semaine - 
## [Second-guessing the modern web](https://macwright.org/2020/05/10/spa-fatigue.html)

>If you go this way, you’re beset by the cognitive dissonance of following in the footsteps of enormous projects [...] but being far outside the norms of modern web development. If Wikipedia were started today, it’d be React. Maybe?
>What if everyone’s wrong? We’ve been wrong before.

Tiens, le temps du backslash pour les SPA (single page applications) semble arrivé. Parmi d'autres, une des contributions récentes sur le sujet. Tom MacWright fait le constat que la stack moderne - Single Page Application, React et API - pose énormément de problèmes quand on l'utilise pour tout et n'importe quoi sans discernement.

C'est une bonne chose d'en prendre conscience. Dommage l'on doive passer par un cycle de hype supplémentaire pour se souvenir, encore une fois, qu'il n'y a pas de balle en argent en ingéniérie logicielle. Les solutions techniques résilientes ne se batissent pas à coup de hype, mais avec du pragmatisme.

## [The properties of great architecture](http://www.ouarzy.com/2020/05/17/the-properties-of-great-architecture/)

>Then defining good software with practices or tool is definitely a failure. [...]
>It won’t be great just because you’re OOP code base is SOLID. 
>It will be great only if both people building it and people using it are happy. Only if they feel whole when they use or build it.

[Ouarzy](http://www.ouarzy.com/) se pose la question de ce qui fait qu'un logiciel semble bon ou pas, notamment à l'aide d'un parallèle avec l'architecture de bâtiment. Le parallèle est intéressant, et on arrive rapidement à la conclusion qu'un logiciel, comme un bâtiment, ne peut être jugé qu'en tant que système complexe, intégré à son environnement.

]]></description><link>https://remihuguet.dev/blog/2020/05/25/les-liens-modern-web-et-architecture</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/05/25/les-liens-modern-web-et-architecture</guid><pubDate>Mon, 25 May 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Des hauts et des bas]]></title><description><![CDATA[Où il est question de niveaux d'énergie et de performance - 
J'ai eu une semaine compliquée. Pas beaucoup d'énergie, un peu de mal à rester concentrer, j'avance moins vite, je perds parfois le fil, je fais des petites erreurs. Cette impression diffuse que rien n'avance tout à fait comme ça le devrait.

Nous ne pouvons pas être en permanence en pleine possession de nos moyens. Pourtant, en tant que professionnels, nous nous comportons parfois comme si c'était le cas. Construire un flux de travail formalisé et structuré, mettre en place des bonnes pratiques de développement, pratiquer le développement dirigé par les tests, avoir l'habitude d'écrire de la documentation: ces pratiques sont un filet de sécurité.

Quand ça va moins bien, pouvoir se raccrocher à des fondamentaux permet de sauver les meubles et d'assurer l'essentiel.  Pas besoin d'être un héros pour assurer.

Si en plus les systèmes mis en place permettent de tirer parti des pics de forme, c'est encore mieux.
]]></description><link>https://remihuguet.dev/blog/2020/05/24/des-hauts-et-des-bas</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/05/24/des-hauts-et-des-bas</guid><pubDate>Sun, 24 May 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Parlez moi de vos problèmes]]></title><description><![CDATA[Où il est question de construire des solutions et de bien comprendre le problème. - 
La mission de l'ingénieur logiciel c'est de construire la solution la plus appropriée pour un problème donné. C'est déjà un travail difficile que de bien comprendre le problème, et de construire une solution qui soit bien alignée avec.

Nous avons tendance à nous mettre des bâtons dans les roues tout seul au passage: en nous projetant trop tôt du côté des solutions, en nous mettant des contraintes arbitraires par des choix techniques prématurés ou dictés par la mode du moment ( _microservices on vous voit!_)

C'est encore plus difficile quand le "client" nous projette lui même trop vite du côté des solutions. C'est humain: quand nous avons un problème, nous avons tendance à réclamer une solution particulière, plutôt qu'à simplement exposer notre problème. 

Peut-être la principale raison est-elle que ce n'est pas facile d'exposer simplement, et avec le moins d'éléments parasites possibles, le problème à résoudre. C'est même très difficile, notamment parce qu'il est plus simple d'imaginer des solutions et d'utiliser ce que l'on a déjà de concret - le produit existant.

Le problème pour le développeur (_navré_), c'est que si nous ne faisons pas l'effort d'aller chercher la compréhension du problème avec le "client", nous allons construire quelque chose qui ressemble à la solution imaginée. Nous partons d'emblée avec des contraintes inutiles, et une compréhension du problème polluée par des pré-supposés de solution.

Ce n'est pas très satisfaisant, et la probabilité que cela réponde au véritable problème qu'il fallait résoudre est mince.

La mission de l'ingénieur logiciel c'est donc en premier lieu de bien comprendre le problème du "client", avec lui - quitte parfois à bousculer un peu, gentimment. C'est aussi de refuser de se comporter en exécutant, quand c'est dans l'intérêt du produit, de l'organisation ou des utilisateurs. Ce n'est pas facile. Mais c'est notre responsabilité.

La mission du "client", c'est de parler de ses problèmes - et essayer de ne pas trop plaquer ces solutions dessus.
]]></description><link>https://remihuguet.dev/blog/2020/06/04/parlez-moi-de-vos-problemes</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/06/04/parlez-moi-de-vos-problemes</guid><pubDate>Thu, 04 Jun 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Chérissez votre legacy]]></title><description><![CDATA[Où il est question de ce truc affreux: le legacy software. - 
Le legacy est un concept commun dans l'ingéniérie logicielle. Il est connoté très négativement. Cet héritage est lourd à porter. Il est n'est pas maintenable, conçu et codé en dépit du bon sens. La moindre modification est difficile à mener. 

Le legacy, c'est donc ce vieux logiciel dont personne ne veut plus s'occuper. Les développeurs préfèrent les "greenfields", partir d'une page blanche et construire de zéro. Et promis, cette fois on fera mieux, pas de legacy en vue!

Michael Feathers dans _Working effectively with legacy code_ définit le legacy code comme le code sans tests. C'est une définition qui a l'avantage d'être simple. Elle coupe le monde en deux. Pourtant, je lui trouve deux défauts.

- Elle comporte beaucoup d'hypothèses implicites. Les tests sont automatisés. Ils servent à quelque chose. Ils sont faciles à comprendre et à maintenir. Une codebase bourrée de tests fragiles et incompréhensibles vaut-elle vraiment mieux que son équivalent sans tests automatisés ?
- Elle parle du code - pas du logiciel. Est-ce équivalent? Si l'on hérite d'un code, c'est sans doute parce qu'on hérite du logiciel qui va avec. Hors un logiciel a des utilisateurs.

La caractéristique première d'un logiciel hérité (_legacy software_), c'est qu'il est utilisé et qu'il crée de la valeur. C'est la raison même pour laquelle nous devons intervenir dessus. C'est bien un héritage - un patrimoine. 

Cette seule caractéristique rend le changement difficile. Quelque soit la qualité du code, de l'architecture, l'alignement avec le métier, avoir des utilisateurs qui comptent sur le produit est une énorme source de complexité pour le changement. Au fond, si les développeurs préfèrent les projets page blanche, c'est peut-être parce qu'ils n'ont pas d'utilisateurs réels. Ils peuvent être l'objet de tous les fantasmes et spéculations. 

Dès qu'il a des utilisateurs, ce nouveau projet chéri, qui devait être parfait, devient instantanément un affreux héritage sur lequel toute opération devient beaucoup plus complexe. Convaincre un utilisateur de changer son utilisation du logiciel, quand bien même ce serait pour son bien, est beaucoup plus difficile que de remanier un code pourri.

Pourtant, ces projets ont de l'intérêt. Nous créons des logiciels pour les gens, pour qu'ils soient utilisés. Ils nous permettent de gagner notre vie. Nous devrions leur prêter plus d'attention.

Voici ma définition du legacy software - et du code qui va avec. Le legacy software, c'est un logiciel qui est utilisé. Nous devrions en prendre soin.
]]></description><link>https://remihuguet.dev/blog/2020/06/23/cherissez-votre-legacy</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/06/23/cherissez-votre-legacy</guid><pubDate>Tue, 23 Jun 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens de la veille - 7]]></title><description><![CDATA[Cette semaine, perfs, perfs, mais pas que. - 
A ne pas rater: [optimisation des images](https://blog.dareboost.com/fr/2017/10/optimiser-les-images-et-reduire-leur-poids-formats-outils-et-rwd/) et [un article salutaire sur l'agilité](https://medium.com/@JoshuaKerievsky/id-like-you-to-know-the-definition-of-agile-639d3fd29d54).


### [Optimiser les images et réduire leur poids : formats, outils et RWD](https://blog.dareboost.com/fr/2017/10/optimiser-les-images-et-reduire-leur-poids-formats-outils-et-rwd/)

Si vous avez jamais essayé d'optimiser le poids de vos pages web, vous vous être forcément frottés à l'optimisation des images. Les images représentent bien souvent le plus gros volume de données téléchargé sur une page. 
Cet article fait un point très clair et utile sur le sujet. Notions à connaître, outils d'optimisation, gestion des images dans un contexte responsive, tout y est. Une super ressource 👍

### [The State of the Web](https://medium.com/@fox/talk-the-state-of-the-web-3e12f8e413b3)

Toujours dans le thème de la performance, ce copieux article dresse un panorama rapide des différents axes d'optimisation des pages web: utilisation des options `preload`, optimisation des images, des webfonts, javascript, &hellip;

### [Developers, swallow your pride and just do stuff](https://dev.to/lukaszsagol/developers-swallow-your-pride-and-just-do-stuff)

J'aime beaucoup ce type d'article pour nous rappeller que notre fonction en tant que développeur est avant tout de produire du logiciel qui génère de la valeur. Parfois, dans certains contextes, cela peut impliquer de prendre du recul sur les bonnes pratiques et de juste mettre en oeuvre ce qui ressemble à un bricolage crade. 

Attention cependant — comme toujours, tout est dans l'équilibre. Les bonnes pratiques, les méthodes qui visent à améliorer la qualité et la maintenabilité des logiciels sont indispensables. Mais le contexte est roi, et nous devons être capable de prendre le recul nécessaire pour savoir quand utiliser les règles, quand les adapter, quand les contourner, quand les ignorer, &hellip; pour atteindre un objectif.


### [Consequences of overvaluing technology](https://dev.to/davidk01/consequences-of-overvaluing-technology-7fp)

Un très court texte au sujet de la fascination que peut excercer la technologie pour elle même. 

>In fact, all things being equal the technology, no matter how good, is more than likely trivial in the grand scheme of things. It is the problems that the technology solves that really matters at the end of the day and no one cares how elegant or inelegant it is.
><cite>David Karapetyan</cite>

### [React explained to a Vue.js developer](https://medium.com/@pierrericgarcia/react-explained-to-a-vue-js-developer-73afa7e8fb6f)

Un petit article technique sympathique dans lequel l'auteur expose les similarités et différences d'implémentation de différents comportements entre deux des frameworks d'interface à la mode, React et Vue.js.


### En vrac

Les autres liens de la semaine, en vrac:

- A ne pas rater: [I’d Like You To Know the Definition of Agile…](https://medium.com/@JoshuaKerievsky/id-like-you-to-know-the-definition-of-agile-639d3fd29d54)
- [Developers are the Most Underrated Designers](https://hackernoon.com/developers-are-the-most-underrated-designers-5855a7e4aa2c)
- [Don’t Build a Startup, Build a Movement](https://medium.com/swlh/dont-build-a-startup-build-a-movement-15c31213168)
]]></description><link>https://remihuguet.dev/blog/2017/11/03/les-liens-de-la-veille-7</link><guid isPermaLink="true">https://remihuguet.dev/blog/2017/11/03/les-liens-de-la-veille-7</guid><pubDate>Fri, 03 Nov 2017 00:00:00 GMT</pubDate></item><item><title><![CDATA[Choix et compromis]]></title><description><![CDATA[Où il est question d'abstraction, d'avoir conscience des choix que l'on fait et des compromis qu'ils impliquent. - 
Se placer à un niveau d'abstraction logicielle donnée, c'est faire plus ou moins de choix pour atteindre un objectif.

Si je me place bas niveau, je devrai faire beaucoup de choix pour arriver à mon objectif. Il y a de bonnes chances que la solution construite corresponde parfaitement à mon besoin. En contrepartie, je dois passer plus de temps, de réflexion et de charge mentale. C'est épuisant de faire des choix!

Si je cherche à adresser un besoin classique, je vais m'appuyer sur une librairie ou un framework qui a fait tout les choix les plus adéquats pour ce problème. Je peux alors me concentrer sur mon objectif, et utiliser mon temps pour faire les choix qui comptent vraiment pour moi. En contrepartie, je dois composer avec tous les choix que je n'ai pas fait moi même. Encore dois-je en avoir conscience.

En tant qu'ingénieur logiciel, nous passons notre temps à faire des choix.  C'est au coeur de notre métier. Plus nous avons de choix à faire pour régler un problème, plus cela prend du temps. Moins nous faisons de choix, plus nous irons vite. Mais nous ferons des compromis.

Bien avoir conscience des choix que l'on doit faire, de ceux que l'on délégue à d'autres, et des compromis que cela implique, cela fait partie du job lorsqu'on crée un logiciel.

---
_Note: Je propose comme méthode d'estimation de compter les choix qu'il y aura à faire dans un projet. En première approximation, ça ne peut pas être pire que les autres façons d'estimer..._
]]></description><link>https://remihuguet.dev/blog/2020/06/25/choix-et-compromis</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/06/25/choix-et-compromis</guid><pubDate>Thu, 25 Jun 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Links - Python and more]]></title><description><![CDATA[Links from my feeds - Python and more - 
Ok, this week I go full english - since most of the links I share are ... in english.


## [Hash.ai](https://hash.ai/)

Create and work with agent-based models, right in your browser. Also I don't drink all the weird stuff in the mission statement, the tool is really promising. Even if you don't have any clue about agent modelling (I don't), this is a really intriguing and fun platform to test.

## [Typed functional dependency injection in python](https://sobolevn.me/2020/02/typed-functional-dependency-injection)

Dependency injection is a base technique for successfully decoupling architectures. The functional programming style is a source of inspiration and elegant pattern to improve the code. Static typing makes the business code more robust and expressive.

This article brilliantly presents how to use functional typed dependency injection , as part of a web application using Django.

## [Never use the word “User” in your code](https://codewithoutrules.com/2018/09/21/users-considered-harmful/)

Naming is a crucial design element for software - and particularly difficult. Language alignment is central in Domain Drive Design in particular. A case study, which we have all come across at one time or another, is well exposed here. There is no "User" in your software!

## [Async python is not faster](http://calpaterson.com/async-python-is-not-faster.html)

A benchmark and a first analysis with various Python web-servers, asynchronous and synchronous.It shows that synchronous configurations are more efficient, contrary to an a priori belief that one can have. Food for thought.

## [Introduction to strategic DDD](https://www.lilobase.me/le-domain-driven-design-sous-langle-strategique-une-introduction/)

__This one is in french__


This video is a great introduction by Arnaud Lemaire to strategic patterns in Domain Driven Design. The strategic side of DDD is, to me, the most interesting part of DDD, because it is always useful, for any project.
]]></description><link>https://remihuguet.dev/blog/2020/06/22/links-python-and-more</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/06/22/links-python-and-more</guid><pubDate>Mon, 22 Jun 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[L'analyse stratégique au secours du legacy]]></title><description><![CDATA[Où il est question de l'utilité de l'analyse stratégique DDD pour améliorer un logiciel legacy. - 
L'utilisation des concepts stratégiques du Domain Driven Design est très puissante pour aborder sereinement la mise sous contrôle d'un logiciel legacy devenu incontrolable. Construire une cartographie sommaire des domaines et sous-domaines, de leur relations et des contextes existants apporte beaucoup d'information.

Pour le legacy typique, il est probable que la carte obtenue soit un beau bazar, avec des chevauchements de contextes et domaines, et un écheveau inextricable de relations.

C'est le premier intérêt de l'approche. Instantanément, faire l'effort d'identifier les domaines, leur importance stratégique, leurs relations, les différents contextes pas vraiment délimités, au sein d'une représentation visuelle simple permet de comprendre pourquoi travailler sur l'existant est devenu si difficile.

Quand on est confronté au quotidien à un logiciel qui résiste au changement, il n'est pas toujours évident de comprendre pourquoi. On peut blâmer les choix techniques. On peut identifier la mauvaise application des bonnes pratiques de code, les outils, ou encore le manque d'expérience de l'équipe. Tout cela peut être vrai, à un niveau micro. A un niveau macro, la raison principale c'est l'absence de conception, la non connaissance des domaines et contextes que l'on manipule qui en découle, et, finalement, le désalignement entre le métier et la solution.

Pouvoir visualiser très concrétement pourquoi ce que l'on manipule est si résistant, c'est un soulagement. Une première étape nécessaire pour améliorer les choses. C'est rassurant.

L'exercice permet de se doter d'outils pour avancer. La classification des domaines, la visualisation des relations entre eux et de l'existant donnent des éléments pour identifier et prioriser les zones les plus critiques sur lesquelles travailler. Cela permet d'obtenir des informations que l'on aurait pas autrement.

Finalement, dessiner une carte idéale de ce que devrait être la solution est aussi libérateur. Cela donne une perspective positive. Cela trace le chemin pour avancer. Au moins maintenant, on a peut être pas réparer le logiciel, mais au moins, on ressent pourquoi il est tel qu'il est, on sait quel objectif viser pour faire mieux, et on sait quels sujets doivent être gérés en premier.

Cela vaut le coup de passer quelques heures de réflexion non ?
]]></description><link>https://remihuguet.dev/blog/2020/07/09/l-analyse-strategique-au-secours-du-legacy</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/07/09/l-analyse-strategique-au-secours-du-legacy</guid><pubDate>Thu, 09 Jul 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens - DDD, thinking, async et covid]]></title><description><![CDATA[Les liens intéressants de ma semaine - DDD, thinking, async et covid - 
Beaucoup de ressources - plutôt que de véritables articles - cette semaine.

## [Message à caractère informatique](https://www.youtube.com/playlist?list=PLvjEkX1131rBpr7T8t6Zwdhe5RlpsT3Ci)

Chaque semaine, une heure de discussions autour de la veille technique des gens de chez Clever Cloud, détendu et sans langue de bois. A suivre !

## [Des ressources DDD pour démarrer](https://github.com/ddd-crew/ddd-starter-modelling-process)

Plein de ressources utiles pour commencer à utiliser Domain Driven Design.

## [Tools for better thinking](https://untools.co/)

Une collection d'outils simples pour mieux penser. J'adore.

## [How async should have been](https://sobolevn.me/2020/06/how-async-should-have-been)

Un article hyper intéressant et très bien écrit sur le design de code asynchrone en Python. L'auteur est par ailleurs derrière quelques librairie Python hyper prometteuses: [returns](https://github.com/dry-python/returns) et [classes](https://github.com/dry-python/classes).

## [Don't guive into the guilt](https://salon.thefamily.co/dont-give-in-to-the-guilt-2e2dc709c7d)

>If you needed COVID-19 to figure out that the people working to stock supermarket shelves had a hard job, that nurses were completely overworked, what were you looking at? COVID-19 didn’t start all of this, it just made it impossible to ignore.

Bon ok il ne s'agit pas vraiment de software. Mais je dois avouer que j'ai une faiblesse pour les gens de chez The Family, et Oussama Ammar a un point de vue intéressant dans cet article - et comme souvent, une punchline bien sentie.
]]></description><link>https://remihuguet.dev/blog/2020/06/16/les-liens-ddd-thinking-async-et-covid</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/06/16/les-liens-ddd-thinking-async-et-covid</guid><pubDate>Tue, 16 Jun 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[2020 summer's links]]></title><description><![CDATA[Links from my readings of the summer: software, product, startups and the internet. - 
I had quite a long interruption this summer. Here is a long list of the best reads I had during that time.
It's about software craft, product craft, internet and startups.

## [Model, system, code](https://seddonym.me/2020/05/08/model-system-code/)

>There is an approach to design that many, if not most, developers adopt unthinkingly. Let’s call it Code Driven Design. It’s the process we’re likely to follow automatically; the path of least resistance.

Nice article by David Seddon about his personnal software design process. In my experience, a good part of software developpers' issues originates in a lack of a clear and structured methodology.

So here is one to inspire you.


## [The alternative to roadmaps](https://svpg.com/the-alternative-to-roadmaps/)

I've discovered the Silicon Valley Product Group blog pretty recently, and I became some sort of fan boy instantly. This piece is already five years old and is inspiring. In a nutshell, the alternative is:

1. Empowered, autonomous teams with some form of OKR
2. High integrity commitments (https://svpg.com/managing-commitments-in-an-agile-team/)

## [Property-based testing and hypothesis in python](https://www.hillelwayne.com/post/property-testing-complex-inputs/)

Property-based testing is some complicated word for a simple idea: some part of your software presents properties that can always be verified. 
In Python, hypothesis is a library to achieve easily that type of tests. The funny part is, I had already used hypothesis and made some property-based testing without realising it, up until I read this article! It was kind of a "ahah" moment, since I finally understood why hypothesis is clearly not suitable for all tests in Python.

## [The most famous loop](https://danco.substack.com/p/the-most-famous-loop)

Alex Danco's newletter _Two truths and a take_ is great. This one is very interesting. He elaborates an analogy between thermodynamic's Carnot cycle loop and business loops, with one powerful idea: _expansion and contraction of disorder is an essential part of efficient loops._

A must read!

## [UI as an afterthought](https://michel.codes/blogs/ui-as-an-afterthought)

This post explains how one should model and design front-end software, starting from state and processes, rather than from UI. Stated differently, Domain Driven Design apply to front-end development too ;)

## [Fast design will kill your product](https://philip.design/blog/fast-design-will-kill-your-product/)

As a software engineer, and sometimes team lead, I often feel odd when stakeholder (CEO most of the time) ask me to put some small changes on top of our backlog. Most of the time, justification is: "it's a quick win". And yes, sometimes these are real wins, quick to implement - but not all.

The problem is, how can you keep a consistent product design when you are taking a lot of fast design decisions ?

This post is a concise explanation of why you should be very careful when doing fast design. I'd add that you should be careful with quick wins - sometimes it is not really quick, and sometimes it's not even a win...

## [#NOESTIMATES - La fin des estimations ?](https://www.youtube.com/watch?v=fZXV9YeAFnY&feature=emb_logo) (in french)

A great video by Frédéric Leguedois about estimates in software development. Full of interesting considerations - and a lot of punchlines!


## [India, Jio, and the Four Internets](https://stratechery.com/2020/india-jio-and-the-four-internets/)

>On one hand, large U.S. tech companies are winners, at least relative to everyone else: yes, all of the regulatory red tape increases costs (and, for targeted advertising, may reduce revenue), but the impact is far greater on would-be competitors. To put it in allegorical terms, the E.U. is restricting the size of the castle even as it dramatically increases the moat.

In this Stratechery issue about TikTok, Ben Thompson describes the different Internet models, from US to China and European one. Obviously, his opinion on EU model strikes me: yes, we are gaining more and more protection for citizens. But it comes at a cost, that is not recognised explicitly most of the time: these regulations are barrier for new incumbents. The same regulations that are protecting us citizens are also preventing us to grow our own Internet giants, and thus let us completely dependent of US techs.

Maybe the most effective way to fight against GAFAM in EU would be to have our own GAFAMs. 
]]></description><link>https://remihuguet.dev/blog/2020/09/17/2020-summer-s-links</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/09/17/2020-summer-s-links</guid><pubDate>Thu, 17 Sep 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Un bilan de 2020]]></title><description><![CDATA[Où l'on fait le bilan de cette année écoulée et esquisse l'année qui vient - 

## Alors, freelance ?

Fin janvier 2020, [j'ai quitté le poste que j'occupai](/blog/2020/01/31/au-revoir-eshard-bonjour-independant) chez eShard pour exercer en indépendant.

Mon premier client est [Opquast](https://www.opquast.com), dès début février.
D'abord pour 6 mois, nous avons prolongé de 6 mois supplémentaires la mission.
Opquast c'est une équipe géniale, avec un projet vraiment important pour le web.


Durant cette mission avec eux, j'ai essayé d'aider l'équipe à assainir le legacy, faire évoluer leur architecture, et sensibilisé au flux, à l'intégration continue, au TDD, au DDD, à la clean architecture et au clean code.
Une mission hyper satisfaisante et je crois appréciée par le client 😜 (témoignages [sur l'accueil](/)).


Cette année m'a permis de mieux comprendre comment me positionner et structurer mon offre.
J'ai aussi beaucoup progressé sur les pratiques craft - notamment l'utilisation du DDD stratégique pour améliorer un legacy.


Je travaille à distance à temps plein (et ce n'est pas dû à la covid).
J'avais déjà pas mal travaillé à distance, mais pas sur un temps plein.
Cela m'a permis d'apprendre à mieux me connaître et à grandir sur le plan humain.


Je termine avec Opquast à la fin du mois de janvier.
Je continuerai à les accompagner sur un mode de conseil plus ponctuel.

## Année 2

Mon objectif pour 2021 est de diversifier ma clientèle - tout en gardant en tête que le type d'offre que je propose ne me permets pas non plus d'avoir 36 clients dans l'année.
Je veux aussi augmenter un peu mon CA et mon TJM effectif.


Mon autre objectif pour 2021 sera d'investir (enfin) régulièrement dans la production de contenus.
Le mentoring, le compagnonnage ou la formation notamment sont des activités que j'ai envie de développer. 
C'est une façon de travailler à la fois mes compétences et de satisfaire un besoin.


Mais le principal c'est continuer de m'éclater et de m'épanouir dans ma carrière d'indépendant.


## 2020, annus horribilis ?

Je ne peux pas évacuer complètement le sujet.
2020 est plutôt une bonne année, vue de ma petite fenêtre.

Pourtant, il y a de quoi trouver que c'est une année affreuse.
Pandémie mondiale amenant un collapse économique, défiance dans l'action publique, violences de tous ordres, catastrophes climatiques.
Qui pourrait considérer que 2020 fût autre chose qu'une _annus horribilis_?

J'adresse toutes mes pensées et mon réconfort (c'est peu de choses) à tout ceux qui ont perdu un proche dans la pandémie, tout ceux fragilisés par ses conséquences économiques, toutes les victimes de terrorisme et de violence, les naufragés climatiques et tous ceux que j'oublie qui ont souffert cette année.

Le meilleur reste à venir.
]]></description><link>https://remihuguet.dev/blog/2020/12/29/un-bilan-de-2020</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/12/29/un-bilan-de-2020</guid><pubDate>Tue, 29 Dec 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les liens - Identité, produit et hype]]></title><description><![CDATA[Les liens intéressants de ma semaine - Identité, produit et hype - 
Et hop quelques liens pour cette semaine!

## [Keep your identity small](http://www.paulgraham.com/identity.html)

>[...] there is a step beyond thinking of yourself as x but tolerating y: not even to consider yourself an x. The more labels you have for yourself, the dumber they make you.

J'aime beaucoup les écrits de Paul Graham en général et je viens de découvrir cet article un peu ancien. Une argumentation plutôt convaincante sur l'idée suivante: il est à peu près impossible d'avoir une discussion rationnelle sur un sujet que quelqu'un a intégré a son identité. Donc, pour être plus rationnel et plus ouvert, gardons notre identité la plus simple possible.


## [The Most Important Thing | Silicon Valley Product Group](https://svpg.com/the-most-important-thing/)

>Empowerment of an engineer means that you provide the engineers with the problem to solve, and the strategic context, and they are able to leverage technology to figure out the best solution to the problem. 

Un très intéressant, et court, article de Marty Cagan, du [Silicon Valley Product Group](https://svpg.com/). La vision du product management que partage Marty Cagan sur ce blog est bluffante - et cet article parvient à synthétiser une idée très forte de façon simple. Un autre article brillant: [Product vs. Feature Teams](https://svpg.com/product-vs-feature-teams/)


## [Why we at $FAMOUS_COMPANY Switched to $HYPED_TECHNOLOGY](https://saagarjha.com/blog/2020/05/10/why-we-at-famous-company-switched-to-hyped-technology/)

>Initially, we tried messing with some garbage collector parameters we didn’t really understand, but to our surprise that didn’t magically solve our problems so instead we disabled garbage collection altogether. This increased our memory usage, but our automatic on-demand scaler handled this for us, as the graph below shows

Une parodie bien sentie, et plutôt drôle, des articles que l'on peut voir régulièrement fleurir au sujet des changements de stack technique dans telle ou telle startup financée. Une des multiples facettes de l'obsession malsaine de notre milieu pour ses joujous: les technos.

]]></description><link>https://remihuguet.dev/blog/2020/06/01/les-liens-identite-produit-et-hype</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/06/01/les-liens-identite-produit-et-hype</guid><pubDate>Mon, 01 Jun 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Crise et recrutement de profils juniors]]></title><description><![CDATA[Où l'on témoigne des difficultés à trouver un job pour les juniors durant la crise covid - 
Aujourd'hui j'ai aidé mon client à faire une sélection dans les 100 et quelques CV reçus pour 1 poste de dev junior + 1 alternant.

Émotionnellement, j'ai vécu un très mauvais moment. C'est vraiment un moment merdique pour ceux qui se lancent.

80 % des candidats sont issus de reconversion. Je ne sais pas encore quoi penser vraiment à ce sujet, étant moi même un converti. En tout cas gros soutien à vous, ça doit pas être simple.

Le reste, les jeunes qui sortent de formation initiale en ce moment. Compliqué aussi pour eux de se lancer en ce moment, je pensai à mes gosses et je me suis senti mal pour eux. Courage aux jeunes, dites vous que le meilleur est à venir.

Pour finir, je tire quand même 2 enseignements. L'apprentissage, c'est un mode génial pour démarrer, et je suis intimement convaincu que c'est la voie d'avenir pour ce métier. Malheureusement, tout le monde ne peut pas y prétendre

Les grosses structures ont un rôle à jouer. On aime bien casser les grosses ESN dans notre milieu, mais en vrai certaines sont capables de prendre des juniors sur un potentiel, de les former et de leur mettre le pied à l'étrier.

Si vous démarrer, allez voir aussi du côté des grosses ESN, les centre de services et cie. Non tout n'est pas pourri, oui vous pouvez y faire une bonne première XP.]]></description><link>https://remihuguet.dev/blog/2021/01/12/crise-et-recrutement-de-profils-juniors</link><guid isPermaLink="true">https://remihuguet.dev/blog/2021/01/12/crise-et-recrutement-de-profils-juniors</guid><pubDate>Tue, 12 Jan 2021 00:00:00 GMT</pubDate></item><item><title><![CDATA[Clean architecture with Django]]></title><description><![CDATA[Where we draw a quick path to use clean architecture with Django framework - 

❓Today, I was asked what's a clean architecture to me when using Django web framework
💡I found it was a very interesting question - not so easy to make a synthetic, yet useful answer.


✍️ I start to write something with the idea that it must be short, synthetic and introduce what is necessary to start clean architecture with Django.
🤦‍♂️ It is much more complicated than I thought
😅Good news is, I have some interesting content to finish in coming days.


📚 However, the main takeaways are:

1. Make a domain model with in pure Python
2. Make application services of the domain with functions. Only primitives args, inject repository here
3. Make a concrete repository implementation with Django ORM

5. Views handles http stuff and calls application service
6. Forms handles http data validation and calls application service
7. Templates handles display stuff. Be dumb in templates

You can apply it to legacy. It is a great starting point.

🚀 After that you can go much further in clean architecture and DDD with Django ]]></description><link>https://remihuguet.dev/blog/2021/01/15/clean-architecture-with-django</link><guid isPermaLink="true">https://remihuguet.dev/blog/2021/01/15/clean-architecture-with-django</guid><pubDate>Fri, 15 Jan 2021 00:00:00 GMT</pubDate></item><item><title><![CDATA[La responsabilité du développeur]]></title><description><![CDATA[Où il est question de se comporter en adulte et assumer nos responsabilités - 
L'une des conversations qui doit se produire le plus souvent dans notre métier ressemble peu ou prou à cela:

>- Ça marche, mais on a des problèmes de qualité parce qu'on a pas de tests automatisés.
>- Pourquoi il n'y a pas de tests automatisés?
>- [Manager machin] nous a demandé de ne pas les faire pour sortir plus vite, et on nous accorde jamais le temps pour rattrapper la situation. On est pas écouté.


La première étape pour être écouté et pris au sérieux est d'assumer ses responsabilités.

Si on a délivré quelque chose dont la qualité est en-dessous des attentes, implicites ou explicites, c'est notre responsabilité.

_Bien sûr, il y a des organisations profondément dysfonctionnelles et de mauvaix managers._

Pour autant, nous devons assumer notre responsabilité: nous produisons le logiciel, c'est donc à nous de garantir qu'il est conforme au niveau de qualité attendu - explicite si possible, implicite souvent.

Si on juge indispensable d'avoir une suite minimale de tests automatisés, la première étape est de ne pas donner prise sur cet élément lors de la négociation de périmètre. (Sidenote: _c'est un des effets de bord intéressant du développement dirigé par les tests: l'obtention d'une couverture minimale de tests n'est pas négociable._)

Si on a livré en conscience en-dessous du niveau de qualité qu'on pense nécessaire, c'est notre responsabilité.

Pour être considéré comme des adultes et pris au sérieux dans l'organisation, commençons par nous comporter en adulte.
]]></description><link>https://remihuguet.dev/blog/2020/06/01/la-responsabilite-du-developpeur</link><guid isPermaLink="true">https://remihuguet.dev/blog/2020/06/01/la-responsabilite-du-developpeur</guid><pubDate>Mon, 01 Jun 2020 00:00:00 GMT</pubDate></item><item><title><![CDATA[Learning is the software engineer job]]></title><description><![CDATA[Where we state that learning is a part of software engineering job - 
Learning is a key part of software engineering activity.

We learn to understand business domains to build appropriate solutions to solve problems.

We learn how to deliver more values for people using our software, and so for our organisations.

Design a the other part of software engineering.

We are designing software. Product in software engineering is a name, not a verb.

Roughly speaking, we learn and we design. Then, we learn from our first designs and design again.

That's fast feedback loop agile development.

All these learning are what make us valuable for the organisation.

So, how come that for so much people, learning its own craft is not a part of the daily work for a software engineer ? It is a toxic behavior and economic non-sense.

Software engineer should not have to learn and improve during their free time.

They can if they want, have the will to. But it is bonus.

To succeed in the long term, any software engineering company must save a significant amount of time (20 - 25%? ) of software engineers to learn.

Whether it is big chunk of formal learnings or day-to-day learnings.

If you are a software engineer, please dont participate to this idea that it is normal to work long unpaid times to just keep in touch with what is our core craft.]]></description><link>https://remihuguet.dev/blog/2021/01/18/learning-is-the-software-engineer-job</link><guid isPermaLink="true">https://remihuguet.dev/blog/2021/01/18/learning-is-the-software-engineer-job</guid><pubDate>Mon, 18 Jan 2021 00:00:00 GMT</pubDate></item><item><title><![CDATA[Pour être agile, ne déployez pas la méthode Agile]]></title><description><![CDATA[Où il est question d'agilité et de méthode Agile - 
## Vous avez dit Agile ?

La méthode Agile est devenue totalement mainstream. Si vous n’en êtes pas convaincu, tapez “agile gartner” dans Google. Vous verrez que Gartner produit de nombreuses études sur le sujet Agile.

À commencer par le premier résultat, que l’on peut voir ci-dessous :


![Capture d'écran du premier résultat de la recherche "agile gartner" sur Google](./images/gartner_agile.png)

Cette étude, [“Enterprise Agile Planning Tools Reviews 2021”](https://www.gartner.com/reviews/market/enterprise-agile-planning-tools) est une étude portant sur les outils “qui aident les organisations à utiliser les pratiques agiles à l’échelle” (_“Enterprise agile planning (EAP) tools help organizations to make use of agile practices at scale[...]”_).

Il est question de planning, d’outils, de processus - et de mise à l’échelle. Ce n’est qu’un exemple, mais significatif : lorsqu’on évoque la méthode Agile, on parle d’abord d’outils et de processus.

Vous l’avez probablement vécu si vous travaillez à créer dans la tech. Une transformation Agile consiste à déployer un cadre de processus - Scrum souvent, ou SAFe - et à demander aux équipes d’adopter un ensemble de rituels, de pratiques et d’outils.

L’objectif n’est plus de créer des logiciels de valeur, mais d’être Agile. Mais est-ce bien le cas ?

__Est-on vraiment agile lorsque l’on déploie une méthode Agile ?__

## Du manifeste à la méthode Agile

Le mouvement Agile trouve son origine dans le [“Manifesto for Agile Software Development”](https://agilemanifesto.org/), publié en 2001, texte court qui met en avant quatre principes permettant de créer de meilleurs logiciels.

Les signataires de ce texte, développeurs, sont créateurs de différentes pratiques de développement: Kent Beck a publié eXtreme Programming en 1999, Ken Schwaber et Jeff Sutherland développent Scrum, Alistair Cockburn a crée Crystal Clear, parmi d’autres exemples.

Le manifeste a pour but de mettre en avant les principes clés qu’ils partagent.

Depuis, la méthode Agile s’est diffusée largement, y compris hors du champ du développement logiciel, et est devenue un business à consultants florissant.

Les start-up en phase de croissance sont des cibles naturelles de la méthode Agile.

Sous la pression d’une croissance rapide de l’organisation, on tente de déployer la méthode Agile à l’échelle de l’entreprise. Cela devient un objectif en soi.

Dans un contexte difficile, la tentation est forte d’appliquer aveuglément des recettes toutes faites. Il est demandé aux équipes de souscrire à des rituels, des contraintes et des pratiques qui sont hors sol et déconnectés des réalités quotidiennes de l’équipe.

Les grandes organisations traditionnelles, menacées par les start-up, la transition numérique, leur bureaucratie interne, pensent que la méthode Agile va leur permettre de mieux innover.

C’est une recherche vaine d’une solution miracle à des problèmes complexes. Outre qu’il n’est bien souvent plus question de développement logiciel, c’est une mauvaise analyse de penser que l’agilité des start-up vient de leur organisation.

Comme [l’explique Philippe Silberzahn](https://philippesilberzahn.com/2017/07/24/pas-agilite-dont-votre-organisation-a-besoin/), spécialiste du management des organisations en contexte de rupture :

>“Ce que montre le dilemme de l’innovateur, c’est que l’avantage des start-up n’est tant pas leur agilité que le fait qu’elles n’ont pas d’activité historique à protéger”.

Pourtant, les grandes organisations sont la première source de revenus des vendeurs de méthode Agile, [SAFe](https://www.scaledagile.com/enterprise-solutions/what-is-safe/) en tête, pour une agilité à l’échelle clé en main : tout est fait pour assurer la grande organisation contre le risque.

## _“Run, you fool!”_

Ces dérives ont des conséquences délétères sur les équipes. Elles sont dénoncées depuis plusieurs années, en premier lieu par des signataires du manifeste.

Dans [Agile is Dead (Long Live Agility)](https://pragdave.me/blog/2014/03/04/time-to-kill-agile.html), Dave Thomas, signataire du manifeste et auteur du classique “The pragmatic programmer”, est direct :

>"The word “agile” has been subverted to the point where it is effectively meaningless, and what passes for an agile community seems to be largely an arena for consultants and vendors to hawk services and products."

Scrum, par la volonté de ses créateurs, est devenu un standard Agile de fait. Les témoignages sur les dégâts d’une application sans recul de ces préceptes sont nombreux.  La charge de [Michael O’Church](https://michaelochurch.wordpress.com/2015/06/06/why-agile-and-especially-scrum-are-terrible/) est l’une des plus virulentes :

>“Scrum is the worst, with its silliness around two-week “iterations”. It induces needless anxiety about microfluctuations in one’s own productivity. There’s absolutely no evidence that any of this snake oil actually makes things get done quicker or better in the long run. It just makes people nervous. There are many in business who think that this is a good thing because they’ll “work faster”.

Pourtant, les acteurs sur le terrain sont de bonne volonté et de bonne foi. L’agilité est demandée par les équipes, les directions y voient l’opportunité d’une amélioration du fonctionnement de l’organisation, les facilitateurs veulent vraiment aider.

Alors comment en arrive-t-on à cette situation ? 

C’est le paradoxe (apparent) de l’agilité.

Vouloir imposer une méthode Agile vous éloigne de l’agilité, parce que vous entrez directement en contradiction avec le premier principe du manifeste.

**“Individuals and interactions over processes and tools”**

L’agilité packagée - de Scrum à SAFe, mais pas seulement - permet de rassurer des décideurs averses au risque, et des opérationnels mal à l’aise avec l’incertitude.

Avec ses rituels et ses pratiques, un framework Agile est une solution miracle à des problèmes complexes.

Mais cela n’a plus grand-chose à voir avec le manifeste, et - surtout - avec les besoins des organisations et des équipes.

## Accepter la complexité

Les managers doivent sortir du faux confort d’une méthode toute prête et affronter l’incertitude du terrain.

Être agile peut être un bon moyen d’atteindre vos objectifs - mais cela n’est pas garanti.

Pour cela, foin de méthode toute faite, de framework et de rituels.

Pour une organisation “tech”, c’est-à-dire pour qui le logiciel est au centre de la création de valeur, vouloir que l’organisation soit Agile n’est pas un objectif.

Ce que vous souhaitez, c’est créer plus de valeur : augmenter le chiffre d’affaires, le bien-être des salariés, la satisfaction des utilisateurs, la marge, ou n’importe quel objectif qui fait sens dans votre contexte.

Bien identifier ces objectifs, les décliner dans une vision et des missions pour chaque équipe est un bon point de départ.

Charge ensuite à chaque équipe de s’organiser, comme le rappelle Ron Jeffries dans [Developers Should Abandon Agile](https://ronjeffries.com/articles/018-01ff/abandon-1/) :

>"The Manifesto calls for “self-organizing” teams, and in the best case, that comes down to the team choosing its own process. If I were starting a company, I’d let the teams choose any process they wish. I’d ask for results, not a specific process" 

Il faut partir du terrain : des gens, du contexte, et utiliser la boîte à outils des méthodes pour construire la meilleure solution, [comme l'explique Dave Thomas](https://pragdave.me/blog/2014/03/04/time-to-kill-agile.html) :

>"What to do: Find out where you are Take a small step towards your goal Adjust your understanding based on what you learned Repeat How to do it: When faced with two or more alternatives that deliver roughly the same value, take the path that makes future change easier."

Mettre en place des équipes autonomes, donner le contexte stratégique et la vision, et permettre à l’équipe de construire ses solutions pour atteindre les objectifs de l'organisation est un pas vers une organisation agile.

## Au fondement ... ou pas

Utiliser aveuglèment une méthode Agile est en contradiction fondamentale avec le manifeste.

Si cela fonctionnait, ce ne serait pas bien grave - on se fiche de la fidélité au dogme originel.
Mais appliquer des méthodes Agile prêtes à l’emploi fait beaucoup de dégâts, et bien souvent cela crée plus de problèmes que cela n’en résout.


Commencez par identifier les objectifs véritables de votre organisation.

Il est indispensable de mettre les mains dans la complexité et travailler au plus près du terrain, donner des objectifs, une vision et des moyens à des équipes autonomes, capables de s’organiser pour délivrer des résultats.

Si vous êtes une organisation dont le logiciel est au cœur de la proposition de valeur, l’agilité, c'est à dire la capacité à s'adapter à un environnement d'incertitude - commence par l’excellence technique.

C’est souvent la grande oubliée des projets de transformation - et c’est pourtant le fondement à bâtir en premier.




_Je remercie Marie-Laure Kléville, Frédéric Bourguignon et Valentin Decker pour leurs relectures et avis sur cet article. Que ce soit le premier d’une longue série._


## Des liens cool

Voici quelques ressources en lien avec le sujet:
- [Et si on redémarrait l'agile ? Arnaud Lemaire](https://www.youtube.com/watch?v=pLISFJM22ro&t=3s)
- [Allen Hollub “War is Peace, Freedom is Slavery, Ignorance is Strength, Scrum is Agile”](https://www.youtube.com/watch?v=WFbvJ0dVlHk)
- [“Running in circles” Basecamp, Shape Up](https://m.signalvnoise.com/running-in-circles/)
- [Why Agile isn’t working, John Cutlefish](https://cutle.fish/blog/why-isnt-agile-workin)
- Les articles du [SVPG](https://svpg.com)
    - https://svpg.com/lead-with-context-not-control/
    - https://svpg.com/the-alternative-to-roadmaps/
    - https://svpg.com/meaningful-transformation/

]]></description><link>https://remihuguet.dev/blog/2021/06/02/pour-etre-agile-ne-deployez-pas-la-methode-agile</link><guid isPermaLink="true">https://remihuguet.dev/blog/2021/06/02/pour-etre-agile-ne-deployez-pas-la-methode-agile</guid><pubDate>Wed, 02 Jun 2021 00:00:00 GMT</pubDate></item><item><title><![CDATA[Pourquoi les choix techniques ne sont pas (si) importants]]></title><description><![CDATA[Où il est question de succès et de problèmes dans les équipes logicielles, et des choix techniques - 

## Alors, elle est bien ma stack ?

Lorsque je prends contact avec une nouvelle équipe, la première question qui m'est posée concerne les choix techniques, et leur viabilité. En particulier, pour identifier ce qui ne s'est pas bien passé : maintenabilité et qualité en berne, temps de développement qui explosent, bref, la sempiternelle litanie des problèmes rencontrés dans presque tous les projets.

Il est de bon ton alors de chercher un coupable du côté des choix techniques.


- *"Est-ce qu'il ne faudrait pas utiliser *langage machin* à la place de *langage truc* ?"*
- *"Est-ce qu'il ne faudrait pas changer le framework web, le précédent nous a causé une grosse dette technique”*
- *"On devrait passer sur une architecture microservices pour résoudre nos problèmes avec le monolithe”*

Le choix technique, c'est stratégique. Vraiment ?

En fait non. Les choix techniques ne sont pas un facteur (si) déterminant dans les réussites et les échecs d'une équipe.


## Un outil pour chaque tâche

Se concentrer sur les choix techniques est naturel. En tant qu'ingénieur nous aimons penser qu'il existe un outil adapté pour chaque tâche. Y compris pour construire des logiciels. Après tout, nous sommes formés pour ça, et aimons ça. C'est un biais structurel de notre profession : nous adorons discuter choix techniques, mérites et compromis respectifs.

Nos formations initiales et notre culture, encore très imprégnées de l'ingénierie industrielle classique et de taylorisme, nous poussent à penser qu'il nous faut tout définir au début d'un projet. Si par ailleurs, il y a un outil adapté pour chaque tâche, cela rend les choix techniques critiques : il ne faut pas se planter d'outil ! Cela structure même en grande partie le recrutement des développeurs. On recherche un développeur Javascript, Python ou Java, quand ce n'est pas un développeur React, Django ou Spring.


La multiplication exponentielle des technologies et écosystèmes disponibles pour créer du logiciel rend le sujet encore plus complexe - et potentiellement anxiogène. Cette complexité croissante du paysage technique rend les choix techniques illisibles et donc intimidants. Pour les responsables, le succès du produit semble lié aux choix techniques, ce qui renforce l'obsession du "bon choix" : si on se plante au démarrage, on risque l'échec. La mythologie autour du "bon choix" est un biais qui fait surestimer le rôle des choix techniques dans les succès de logiciel, tout comme dans les échecs.


Mais c'est au final bien humain. Pour tous les acteurs, le choix technique, c'est un sujet rassurant.

Concrète, investi par les plus grands cabinets conseils, qualifier une technologie semble être une démarche rationnelle, voire presque scientifique. Cela semble objectivable. Qui n'a jamais vu une matrice de choix, dont les critères et la notation, parfaitement arbitraire au demeurant, ne sont là que pour justifier par un vernis rationnel la décision qui a en fait déjà été prise ?

_"Nobody ever gets fired for choosing IBM"_

De même qu'on ne pouvait pas reprocher à quelqu'un de choisir IBM comme fournisseur, on ne reprochera à personne l'échec d'un projet si on peut l'imputer à une technologie, surtout si le choix a pu être rationalisé en apparence. C'est un terrain sur lequel tout le monde est à l'aise.

## Le voile des illusions


Les technologies ne peuvent pas être le facteur primaire de succès ou d'échec d'un produit.

D'un point de vue des organisations, il existe des échecs et des réussites à peu près pour n'importe écosystème technique. L'open source devenu quasiment universel, les écosystèmes se développent et se nourrissent des organisations qui les utilisent avec succès. Les échecs et difficultés se rencontrent dans tous les écosystèmes. Les technologies se développent malgré ces difficultés, et n'empêchent pas l'adoption par de nouveaux usagers. Même s'il existe des cycles dans l'usage de toutes les technologies, ils sont plus dictés par les modes et les influences du moment que par un facteur discriminant sur la réussite ou l'échec des projets qui les utilisent.


La multiplication des technologies rend au contraire le choix de plus en plus indifférent pour la majorité des problèmes.

Si vous devez faire une application web, il existe de très nombreux choix possibles, et il y a peu de chances qu'aucun soit discriminant pour la réussite du projet. La majorité des développements logiciels n'ont pas de contraintes critiques. Sauf à envoyer une capsule sur l'ISS ou à devoir encaisser le trafic de Google ou de Facebook, vous n'avez probablement pas de grosse pression à choisir la bonne technologie. Les choix techniques ont leur importance bien sûr. Mais la plupart du temps pas sur la base de leurs qualités propres.

Les choix techniques sont utilisés, inconsciemment la plupart du temps, pour éviter le facteur vraiment critique pour toute équipe logicielle : les gens qui la composent et leurs compétences.

## Le facteur X

Le projet de refonte est un grand classique de la communication sur les mérites intrinsèques supposés d'une technologie. Classiquement, après avoir fait une première version d'un logiciel qui connaît un peu de succès, il faut repartir de zéro parce que les performances ou l'évolutivité se dégradent. Il est souvent de bon ton d'incriminer les choix techniques dans ce genre de cas. Si jamais le projet de refonte se passe bien - ce qui n'est pas si courant - on sera renforcé dans cette vision des choses.


Pourtant le facteur décisif, ce sont les compétences de l'équipe, la qualité de son fonctionnement et la connaissance du domaine.

Les compétences techniques des développeurs mises en avant sont les pures compétences technologies : langage, framework, … Les compétences transverses, les tests automatisés, le Test Driven Development, l'intégration continue, le Domain Driven Design, sont plus souvent négligées. Ces compétences sont longues à acquérir, complexes à aborder et à installer, en particulier dans des équipes avec des habitudes ancrées. Elles ont bien plus d'impact sur la réussite d'une équipe que la connaissance d’un langage. À long terme, elles sont un facteur bien plus décisif sur le succès.


Le bon fonctionnement d'une équipe est un facteur clé également. Une équipe bien organisée, qui sait communiquer et collaborer est bien plus prédictive de succès que n'importe quel framework. Développer ces compétences nécessite un travail au long cours qui ne peut pas être seulement effectué par des sessions de formations. Cela implique de laisser les ingénieurs avec suffisamment d'espace à consacrer, durant leur temps de travail, pour leur formation et leur veille technique. Comme je l'écrivais [ici](/blog/2021/01/18/learning-is-the-software-engineer-job), apprendre est une activité de base pour tout ingénieur logiciel, et une entreprise qui veut vraiment réussir devrait viser 20% du temps de travail dédié à cela.


L’un des facteurs le plus critique de réussite, celui qui peut éventuellement rendre un projet de refonte pertinent, c'est la connaissance du domaine. Cette compétence intangible sur le problème que l'équipe cherche à résoudre s'accumule au fil du temps. Comprendre ses utilisateurs intimement, avoir une connaissance fine du problème à résoudre est un actif critique.


## Vous reprendrez bien des microservices ?

Les technologies et les choix techniques que nous faisons sont structurants dans l'activité de développement logiciel. Nous pouvons penser que les choix techniques sont critiques pour la réussite des produits. Nous nous y intéressons trop, par biais professionnel, parce que c'est un terrain en apparence ferme qui permet d'éviter les sujets désagréables : les problèmes humains et le développement des compétences des équipes.


Le succès, et les problèmes, d'une équipe sont déterminés par les compétences transverses, le bon fonctionnement de l'équipe, sa capacité à innover et à s'approprier le domaine et le problème qu'elle essaye de résoudre. Développer ces aspects exige un investissement important et de long terme sur les gens. Cela peut être difficile à faire, les résultats peuvent mettre du temps, c'est un terrain mouvant et complexe. Sur le long terme, c'est votre levier le plus sûr sur le succès ou l'échec d'un produit - bien plus que n'importe quel choix technologique.


Il peut arriver qu’un échec soit réellement imputable à un mauvais choix technique. Mais même dans ce cas, le vrai problème sous-jacent, c’est bien la compétence des membres de l’équipe et la connaissance du problème à résoudre, qui a mené a taper totalement à côté de la cible.

Il reste un autre déterminant majeur de succès ou d’échecs: les dysfonctionnements de l'organisation, et les problèmes systémiques en qui en découlent. Pour résoudre ces problèmes, résistez à l'envie de déployer une architecture microservices comme solution.


]]></description><link>https://remihuguet.dev/blog/2021/06/12/pourquoi-les-choix-techniques-se-sont-pas-si-importants</link><guid isPermaLink="true">https://remihuguet.dev/blog/2021/06/12/pourquoi-les-choix-techniques-se-sont-pas-si-importants</guid><pubDate>Sat, 12 Jun 2021 00:00:00 GMT</pubDate></item><item><title><![CDATA[How to start clean architecture with Django]]></title><description><![CDATA[Where we eexpose the essence on how you can start to use clean architecture when dealing with Django framework - ## TODO

- dessins
- code examples

Today, I was asked about what I consider a clean architecture when using Django. 
I thought it was a fantastic question, particularly if I try to make a synthetic yet useful answer.
So let's try

## What are we talking about anyway ?

[Django](https://www.djangoproject.com/) is popular web framework built with Python.
Like Rails and some others, it was built in the mid 2000s to allow for rapid development, and it does a real good job for that.
It comes with a HTTP layer, a templating engine and an ORM. 
It enforces a kind Model - View - Template architecture, the model layer being the starting point of almost everything.
It is intended to be both the data persistence layer and the domain model - with the "fat model" approach.

Models are then used both in views - and forms API - and in templates.
This often results in domain knowledge being scattered through models, forms, views and templates.
In the better case, with a lot of discipline, you can at least have all your domain knowledge in your models, but you still have a high coupling between data models and domain models.
This results usually in long running tests, which makes it hard to benefit from a short feedback loop if you want to use TDD.

So, how can we go beyond these problems ?

## Clean architecture to the rescue

Clean architecture, and its close parent hexagonal architecture, are architectural styles whose goals are to protect the core domain model from couplings to the external world.


The idea is that, to built lasting, efficient and easy to change software, we must strictly protect the core domain model.
It should not depend on anything coming from the external world, be it http request, data persistence system, third-party API.

Moreover, it should be easy to change one of these input / output system, or add one.
Need to change the database ?
Need to build a CLI ?
You should just have to respect some contract and plug in to the appropriate port.

Without going into much detail, the basic, vital idea is that dependency should always go from the outside to the inside: exterior element can depend on inner element, but never the other way.

HTTP controller depends on the domain.
A persistence system depends on the domain.

To do that, you can easily start with two patterns:
- dependency injection, to let the domain model handle it's interactions to external systems it controls
- function with simple API on the domain model to be called by external systems that drives the application

## How can it be used with Django ?

The principal problem with Django is the coupling between the data model and the domain model.
They are the same!
A secondary, yet important, problem is the scatter use of data models, with uncontrolled calls to the persistence, through the views and templates.

Without going on a full blown approach like in the excellent [Software Architecture Patterns with Python book](), you can start with the following simplified approach.


### Domain model

Start by creating a real domain model, with entities and value types (value objects) to replace the data model.

You can use plain and simple Python objects to start.
I highly recommend that you use [Pydantic]() coupled to [dataclasses]() and [type hints]().
You'll be able to define typed, declarative models with basic type validation, with a neat and comprenhensive code.

This model must carry all the behavior.
You can migrate behavior properties and functions from your Django models.


Persistence will be handled by the domain model through a repository pattern.
You define an interface that repository implementations must follows in the domain: get an entity, save, and whatever you need.
In Python, you can use [abstract base classes]() or [protocol]() to have some interface kind.
Concrete repository instances will be provided through dependency injection.


You won't use directly domain models directly from the views.
Usually, creating consistent instances will implies several steps, with interactions with persistance system.
To handle that, you will have an application services layer (or use cases layer).
It can be plain functions.
Try to have only primitive or very simple types in the functions signatures, to avoid the detailed domain knowledge to leak in the view.
All these should be located in the domain model.
These functions will handle interaction with the persistance system through a concrete instance of repository.

With that, you already have:
- a really short feedback loop to TDD it, because you will use an in-memory repository implementation
- interfaces with primitive to major use cases for the views to call


### ORM repository implementation

For production, you'll use a concrete implementation of the repository based on the ORM.
With a legacy system, you can even stick to existing models quite simply.

Define (Django) data models as is best fitted for your need, and implements the repository methods.
Integration tests will give you confidence that it is well working.

### The view layer

There is not much change needed in the view layer.
You should  pay attention the following points.

Views should be the dumbest possible: doing some http stuff, calling a service from the application service, returns something.
Views are responsible for providing a repository implementation to the application service.
Forms are a practical way to handle form data validation, and can be used to call application service too.
Templates should be the dumbest of all.
Provides only in-memory, flattest possible data structure (sometimes called view model).
Manage only display logic in templates.

## Enjoy and go further

With this approach, you can quickly have great improvements on several matters.

Your domain knowledge is expressed in a pure Python, semantic domain model, located in a single place.

Use cases are expressed as application service functions.

All the domain model can be tested with a fast in-memory repository implementation.

Interactions with persistance system is located in one place - the repository - making performance and optimisations easier.

Views are back to their role: handling http interactions.
Forms are back to their role: http data validations.
Templates are back to their role: displaying.

Even with a complicated, legacy system, you can incrementally use this starting patterns to improve.

You can go much further on that path, but that's a starting point.
]]></description><link>https://remihuguet.dev/blog/2021/01/21/how-to-start-clean-architecture-with-django</link><guid isPermaLink="true">https://remihuguet.dev/blog/2021/01/21/how-to-start-clean-architecture-with-django</guid><pubDate>Thu, 21 Jan 2021 00:00:00 GMT</pubDate></item><item><title><![CDATA[Je n'utilise pas l'astrologie pour prendre des décisions]]></title><description><![CDATA[Où il est question de prendre des décisions et d'estimations. - 

Il est difficile de prendre des décisions. Prendre une décision, c'est en général faire un choix, et donc renoncer. C'est opter pour un chemin, sans avoir de certitudes sur les implications du choix. L'avenir est incertain. Si les conséquences, coûts, bénéfices, inconvénients à court terme d'une décision sont parfois claires, les impacts à plus long terme le sont beaucoup moins.


La raison en est simple, et admise assez aisément par la majorité des gens à peu près rationnels : on ne peut prédire le futur.


Que cela soit pour la vie quotidienne ou pour diriger un pays, les exemples de pratiques irrationnelles destinées à nous rassurer sur nos décisions sont légion. L'un va consulter un astrologue pour savoir s'il doit poursuivre cette nouvelle relation, l'autre un conseiller en investissement qui prédit les tendances de la bourse pour placer ses économies. Même les chefs d'État ont régulièrement recours aux services de charlatan en tout genre pour les rassurer sur leurs décisions.


C'est humain. Nous éprouvons tous un grand inconfort face à l'incertitude. Nombreux sont ceux qui utilisent des moyens peu rationnels en toute connaissance de cause pour prendre des décisions.


En matière de développement logiciel, vouloir prédire le futur reste une activité répandue. Les prédictions sur le déroulement du développement d'un logiciel s'appellent généralement des estimations. De plus en plus de professionnels admettent qu'elles ne fonctionnent pas, et pourtant continuent à les utiliser pour prendre des décisions. J'ai toujours trouvé cela étrange.


Je comprends maintenant pourquoi : c'est humain. C'est un moyen simple de se rassurer sur les décisions que l'on prend. Cela permet de s'accrocher à une forme d'empirisme et de rationalité de façade. L'objection la plus répandue que j'obtiens quand je propose de les abandonner est : "Mais comment va-t-on prendre une décision ?"


Je n'ai pas toujours de réponse. Il n'y en a pas de simple. Prendre des décisions, tous les jours, en tant qu'être humain, est une chose difficile.


Mais en tant que professionnel, je ne peux pas me contenter de cela. Nous devrions faire mieux. Même si cela nous rend la vie plus compliquée ou que cela nous met face à nos propres insécurités. Je n'ai pas d'alternatives à l'astrologie dans ma vie quotidienne, et pourtant je n'y recours pas.


Si vous pensez que les estimations dans le logiciel ne sont pas fiables (même si vous pensez qu'elles sont marginalement fiables), n'acceptez pas de les utiliser pour prendre des décisions.
]]></description><link>https://remihuguet.dev/blog/2023/01/04/estimations-astrologie</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/04/estimations-astrologie</guid><pubDate>Wed, 04 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Dynamique d'équipe]]></title><description><![CDATA[Où je parle de la dynamique d'équipe et de la sécurité psychologique - 
Une dynamique d'équipe est fragile.

Il est courant que l'autonomie, la responsabilité, la prise d'initiative soient des valeurs déclarées comme importantes par les dirigeants d'une entreprise. Il est plus rare que la réalité quotidienne soit alignée avec les déclarations.

La sécurité psychologique, notamment, est un élément clé, nécessaire pour que ces bonnes intentions deviennent une réalité vécue.

Lorsque cet élément est présent, la dynamique vécue au quotidien au sein de l'équipe a un côté magique.

Mais c'est quelque chose de fragile. Il n'est pas évident de comprendre comment il a été apporté à l'équipe. Il est très facile de le perdre. Les mauvaises décisions de management sont vites prises. Une communication ratée, quelques malentendus, un changement mal géré, et les effets peuvent être dévastateurs, très rapidement.

Les marques de défiance vis à vis de l'équipe sont particulièrement efficaces pour détruire la sécurité psychologique. Si vous êtes manager, méfiez-vous de vos impulsions de contrôle et de votre propre insécurité. Le résultat pourrait être désastreux.
]]></description><link>https://remihuguet.dev/blog/2023/01/03/dynamique-equipe</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/03/dynamique-equipe</guid><pubDate>Tue, 03 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[La température de l'eau]]></title><description><![CDATA[Où il est question des (mauvaises) habitudes que nous acceptons dans notre quotidien de développeur. - 
Ce matin je suis tombé sur ce [tweet] (https://twitter.com/AngiG29/status/1610682617875075073)


En quelques mots, une développeuse y explique le processus complexe, voire ubuesque, qui lui a été expliqué pour qu'elle puisse tester ses modifications sur un projet.


L'exemple est particulièrement salé - et potentiellement drôle.


Quoi qu'en y pensant à deux fois, j'ai ri un peu jaune.


Combien de fois par jour, dans notre quotidien de développeur, nous reposons-nous sur un processus inutilement complexe ? Une étape manuelle ? Des détails non documentés ? Quand nous baignons dedans tous les jours, nous percevons bien que tout n'est pas parfait. Mais nous nous habituons malgré tout à la température moyenne de l'eau.


Alors peut-être que nous ne devrions pas trop sourire de cet exemple. Il est possible que notre quotidien de développeur, vu de l'extérieur, n'en soit pas si éloigné.


La médiocrité s'installe facilement. Maintenir un haut niveau de qualité du code est une tâche quotidienne, qui demande un effort conscient et des compétences.
]]></description><link>https://remihuguet.dev/blog/2023/01/05/temperature-eau</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/05/temperature-eau</guid><pubDate>Thu, 05 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[365 challenge - Bilan une semaine]]></title><description><![CDATA[Où je dresse un bilan après une semaine de challenge d'écriture - Après une première semaine de challenge, voici venu le temps d'un premier bilan. C'est pratique, ça me permet de remplir une journée du challenge.


Un, je n'ai pas publié hier. Aïe, le challenge serait-il déjà perdu ? Oui, parce que je n'ai pas publié. Non, parce que j'ai écrit quelque chose comme 300 mots... Mais j'arrive dans ma zone d'inconfort : le personnel. Et ce n'est pas terminé. Donc pour l'instant ce n'est pas publié.


Deux, pour cette première semaine, je n'ai écrit qu'en lien avec mon métier, le logiciel (et les organisations). C'est une zone de confort. Je ne suis pas très fier de ce que j'ai produit, mais cela a généré quelques interactions intéressantes.


Trois, je sens que la règle de devoir publier tous les jours va vite me poser problème. J'aime bien écrire des formats courts, mais j'aimerais aussi reprendre des formats plus long et structurés. Ce n'est pas incompatible, je peux écrire un format court tous les jours ET travailler sur des formats plus longs en parallèle. C'est même un peu le but du challenge, prendre une habitude pour arriver à écrire plus.


En conclusion, je vais donc amender un ma règle concernant la publication. Je veux me permettre de ne pas publier tous les jours, l'objectif principal étant d'écrire. J'ai quand même besoin de quelque chose de public pour attester ça, même si c'est symbolique. Je ferai donc un commit de mes drafts. Un commit chaque jour, c'est simple.
]]></description><link>https://remihuguet.dev/blog/2023/01/08/365-challenge-bilan</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/08/365-challenge-bilan</guid><pubDate>Sun, 08 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[De la relativité au logiciel, une question de principes]]></title><description><![CDATA[Où il est question de physique, de principes premiers et d'A. Einstein. - 

## Il était une fois, dans une vie lointaine...

Avant d’être développeur, j’ai été un jeune chercheur doctorant en physique.
Théoricien, j’ai étudié durant mon doctorat des modélisations de la matière nucléaire prenant en compte la chromodynamique quantique - la partie du modèle standard qui s’occupe des interactions fortes.


Lorsqu’on me demande ce qui m’a permis de faire la bascule de l’un à l’autre, j’ai tendance à donner la réponse facile : j’ai beaucoup codé pour mes travaux de recherche et j’étais un autodidacte familier de l’informatique.


Sauf que c’est assez faux. Ces raisons sont plutôt **pourquoi** j’ai choisi l’informatique.
Pour la même raison que j’en pratiquais beaucoup, et que je l’ai brièvement enseigné aux étudiants de première année en physique : ça me plaisait et ça m’avait toujours plu.


Ce qui m’a vraiment permis de m’adapter et de compenser mon manque de formation initiale, c’est la façon de penser du scientifique.
Une méthodologie de travail et de raisonnement que j’ai cultivé en tant que physicien: le raisonnement par les principes premiers, first principles thinking en anglais.


Je ne l’ai compris que récemment, mais c’est ce mode de pensée, assez peu utilisé dans le développement logiciel, qui me permet de réussir dans ce domaine.
Pratiquée régulièrement, cette façon de penser est une forme de superpouvoir.
Nous gagnerions beaucoup à la diffuser et l’utiliser plus dans l’ingénierie logicielle.


## Le petit Albert et la vitesse de la lumière

Lorsque j’étais étudiant en physique, le domaine que j’ai préféré découvrir était la relativité restreinte.
En effet, tous les résultats peuvent se retrouver à partir de principes de base fondamentaux simples.
Les mathématiques impliquées sont “relativement” faciles, et tout découle logiquement des postulats de départ.


La théorie de la relativité restreinte[^1] est publiée en 1905 par Albert Einstein, et elle traite de la dynamique des corps en mouvement et des équations électromagnétiques.
Cette année-là, Albert Einstein, alors employé au bureau des brevets à Berne, publie quatre articles fondateurs, qui vont poser les bases de la physique moderne.


Dans “Sur l’électrodynamique des corps en mouvement”, il s’attaque au problème de l’éther.
Supposé être le support matériel des ondes électromagnétiques, l’éther est un concept ancien, dont la théorie est améliorée progressivement au XVIIIème et XIXème siècles.
Mais elle avait été mise à mal dans les années 1880 par les expériences de Michelson et Morley[^2].
Alors que ces expériences auraient dû démontrer le mouvement relatif de la terre par rapport à l’éther, le résultat était négatif. Comme si l’éther n’existait pas.
Personne ne parvient à expliquer ce résultat à l’aide d’interprétations classiques durant vingt ans.


Einstein va résoudre le problème en reprenant le problème au fondement.
Il part des seules hypothèses qui lui semblent être fondamentales:
- les lois de la physique, mécaniques et électrodynamiques, sont les mêmes dans tous les référentiels galiléens
- puisqu’il n’est pas possible de mesurer une vitesse de la lumière différente selon le référentiel, il postule que la vitesse de la lumière dans le vide est la même quel que soit le référentiel.


Sur cette base, il construit, au long d’un article fascinant de 9000 mots, sans aucune référence ni note, une théorie du mouvement des corps dont les impacts vont être l’un des fondements de la physique développée au XXème siècle[^3].


Les résultats des articles de 1905, dont celui-ci, sont essentiels dans le développement de la physique moderne.
Mais c’est surtout dans son approche méthodologique qu’Einstein va changer la façon dont on fait de la physique.
Au lieu d’améliorer progressivement ce qui existe, de fonctionner par imitation et analogie, Einstein propose de remettre en question tous les fondements supposés acquis des théories classiques.
Il attaque les problèmes en les décomposant et en mettant de côté tout ce qui n’est pas suffisamment solide, pour se concentrer sur les hypothèses les plus sûres et bâtir à partir de là.


C’est le principe même du raisonnement par les principes premiers.


## First principles thinking

Le raisonnement par les principes premiers n’est pas spécifique de la physique, mais il est paradigmatique de la méthode scientifique.
Ce n’est que très récemment que j’ai mis un nom sur quelque chose que je pratique depuis très longtemps.
Durant mes études, j’avais notamment développé une méthode de travail et d’apprentissage basée sur le principe suivant : comprendre plutôt que mémoriser, apprendre les principes, pas des formules[^4].

Ma méthode de travail consistait à :
- identifier les quelques éléments fondamentaux à retenir, ceux qu’on ne peut pas retrouver
- s’approprier le domaine, par la parole (je me parlai beaucoup à moi-même), la reformulation et les lectures connexes
- la répétition d’exercices et démonstrations de base, si possible avec différentes méthodes
- en toutes circonstances, refuser de ne pas comprendre


À court terme, c’était un investissement important, assez peu payant. 
Ce n’est pas pour rien que le simple bachotage reste la méthode la plus répandue pour passer ses examens.
Mais à long terme, cela m’a permis de construire une compétence incroyable, qui m’a servie en tant que physicien et en tant que développeur : savoir trouver des solutions quand je n’en ai pas une toute prête.


Cette méthode de travail est une forme de raisonnement par les principes premiers.


Dans son article [First Principles: Elon Musk on the Power of Thinking for Yourself](https://jamesclear.com/first-principles), James Clear définit le raisonnement par les principes premiers de la façon suivante :

>First principles thinking is the act of boiling a process down to the fundamental parts that you know are true and building up from there.


Lorsque nous sommes confrontés à un problème ou avons une tâche à accomplir, nous cherchons d’abord une solution toute prête dans notre expérience.
C’est une forme d’économie d’énergie du cerveau : cela consomme beaucoup moins de ressources d’utiliser une expérience passée, une recette déjà apprise, de fonctionner par analogie ou par imitation.
Et heureusement que nous fonctionnons ainsi. Nous ne pouvons pas en permanence inventer de nouvelles solutions.
Être capable de sortir de ce mode est pourtant important.
Vinita Bansal dans [First Principles Thinking: The Most Powerful Way To Think](https://www.techtello.com/first-principles-thinking/) écrit:

>When faced with complicated problems at work or in life, they are inclined to follow a safe path to known practices and do not attempt a hard path that requires digging deeper and exploring unknown territory.


Utiliser le raisonnement par les principes premiers est d’autant plus difficile et exigeant que l’on n’a pas l’habitude de le pratiquer.
Cela peut même être inconfortable, car comme l’écrit Vinata Bansal, cela nécessite une rupture dans les croyances courantes et le dogme:

>A shift in thinking that discards conventional wisdom, cuts through the dogma and questions our own beliefs.


Pour cette raison, c’est aussi un excellent moyen de forger une pensée critique et originale : prendre l’habitude de décortiquer les problèmes, d’identifier les hypothèses implicites ou non, conserver uniquement celles que l’on ne peut pas déduire plus avant, construire sur ces bases.

>If you want to enhance an existing process or belief, continuous improvement is a great option. If you want to learn how to think for yourself, reasoning from first principles is one of the best ways to do it. 
>*James Clear*


Comment le raisonnement par les principes premiers m’a-t-il aidé depuis que je suis développeur logiciel ?


## Et l’ingénierie logicielle ?

Commençons par la réponse franche : je ne sais pas vraiment.
J’ai quelques pistes, des débuts de compréhension, beaucoup de questions en suspens.
La chose dont je suis sûre, c’est que ma méthode de travail et de raisonnement m’a permis de compenser les manques inhérents à un autodidacte.


Il se trouve que le développement logiciel est dominé par la méthode de travail par analogie et imitation.
Ce n’est pas étonnant, c’est le mode dominant que l’on apprend à l’école.
Cela reste par ailleurs une étape pédagogique probablement indispensable.


Pourtant, je suis toujours surpris de voir à quel point ce milieu semble attaché à des pratiques qui me paraissent mauvaises.
Il faut connaître un certain nombre d’algorithmes (les fameux tests au tableau blanc…), connaître les designs pattern du Gang Of Four[^6], connaître l’API de tel framework, …


Lorsque l’on doit résoudre un problème, le réflexe par défaut semble être de copier quelque chose qui y ressemble vaguement.
Le succès de Stack Overflow, et les innombrables mèmes et blagues sur le “Stackoverflow driven development”, constitue les meilleures preuves que, pour encore trop de développeurs, la discipline consiste surtout à imiter.


Ce n’est pas un mal en soi. Parfois, imiter ou utiliser une solution toute prête est la meilleure chose à faire.
Il m’arrive d’utiliser Stack Overflow, pour trouver de nouvelles pistes sur un problème ou me documenter.
Les problèmes surviennent quand c’est le seul mode de fonctionnement que l’on connaît.


J’ai l’intuition, la conviction même, qu’il y a beaucoup à gagner à apprendre à travailler selon les principes premiers.
Ne serait-ce qu’un peu.
Comme le dit Jame Clear, “aller un ou deux niveaux plus profond que la plupart des gens”[^5] suffit pour tirer un avantage d’utiliser le raisonnement par les principes premiers.


Mais comment l’utiliser dans le cadre de l’ingénierie de logiciels ?
Si je regarde ma propre pratique, j’ai quelques pistes.



La première application la plus évidente est pour la résolution de problèmes, en particulier le debug.
Dans le cadre de la résolution de bug, c’est une méthode terriblement efficace, qui ressemble à une démarche expérimentale.
Une façon de commencer à utiliser le raisonnement par les principes premiers dans ce cadre est de :
- rassembler les faits et observables dont on dispose (logs, capture d’écran, …)
- décortiquer et expliciter toutes les hypothèses et préconceptions implicites que l’on a sur le contexte
- identifier et écarter impitoyablement tout ce qui n’est pas fondé 
- pour chaque hypothèse restante, déterminer un processus et une méthode de vérification empirique


Ce mode de pensée peut aussi être utilisé pour la recherche de solutions innovantes à un problème. 
Analyser de façon systématique les différentes composantes d’un problème, identifier et porter un œil très critique sur les hypothèses faites apporte déjà un plus pour la conception de solutions.


La deuxième piste concerne l’apprentissage.
Pour un développeur, apprendre est une composante essentielle du métier.
Utiliser le raisonnement par les principes premiers permet d’apprendre à apprendre vite, et de développer une plasticité qui permet d’adopter rapidement de nouveaux outils ou technologies.


Je fais en sorte de toujours m’approprier les concepts en déconstruisant, reformulant, et refaisant par moi-même.
Il existe une tendance dans toute spécialité de noyer les concepts importants sous des montagnes de complexité artificielle et de bruit.
Lorsque j’aborde un nouveau sujet, j’essaie d’identifier les principes fondamentaux sous-jacents, et de le séparer des détails.


Par ailleurs, je me limite à quelques sources de documentation.
J’utilise en général abondamment les documentations officielles.
Je suis peu de cours en ligne, de tutoriels, et lis assez peu de livres techniques.
En la matière, l’important n’est pas la quantité mais la qualité.
Chaque lecture doit s’accompagner d’un travail de pratique et de reformulation, qui est très chronophage.


Reste la conception et l’architecture logicielle au sens large.
J’ai pour l’instant des intuitions sur la façon dont le raisonnement par les principes premiers m’aide dans ce domaine.
La méthodologie en elle-même apporte un regard différent sur l’architecture ou la conception de code.


Au-delà de la méthodologie, la question qui se pose est : quels sont les principes de conception fondamentaux ?
Classiquement, nous pouvons citer les suspects habituels : SOLID, KISS, DRY[^7], principes du Domain Driven Design, les designs pattern du Gang Of Four, …


Certaines de ces pratiques sont sans doute des principes premiers.
D’autres désignent déjà des notions composites, qui peuvent se déduire de principes plus fondamentaux.
Le jour où l’on doit résoudre un problème qui sort un peu du cadre, nous serons mieux armés si nous comprenons les principes fondamentaux qui ont permis de construire ces concepts.


Je ne sais pas quels sont ces principes.


Ils ne sont probablement pas universels d’ailleurs, mais dépendent du problème étudié, du contexte et du niveau d’abstraction où l’on se place.
J’ai quelques intuitions et idées, mais trop confuses encore pour les partager.

Je suis convaincu que l’utilisation plus large du raisonnement par les principes premiers dans la communauté de l’ingénierie logicielle et formuler, diffuser et enseigner des principes fondamentaux pourrait aider à améliorer la pratique et l’apprentissage du métier.


## Une méthode qui gagne à être connue


Pour expliquer le résultat négatif des expériences de Michelson et Morley, Albert Einstein est revenu aux principes les plus fondamentaux.
Sur cette base, il a écrit l’article de physique le plus fascinant de l’histoire de cette science, et changé notre compréhension de la physique et la façon dont on pratiquait la discipline.


Sans avoir la prétention d’avoir autant d’impact, cette façon de raisonner peut nous aider au quotidien dans notre métier de développeur.


Elle nécessite un investissement, et comme toute pratique nouvelle nécessite du temps pour s’acquérir et être efficace.
Bien utilisée, elle permet d’apprendre à mieux apprendre, d’apporter des solutions innovantes à des problèmes complexes.


Je pratique cette façon de travailler en tant que développeur depuis quelques années maintenant.
Que ce soit pour apprendre et me former, pour résoudre des bugs, pour aborder des problèmes complexes, cet héritage de mon passé de physicien a été mon meilleur atout en tant que développeur.


Je suis convaincu que la formulation claire, la diffusion des principes premiers de l’ingénierie logicielle, l’apprentissage de l’utilisation de ses méthodes, peut bénéficier à tous les développeurs.


Mon espoir, sans doute naïf et arrogant, est que cela pourrait être une contribution pour résoudre en partie la “crise” du logiciel, ces problèmes permanents de qualité rencontrés par notre industrie depuis 40 ans[^8].




[^1]: On la qualifie de “restreinte” car elle exclut la prise en compte de la gravitation, sujet qui sera abordé par Einstein plus tard, en 1915, à travers la relativité dite générale.
[^2]: Pour une description des expériences, voir [Wikipedia](https://fr.wikipedia.org/wiki/Exp%C3%A9rience_de_Michelson_et_Morley). 
[^3]: Pour une version française de l’article, voir par exemple [cette traduction](http://etienneklein.fr/wp-content/uploads/2016/01/De-l%C3%A9lectrodynamique-des-corps-en-mouvement.pdf).
[^4]: Attribué à Richard Feynman: 

    *"Understand, don’t memorize. Lean principles, not fomulas."*

[^5]: D'après [James Clear](https://jamesclear.com/first-principles): 

    *"In practice, you don’t have to simplify every problem down to the atomic level to get the benefits of first principles thinking. You just need to go one or two levels deeper than most people."*

[^6]: Désigne le livre “Design Patterns - Elements of reusable Object-Oriented software” par E. Gamma, R. Helm, R. Johnson et J. Vlissides en 1994.
[^7]: Dans l'ordre:

    - **SOLID** : désigne 5 principes de conception en programmation orientée objet, formulée par Robert C. Martin : Single responsibility principle, Open / Closed principle, Liskov susbtitution principle, Interface segregation principle, Dependency inversion principle.
    
    - **KISS**: *Keep it simple, stupid*
    
    - **DRY**: *Don’t Repeat Yourself*

[^8]: Vous remarquerez que, contrairement à A. Einstein, je fais pas mal de notes de bas de page.
]]></description><link>https://remihuguet.dev/blog/2021/06/12/relativite-logiciel-principes</link><guid isPermaLink="true">https://remihuguet.dev/blog/2021/06/12/relativite-logiciel-principes</guid><pubDate>Sat, 12 Jun 2021 00:00:00 GMT</pubDate></item><item><title><![CDATA[La newsletter 1 - Un manifeste de trop ?]]></title><description><![CDATA[Où il est question du TDD Manifesto et des quelques contenus qui m'ont plus. - 
Si vous voulez recevoir la newsletter, [c'est par ici](https://landing.mailerlite.com/webforms/landing/f3t1z4). 
J'envoie au plus une édition par semaine, probablement beaucoup moins.


## L'édito - Un manifeste de trop ? 


Alors que je me demandai bien ce que j’allais pouvoir vous raconter dans première newsletter, la réponse est venue, comme souvent, grâce un à un peu de procrastination.

Il se trouve que s'est tenu le 10 juillet la première conférence consacrée au Test-Driven Development (http://tddconf.com/).
Durant cette conférence, a été annoncée la publication d’un Manifeste TDD, que vous pourrez lire ici : https://tddmanifesto.com/.
Je vais vous avouer quelque chose, je n’ai pu m’empêcher d’avoir une petite grimace en lisant cette nouvelle. Encore un manifeste ? Pourquoi ? Est-ce vraiment une bonne idée ?


Dans l’histoire des manifestes logiciels, nous avons eu le [Manifesto for Agile Software Development](https://agilemanifesto.org/) en 2001.
Comme cela ne suffisait pas, et en partie pour remettre l’excellence technique au cœur de l’agilité, il y a eu le [Manifesto for Software Craftsmanship](http://manifesto.softwarecraftsmanship.org/), en 2009.


Écrire un manifeste semble devenir la voie privilégiée pour tenter de normaliser et diffuser une pratique.


L’intérêt de l’idée de l’agilité ne réside pas dans l’utilisation du manifeste, ou de ses principes, ni même dans leur respect.
Sa force est qu’elle est la manifestation concrète de pourquoi nous faisons des logiciels : pour répondre au besoin d’un utilisateur.


Le software craftsmanhip manifesto est la concrétisation du fait que l’épanouissement de ceux qui font du logiciel est aussi important que pourquoi nous faisons du logiciel.
Il s’agit de l’expression d’un idéal de maîtrise de notre art.
Ces deux idées sont importantes, et deviennent de plus en plus prégnantes dans l’industrie.


Pour autant, cela vient avec un prix.


À partir du moment où vous écrivez un manifeste, vous mettez en place les bases d’une nouvelle église.
Certains se feront gardiens des écritures, et vont s’assurer de leur diffusion et de leur respect.
Le respect littéral du manifeste peut devenir plus important que l’esprit de l’idée qu’il porte.


Une fois le manifeste TDD écrit, viendront inévitablement les querelles d’écoles, la défense du dogme, et la volonté prosélyte de diffuser la bonne parole, sasn considération pour l’esprit de la pratique.


TDD est sans doute la pratique qui a le plus influencé mon évolution en tant que développeur.
C’est un outil que je considère comme fondamental, structurant, et qui mérite d’être plus largement diffusé.
A-t-on besoin d’un manifeste, au risque de conforter ceux qui défendent une vision puritaine de la pratique ?
A-t-on besoin de cet outil pour diffuser la pratique, en faire sa pédagogie ou expliquer sa valeur ?


Plus important encore, avait-on besoin d’écrire un manifeste pour cela ?
Quel sera le prochain manifeste ?
Le pair “programming manifesto” ?
Le “continuous integration manifesto” ?

L’avenir nous le dira.


## Les liens de la veille

### [La dette technique : une supercherie mythologique pour galériens de l’IT](https://waxzce.medium.com/la-dette-technique-une-supercherie-mythologique-pour-gal%C3%A9riens-de-lit-7ed0dfbf39c7)

Plus j’y réfléchis, plus je considère que la dette technique est, la plupart du temps, une arnaque.
Laissez-moi le formuler simplement : d'après mon expérience, la plupart de ce que les développeurs et leurs managers appellent la dette technique n'est que du logiciel pourri.
Un logiciel pourri apparaît de deux manières : il était pourri depuis le début, ou il est lentement devenu pourri par manque d'investissement et de discipline.


Quentin Adam dit plus ou moins la même chose dans cet article, d'un point de vue financier, très bien écrit.
À lire si vous voulez mieux comprendre pourquoi la dette technique est un concept toxique à éviter dès maintenant.


### [Discovery – Problem vs. Solution](https://svpg.com/discovery-problem-vs-solution/)

Dans cet article du SVPG, Marty Cagan explique que, lorsque vous considérez l'espace du problème par rapport à l'espace de la solution, sachez que la découverte de produits consiste à travailler dans les deux - probablement plus dans l'espace solution.
Ne séparez pas et n'isolez pas l'espace des problèmes de la gestion des produits et l'espace des solutions de l'ingénierie.
C’est ce que sont les équipes transversales et multi-expertises.


Il me semble que, dans le domaine de "l'ingénierie", Domain Drive Design encourage plus ou moins la même notion.
Il concerne l'espace du problème et de la solution, des interactions et des itérations entre ces espaces - travailler sur une solution changeant votre compréhension du problème.

DDD est un domaine d'ingénierie de produits. Il s'agit de découvrir et de créer des produits, pas seulement de faire de l’ingénierie de logiciel.


### [Farewell to fsync(): 10× faster database tests with Docker](https://pythonspeed.com/articles/faster-db-tests/)

Accélérer l'exécution des tests d’intégration pour une base de données est crucial.
Même avec une architecture propre, vous devez tester votre base de données réelle à certains moments.
C’est mieux si c’est très rapide.


Dans cet article, Itarmar Turner-Trauring propose des méthodes pour accélérer l’exécution des tests avec base de données et Docker, avec Python. Pratique.


### [Does it belong in the application or domain layer?](https://matthiasnoback.nl/2021/02/does-it-belong-in-the-application-or-domain-layer/)

L’un des principes de l’architecture propre est de n’autoriser que des dépendances des couches externes du logicel (entrées - sorties) vers les couches internes, le modèle du domaine étant au coeur.
Il est courant d’avoir une couche intértermédiaire entre le domaine et l’infrastructure, souvent appelée “Application Layer”.


Dans cet article, Matthias Noback explique comment il choisit si un service doit se trouver dans le domaine ou dans la couche application.
Il complète pour cela le principe ci-dessus avec un autre: une couche ne devrait dépendre que de la première couche interne.


### [Stop using tools as if they were solutions](https://www.thedigitalcatonline.com/blog/2021/05/25/stop-using-tools-as-if-they-were-solutions/)

Dans cet article, Leonardo Giordani expose, à travers l’exemple du test technique, comment nous favorisons une culture du code centrée autour des outils.
Or, comme il l’explique très bien, les outils ne sont pas des solutions, et c’est bien sur les problèmes que nous devrions travailler.


>We all make the same mistake here: we push (or at least accept) a culture in which we teach and learn tools as go-to solutions without teaching to identify and face problems.]]></description><link>https://remihuguet.dev/blog/2021/07/14/newsletter-1</link><guid isPermaLink="true">https://remihuguet.dev/blog/2021/07/14/newsletter-1</guid><pubDate>Wed, 14 Jul 2021 00:00:00 GMT</pubDate></item><item><title><![CDATA[Software Craft (le livre) - Quelques réflexions]]></title><description><![CDATA[Où je note quelques remarques sur le livre Software Craft (Dunod) - 
J'ai commencé la lecture ce week-end du livre ["Software Craft - TDD, Clean code et autres pratiques essentielles"] (https://www.dunod.com/sciences-techniques/software-craft-tdd-clean-code-et-autres-pratiques-essentielles), l'un des rares livres sur les pratiques "craft" en français (non traduit de l'anglais bien entendu...)

Quelques éléments qui m'ont marqué, dès l'avant-propos et le premier chapitre.

## Working code is a low bar.

Cela reste un enjeu difficile à appréhender, que ce soit pour de nombreux développeurs, ou pour les métiers qui gravitent autour du développement. Faire fonctionner un logiciel est rarement un enjeu, et ce n'est qu'une étape dans l'ingénierie.

## Définir le besoin est au moins aussi difficile que d'écrire le code correspondant.

L'activité d'ingénierie logicielle est **principalement** un processus de découverte progressive du besoin, d'où découle la nécessite de processus itératifs, de boucles de feedbacks courtes, etc...

## TDD, le pilier

Parmi les pratiques incontournables, le premier chapitre est consacré à TDD. C'est parfaitement logique. S'il devait rester un incontournable, à la fois pilier et levier pour actionner d'autres méthodologies et techniques, c'est le TDD.

Pourtant, et y compris dans les quelques workshops que j’ai proposés par le passé, TDD est souvent abordé après le "clean code" ou la clean architecture.

Pourquoi ? Parce que TDD est sans doute plus difficile à adopter, il nécessite du temps et une remise en question importante des habitudes.

Malgré tout, commencer par TDD est, in fine, le choix évident.
]]></description><link>https://remihuguet.dev/blog/2023/01/16/software-craft-avant-propos</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/16/software-craft-avant-propos</guid><pubDate>Mon, 16 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Software Craft (le livre) - Quelques réflexions]]></title><description><![CDATA[Où je note quelques remarques sur le livre Software Craft (Dunod) - 
J'ai commencé la lecture ce week-end du livre ["Software Craft - TDD, Clean code et autres pratiques essentielles"] (https://www.dunod.com/sciences-techniques/software-craft-tdd-clean-code-et-autres-pratiques-essentielles), l'un des rares livres sur les pratiques "craft" en français (non traduit de l'anglais bien entendu...)

Quelques éléments qui m'ont marqué, dès l'avant-propos et le premier chapitre.

## Working code is a low bar.

Cela reste un enjeu difficile à appréhender, que ce soit pour de nombreux développeurs, ou pour les métiers qui gravitent autour du développement. Faire fonctionner un logiciel est rarement un enjeu, et ce n'est qu'une étape dans l'ingénierie.

## Définir le besoin est au moins aussi difficile que d'écrire le code correspondant.

L'activité d'ingénierie logicielle est **principalement** un processus de découverte progressive du besoin, d'où découle la nécessite de processus itératifs, de boucles de feedbacks courtes, etc...

## TDD, le pilier

Parmi les pratiques incontournables, le premier chapitre est consacré à TDD. C'est parfaitement logique. S'il devait rester un incontournable, à la fois pilier et levier pour actionner d'autres méthodologies et techniques, c'est le TDD.

Pourtant, et y compris dans les quelques workshops que j’ai proposés par le passé, TDD est souvent abordé après le "clean code" ou la clean architecture.

Pourquoi ? Parce que TDD est sans doute plus difficile à adopter, il nécessite du temps et une remise en question importante des habitudes.

Malgré tout, commencer par TDD est, in fine, le choix évident.
]]></description><link>https://remihuguet.dev/blog/2023/01/17/software-craft-avant-propos</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/17/software-craft-avant-propos</guid><pubDate>Tue, 17 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Pas si simple de pair programmer]]></title><description><![CDATA[Où je partage quelques réflexions sur le pair programming - 
Le pair programming est la pratique du "craft" que j’ai le plus de mal à utiliser, et sur laquelle j’ai le plus de réserves. Ma lecture en cours du livre ["Software Craft - TDD, Clean code et autres pratiques essentielles"] (https://www.dunod.com/sciences-techniques/software-craft-tdd-clean-code-et-autres-pratiques-essentielles) m’a fourni un peu plus matière à réflexion, et a amené quelques échanges intéressants avec mes collègues (_Note : je viens de passer trois jours en compagnie mes collègues de Mee6 en Finlande pour notre "Get together" annuel._).


Mon expérience personnelle du pair programming est pour le moins mitigée. Je ne l’ai jamais vraiment pratiqué régulièrement selon les *règles de l’art*. En fonction des équipes avec lesquelles j’ai travaillé ces dernières années, je l’ai pratiqué, selon les cas, d’occasionnellement à pas du tout, dans des formes dérivées.


Les limites (ou difficultés) que j’ai rencontrées personnellement sont de plusieurs ordres.


Tout d’abord, la pratique est assez épuisante pour moi. Du fait de mon profil, et bien que je l’apprécie dans certaines circonstances et à petite dose, elle me prend énormément d’énergie et s’accompagne généralement d’un peu de frustration.


La pratique nécessite, par définition, beaucoup de synchronicités. Pour des équipes distribuées, habituées à travailler en asynchrone à haute dose, cela peut être difficile à mettre en place. La perte d’asynchronicité notamment peut être ressentie comme une forme de gaspillage.


Les problèmes d’alignement, sur le niveau d’expérience, l’utilisation de pratiques comme TDD par exemple, peuvent également rendre l’exercice difficile, voire très frustrant. Par ailleurs, la pratique nécessite un niveau de sécurité psychologique important entre les binômes, ce qui n’est pas si évident à trouver.


Dans les échanges que j’ai eus, ce sont souvent ces mêmes problèmes qui reviennent, et qui amènent des réticences à essayer d’utiliser la pratique pour régulièrement et de façon structurée.


Pour autant, je reconnais les apports de la pratique, et je pense en comprendre l’objectif de fond : optimiser le flux de l’équipe plutôt qu’optimiser individuellement, ce qui ne conduit pas nécessairement à un optimum local. Le fait qu’elle soit si souvent poussée éveille ma curiosité. Est-ce que je rate quelque chose, ou est-ce que simplement, c’est une pratique complexe à mettre en œuvre ?


Je reste assez sceptique lorsque je vois des assertions prescriptrices sur le sujet (j’ai notamment le souvenir du livre eXtreme Programming de Kent Beck dans ce style). Je peux admettre l'idée que _en théorie_, une équipe délivrera mieux si elle peut pair programmer (voir mob programmer) en permanence. Mais _en pratique_, vous devez faire avec la réalité des équipes, des profils psychologiques, des besoins des uns et des autres.


Comme souvent, il faut probablement rester très contextuel et pragmatique pour utiliser cet outil. Construire un contexte favorable, expérimenter, tenir compte des besoins de tous les membres de l’équipe, former, changer nos habitudes progressivement.


Le chapitre consacré au pair et au mob programming dans ["Software Craft - TDD, Clean code et autres pratiques essentielles"] (https://www.dunod.com/sciences-techniques/software-craft-tdd-clean-code-et-autres-pratiques-essentielles) est d’ailleurs très intéressant de ce point de vue. L’approche des auteurs semble très pragmatique, indique les apports de ces approches, mais aussi les difficultés. De nombreux conseils sont donnés pour conserver une approche bienveillante et tenant compte des besoins de chacun dans l’équipe.
]]></description><link>https://remihuguet.dev/blog/2023/01/21/pair-prog-pas-simple</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/21/pair-prog-pas-simple</guid><pubDate>Sat, 21 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Je n'aime pas trop le lundi matin.]]></title><description><![CDATA[Où je parle du lundi matin - 

Je n’aime pas les lundis. Ou, plus précisément, je n’aime pas un lundi sur deux. Et je redoute presque autant l’autre lundi.


Rien à voir avec le travail. Au contraire, en général, quand j’ai passé un bon week-end, je suis plutôt content de me replonger dans le travail.
J’ai des privilèges incroyables, dont celui de gagner très bien ma vie en faisant un travail qui me stimule, dans d’excellentes conditions. En fait, je suis même peut-être, plus encore maintenant, content de pouvoir me replonger dans le travail ce jour-là.


Le lundi, c’est le jour de changement de garde pour mes deux enfants. Je les pose donc à l’école le matin, je leur fais un câlin et je les laisse partie à l’école. À chaque fois c’est un déchirement. Ne pas les voir pendant une semaine, c’est déjà difficile. C’est encore plus dur parce que la maman et moi ne sommes plus capables de communiquer normalement. C’est le plus dur dans la séparation. Je n’arrive pas à m’y habituer, pas vraiment.


L’autre lundi, c’est le jour où je vais les revoir, après une semaine de séparation. Toute ma journée est rythmée par cet impératif. Je suis partagé entre la joie de les revoir, et l’anxiété de savoir ce qui a bien pu se passer de l’autre côté.


Je n’aime pas trop le lundi matin.
]]></description><link>https://remihuguet.dev/blog/2023/01/09/lundi-matin</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/09/lundi-matin</guid><pubDate>Mon, 09 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Les piliers du craft ?]]></title><description><![CDATA[Où je discute de la structure adoptée dans le livre Software Craft - 
Dans ["Software Craft - TDD, Clean code et autres pratiques essentielles"] (https://www.dunod.com/sciences-techniques/software-craft-tdd-clean-code-et-autres-pratiques-essentielles), les auteurs ont adopté une structure intéressante.


Les premiers chapitres sont consacrés aux techniques incontournables du craft, ce que l'on pourrait appeler les piliers :
- le test driven development
- le clean code
- le behavior driven development
- le pair / mob programming
- les techniques de refactoring
- travailler avec du code legacy


Les chapitres correspondants sont plutôt courts, synthétiques, et donnent les éléments nécessaires pour aborder et démarrer dans chaque sujet. L'ordre également est intéressant en soi.


C'est, à ma connaissance (limitée), la première fois que je vois une présentation aussi synthétique, cohérente et suffisante pour aborder le craft.


Il est bien sûr toujours possible de discuter de la pertinence d'inclure ou non telle ou telle pratique dans ce corpus. À titre personnel, j'aurais ajouté des techniques de base de clean architecture, qui sont nécessaires pour être en mesure d'utiliser à plein le TDD notamment. Mais il faut faire un choix, et je trouve que ce choix est pertinent et a le mérite de donner une vision d'ensemble et des jalons à suivre pour rentrer dans le sujet.




]]></description><link>https://remihuguet.dev/blog/2023/01/25/piliers-du-craft</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/25/piliers-du-craft</guid><pubDate>Wed, 25 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Est-ce qu'on déploie aujourd'hui ?]]></title><description><![CDATA[Où il est question de déploiement le vendredi. - 
Aujourd'hui nous sommes vendredi. Vu que j'ai déjà épuisé l'un de mes marronniers pour la semaine (les estimations), je me suis dit que c'était l'occasion d'en attaquer un autre : alors, on déploie le vendredi ou pas ?


Ce sujet est source d’innombrables mèmes et blagues dans le milieu. Vous connaissez peut-être le site ["est-que qu’on met en prod aujourd’hui] (https://www.estcequonmetenprodaujourdhui.info/), qui répond invariablement le vendredi par un grand... non.


Ne pas déployer le vendredi semble être encore un adage sage, qu'il serait bien avisé de suivre.


De mon côté, je suis très attaché au déploiement continu, ou au moins à ce que les organisations dans lesquelles j’évolue essaient de s’en approcher au maximum. C’est une des pratiques sur lesquelles j’essaye de ne pas céder : les contraintes mises sur le système ne doivent pas nous empêcher, ou nous inciter, à déployer moins souvent. Nous devons trouver d’autres solutions pour réduire les risques liés à des déploiements multiples, souvent plusieurs fois par jour.


Difficile dans ce cadre de dire qu'il ne faut pas déployer le vendredi. Surtout dans le cadre d'un produit très international et orienté utilisateur final comme Mee6.


Il y a pourtant des raisons tout à fait justifiées à ne pas vouloir déployer le vendredi. J'en ai notamment deux en têtes, qu'il faut traiter attentivement.


D'abord, le point de vue de l'ingénierie. S'il y a un problème suite au déploiement le vendredi (en fin de journée bien sûr), qui sera là pour régler les incidents ? C'est d'autant plus vrai dans le contexte de Mee6, avec à la fois une base utilisateur mondiale, et une petite équipe.


Il n'y a pas de réponse facile à ce point. Il convient d'améliorer nos pratiques - cette crainte provient d'abord de l'habitude de livrer des bugs - ce qui permet de réduire les occurrences. Mais personne n'est à l'abri d'une mauvaise surprise. Disposer d'un système très simple de rollback en cas de problème permet de réduire le risque. Au pire, on revient à la version précédente, et on s'attaque au problème. Finalement, si le risque est trop grand pour telle ou telle nouvelle fonctionnalité, et bien, parfois, tant pis... on ne met pas en prod le vendredi.


La deuxième raison est liée au support client. Déployer une nouvelle fonctionnalité un vendredi, pour un produit comme Mee6, c'est avoir un pic d'activité pour le support et les personnes qui sont en lien direct avec la communauté d'utilisateurs tout le week-end. Ce n'est pas le bon moment, cela peut se comprendre. Dans ce cas, la solution qui me semble la plus adaptée est encore de séparer la release aux utilisateurs du déploiement, avec un système de feature flag. L'ingénierie peut continuer son déploiement continu, et le support maîtriser l'ouverture d'une nouvelle fonctionnalité à la horde des utilisateurs.


Alors, est-ce qu'on met en prod aujourd'hui ?
]]></description><link>https://remihuguet.dev/blog/2023/01/06/deploiement-vendredi</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/06/deploiement-vendredi</guid><pubDate>Fri, 06 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Résilience logicielle et slack time]]></title><description><![CDATA[Où je partage une réflexion suite à la lecture d'un article sur la résilience - 


Je lisais récemment cet [excellent article] (https://jessitron.com/2023/01/16/resilience-and-waste-in-software-teams/) de [Jessica Joy Kerr] (https://twitter.com/jessitron), sur la résilience et la place du travail imprévu dans les équipes logicielles.


La thèse de Jessica est simple : les systèmes résilients le sont parce qu'ils ont du mou (oui, c'est la meilleure traduction que j'ai trouvée de _slack_). Le mou, c'est ce qui semble être du gaspillage quand tout va bien, ou que l'on cherche à tout optimiser, mais qui empêche un incident de devenir une catastrophe industrielle.


Dans une équipe logicielle, le mou permet de faire toutes ces tâches impossibles à justifier et à prioriser, qui concernent la qualité logicielle dans son acception la plus large possible. Sans ce mou, dans un système trop rigide où toute tâche doit être justifiée, priorisée et optimisée, le risque est grand que le logiciel perde la résilience.


À être excessivement concentré sur l'impact, le ROI, la valeur, où toute autre chose mesurable - et dont la poursuite est parfaitement indispensable par ailleurs - on se prépare des lendemains très douloureux.


Laisser l'autonomie aux développeurs de travailler sur des tâches non justifiables - ou difficilement - au fil de l'eau, en faisant confiance à leur jugement, c'est un excellent moyen de bâtir un système résilient (_l'auteur de l'article à une règle à la louche de 20% de slack time_).
]]></description><link>https://remihuguet.dev/blog/2023/01/26/resilience</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/26/resilience</guid><pubDate>Thu, 26 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Apprenez TDD]]></title><description><![CDATA[Où je répéte pourquoi vous devriez apprendre TDD - 

De tout l'arsenal du "craft", le Test Driven Development (TDD donc) est l'une des pratiques les plus difficiles à appréhender, possiblement la moins comprise, et pourtant la plus intéressante à utiliser.


Je ne connais pas de développeur pour qui passer au TDD ait été naturel. Pour beaucoup de professionnels, dont je suis, qui ont passé un peu de temps dans l'industrie, apprendre à utiliser TDD est difficile.
Il faut désapprendre avant d’apprendre, se débarrasser de réflexes et d’habitudes de travail bien implantées. Comme souvent, durant un tel processus d’apprentissage, on passe par une phase très désagréable durant laquelle on a l’impression de ne plus savoir rien faire.


C'est une pratique mal comprise, parce que ce n'est pas une pratique de test, mais une pratique de conception. La fonction première du TDD est de nous permettre de faire de la conception logicielle itérative, informée, en s'appuyant sur une boucle de feedback très courte. Une fois qu'on l'a assimilée, elle nous donne un superpouvoir : c'est une méthodologie tout terrain, parfaite notamment quand on ne sait pas par où commencer. J'ai notamment vécu l'expérience de réussir un test technique, que je ne savais par quel bout prendre, grâce à cette technique.


Paradoxalement, même si ce n'est pas une pratique de tests, vous pouvez facilement vous appuyer dessus, mettre un peu de test-first ou test-after dans votre méthodologie, et obtenir à peu d'efforts un bon niveau de couverture de tests.


C'est peut-être la plus intéressante, parce qu'elle ne nécessite pas d'obtenir un accord de l'équipe, de la direction, ou de qui que ce soit pour être pratiquée. Bien sûr, c'est mieux si on peut évoluer dans un environnement de travail homogène. C'est d'abord une discipline individuelle, que vous pouvez toujours pratiquer.


Si j'ai un seul conseil à donner à un développeur pour progresser, c'est d'apprendre TDD.
]]></description><link>https://remihuguet.dev/blog/2023/01/11/apprenez-tdd</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/11/apprenez-tdd</guid><pubDate>Wed, 11 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Vous n'avez pas besoin de savoir si vous pratiquez le VRAI xDD]]></title><description><![CDATA[Où je râle (un peu) sur un travers du milieu logiciel - 
J’ai vu aujourd’hui une discussion sur Linkedin autour du BDD (Behavior Driven Development), et notamment sur ce que seraient le vrai BDD et le faux BDD, ou plus précisément, quelle en serait la définition exacte.

Ce qui est intéressant, c’est que c’est quelque chose de récurrent, qui se produit souvent dans le milieu : discuter de savoir quel est le VRAI _remplacer par n’importe quelle pratique logicielle_.
Comme si cela apportait quoi que ce soit en pratique, ou que cela avait la moindre importance.


Personnellement, je me nourris des idées, pratiques et concepts évangélisés par les uns et les autres.


Je me fais mon opinion, expérimente dans mon contexte, adopte telle pratique ou écarte telle autre, adapte à ma situation, etc...


Je me fiche de savoir ce qu’est le "VRAI" TDD, DDD, BDD, clean code, craft, clean architecture, communisme, libéralisme, whatever.


En pratique, ça ne m’apporte rien de savoir que les pratiques que j’utilise sont tamponnées par je ne sais quelle autorité ou pas.
Surtout quand les termes en questions sont suffisamment génériques et imprécis, comme c’est presque toujours le cas de nos pratiques d’ingénierie.



En physique, la plupart de ces questions d’attributions sont réglées par un moyen simple. Très souvent, une hypothèse ou un modèle donné sont nommés d’après les auteurs de l’article publié (_tout du moins, dans la science contemporaine_).
On parle du boson de Higgs, pas du boson de masse, et du mécanisme de Brout-Englert-Higgs-Hagen-Guralnik-Kibble. On ne parle pas du VRAI modèle de "champ moyen relativiste de la matière nucléaire". Il existe, par exemple, le modèle de Walecka et le modèle de Nambu-Jona-Lasinio. On ne parle pas du paradoxe d’intrication quantique, mais du paradoxe Einstein-Podolsky-Rosen.

Si vous tenez absolument à être précis (quoi que je doute que cela apporte quoi que ce soit), je vous conseille donc d’accoler le nom des auteurs auquel vous faites référence la prochaine fois que vous voulez définir le VRAI trucmuche.
]]></description><link>https://remihuguet.dev/blog/2023/01/31/vrai-ou-pas</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/31/vrai-ou-pas</guid><pubDate>Tue, 31 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Personne ne se plaint!]]></title><description><![CDATA[Où je me pose la question du côut réel de la non qualité - 
Qu’est le coût caché de la non-qualité ?


J'avais une discussion récemment avec un collègue, concernant la correction d'erreurs remontées dans notre système de capture d'exceptions (Sentry, pour ne pas le nommer).


Nous avons dans le système une baseline de problèmes, qui remontent très régulièrement, en quantité, depuis longtemps. C'est devenu un sujet de plaisanterie entre nous. Un jour, on va les corriger.


Parmi ces erreurs, il y en a qui sont inévitables (systèmes distribués, intégration à des systèmes tiers). Tout au plus devrait-on les superviser différemment, voire les gérer comme de l'information et non comme une erreur.


Nous en avons également qui sont de véritables erreurs. Nous savons que certains de nos services dysfonctionnent régulièrement. Cela peut concerner un très faible pourcentage d'utilisateurs (ou d'utilisations), voire dans certains cas, des pourcentages pas si insignifiants.


Lors de cette conversation impromptue, j'ai raconté comment je gérais ces exceptions sur mon périmètre. Je monitore, et je consacre un peu de temps régulièrement à résoudre les problèmes qui ont le plus d'occurrences. J'ai indiqué avoir pensé à demander à chaque équipe de faire de même sur son périmètre.


Mon collègue m'a répondu que les développeurs essayent. Mais que, bien souvent, ces résolutions ne pas prioriser si personne ne se plaint (des utilisateurs, s'entend). Cela se comprend. Nous avons une grosse communauté d'utilisateurs, qui communiquent beaucoup avec notre support. En général, on peut supposer que si un problème est réellement gênant, cela nous sera remonté.


Mais si ça n'est pas le cas ? Combien d'utilisateurs fâchés nous quittent-ils sans remonter leur mécontentement, parce qu'une commande n'a pas fonctionné pour eux, ou que le site web a été trop long à charger ce jour-là ? Combien de revenu perdu ? Est-on bien certain que nos modèles et nos outils de mesure nous permettraient de détecter ces pertes, s'ils existent ?


Il est assez connu que la non-qualité a un impact sur le revenu, en matière de performance web par exemple. Le savoir en tant que donnée générale de notre industrie est une chose. Être capable de mesurer ces coûts dans notre contexte précis en est une autre.


Alors je me pose la question : quel est le coût, réel, de la non-qualité ?
]]></description><link>https://remihuguet.dev/blog/2023/01/10/plainte-non-qualite</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/10/plainte-non-qualite</guid><pubDate>Tue, 10 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Get together]]></title><description><![CDATA[Où je pose quelques réflexions sur l'apport des rencontres physiques pour une équipe distribuée - 
La semaine dernière, nous avons passé trois jours en Finlande avec l'ensemble de l'équipe de [Mee6] (https://mee6.xyz). Nous appelons cet événement le "Get together", il a lieu tous les ans, et nous n'y travaillons pas. C'est un moment dédié uniquement à des activités de découverte du lieu où l'on se trouve, et à des moments de fun entre nous.


Notre équipe est largement distribuée. Une partie de l'équipe tech, produit et support se trouvent à Paris ou en région parisienne, et à peu près l'autre moitié est dispersée en France, mais aussi dans différents pays européens, en Australie et aux Etats-Unis. Même les collègues parisiens de l'équipe tech travaillent essentiellement en remote.


Je suis un partisan du travail à distance depuis longtemps. Lorsque j'ai démarré une activité freelance début 2020, mon premier objectif était de travailler à distance. Je ne suis pas, habituellement, un grand amateur des événements "corporate" et autres "team building".


Ici pourtant, c'est un événement très important pour l'équipe, et qui est fait, je crois de la bonne façon. Pas de "corporate" malaisant, pas d'obligations. Juste le plaisir de se retrouver pour des moments de partage, de plaisir, et de se découvrir un peu plus personnellement. Tout cela contribue à l'équilibre de l'équipe et au plaisir que nous avons de travailler ensemble. Sans cet événement, nous n'aurions très certainement pas la même dynamique.


Je ne pense pas que *cette* façon de faire particulière soit adapté à toutes les organisations distribuées et à distance. Mais il me semble nécessaire de trouver un mécanisme qui permette de limiter les carences du travail à distance pour développer des relations interpersonnelles saines.
]]></description><link>https://remihuguet.dev/blog/2023/01/22/get-together</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/22/get-together</guid><pubDate>Sun, 22 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[IA, TDD et pair programming - kata game of life]]></title><description><![CDATA[Où je fais un kata game of life en TDD et en pair programming avec l'IA - 
Le week-end du 10 novembre, c'était Global Day Of Code Retreat. Impossible pour moi d’y participer : j’ai beaucoup trop d’enfants et d’occupations 😅.

Mais le 11 novembre, j’avais un peu de temps, et j’avais envie d’expérimenter un truc qui me trottait en tête depuis un moment : faire du pair programming en TDD avec une IA générative.

💡 **Setup**

- Kata _Game of Life_
- Cursor + Claude-Sonnet 3.5 (avec un abonnement pro, les quotas gratuits n’ont pas tenu longtemps)
- Python
- Contraintes strictes : je pilote, l’IA code. Objectif : respecter au maximum les principes TDD (baby steps, fake it, refactoring systématique).

💡 **Déroulé**  
Après avoir préparé l’environnement Python, j’ai démarré avec Composer pour analyser le README et poser les contraintes. On a défini une TODO list, puis attaqué les premiers items en TDD.

💡 **Retour d’expérience**  
✅ **Le résultat est plutôt bon.** On est allés au bout du kata et le code est fonctionnel.  
✅ **L’IA force à être ultra-clair dans nos exigences.** Il faut analyser, expliciter, reformuler… et tout ça par écrit. Un excellent exercice.  
✅ **Grosse nécessité de cadrage.** L’IA a tendance à partir en roue libre et à proposer des solutions fonctionnelles mais médiocres. Sans recadrage constant (baby steps, petits tests, implémentations minimales), ça devient vite du spaghetti code.  
✅ **Qualité du code : ça dépend…** Si on ne sait pas où on va en termes d’architecture et de maintenabilité, le code dégénère vite. Sans refactoring systématique, on accumule rapidement des défauts qui rendent le tout ingérable (même pour l’IA).  
✅ **Elle ne sait pas toujours résoudre ses propres bugs.** À plusieurs reprises, elle s’est enfermée dans une boucle où elle corrigeait un test… sans vraiment le corriger. Il a fallu intervenir manuellement pour en sortir.  
✅ **Erreurs basiques.** Import manquants, réintroduction de bugs précédemment corrigés… des petites fautes qui peuvent ralentir la progression.  
✅ **Productivité ?** Difficile à dire si j’aurais été plus rapide seul. Mais il y a une vraie plus-value à déléguer à l’IA tout ce qui est “boring” ou répétitif, pour se concentrer sur le fond : les bons test cases, l’amélioration du design…

💡 **Conclusion**  

Ce n'est qu'un kata, et un kata est assez peu représentatif de notre quotidien.

Mais j'ai apprécié l'exercice, et avec mon expérience, je me sens en contrôle. L'outil m'aide, il ne me domine pas.

Mais je sens aussi que cela pourrait être assez facilement l'inverse. Comment gérer un contexte technique que je ne maîtrise pas ? Un contexte métier qui n'est pas clair pour moi ? Si je n'ai pas d'idées claires sur l'architecture ou les exigences de qualité sur le code produit ? 

---

Publié sur Linkedin https://www.linkedin.com/posts/remihuguet_quand-je-fais-un-kata-en-pair-programming-activity-7295705764273287169-f8e7]]></description><link>https://remihuguet.dev/blog/2025/02/07/game-of-life-cursor</link><guid isPermaLink="true">https://remihuguet.dev/blog/2025/02/07/game-of-life-cursor</guid><pubDate>Fri, 07 Feb 2025 00:00:00 GMT</pubDate></item><item><title><![CDATA[No title]]></title><description><![CDATA[undefined - Il n’est pas possible de lancer rapidement un logiciel et  d’écrire des tests automatisés, encore moins utiliser test-driven development. 

L'écriture de tests automatisés, ou mieux l'utilisation de TDD, c'est un peu le niveau minimum pour assurer de façon fiable la qualité pour un logiciel, en particulier sur le long terme.

L’idée, très répandue est que, pour faire de la qualité, cela prend nécessairement plus de temps. C’est le triangle Périmètre - Coût - Délais, avec la qualité comme variable d’ajustement implicite et non dite au milieu. 

Trivialement, dans le lancement de produit ou les startups, on va faire "vite et sale": on va prioriser la vitesse de déploiement sur la qualité du code.

Cela ressemble à un choix rationnel. Du point de vue des décideurs non développeurs, cela paraît naturel d'avoir un arbitrage à faire entre vite et bien. 

De nombreux développeurs défendent cette idée: je peux faire vite, ou bien, mais pas les deux.

Pourtant, nous sommes nombreux dans le métier à défendre une idée contre-intuitive. Non seulement on peut faire vite et bien, mais on va plus vite en faisant bien. Pas seulement à moyen ou long terme. A très court terme.

Il n'y a plus grand monde pour contester qu'une codebase saine et évolutive comporte des tests automatisés. Le premier facteur de qualité, c'est l'écriture de tests automatisés.

L'utilisation de TDD permet de créer une suite de tests peu coûteuses qui va améliorer la qualité du logiciel et de la codebase. La discipline TDD oblige à une conception minimaliste, qui va éviter d'écrire du code superflu. Elle permet de concevoir un code plus simple, plus évolutif et plus maintenable, car couvert par une suite de tests de non-régression.

Encore faut-il maîtriser la pratique, et l'avoir suffisamment travaillée pour en tirer les bénéfices. Cela implique de maîtriser d'autres compétences liées, qui ne sont pas simples à acquérir.

Sans maîtrise de ces compétences, il est plus coûteux de produire du logiciel de qualité. 

En maîtrisant ces compétences, on fait mieux, plus vite.

Vous souhaitez travailler avec quel développeur, celui pour qui cela prend plus de temps de faire de la qualité ou celui qui va plus vite en faisant de la qualité ? 


]]></description><link>https://remihuguet.dev/blog/Invalid%20date/Invalid%20date/Invalid%20date/slug</link><guid isPermaLink="true">https://remihuguet.dev/blog/Invalid%20date/Invalid%20date/Invalid%20date/slug</guid></item><item><title><![CDATA[Un archétype des problèmes rencontrés par les équipes 'agile']]></title><description><![CDATA[Où il est question d'un équipe produit typique et de ses problèmes. - 
Tu as une équipe produit qui grossit, tu as tout bien fait en mode "agile" pour organiser le travail, et pourtant ça ne fonctionne pas ? Toujours plus de bugs à chaque livraison ? Je te donne quelques idées classiques de pistes d'amélioration.

Tu as une équipe produit d'environ 20 personnes. Tu as adopté l'organisation en "feature teams", parce que Spotify, tu as mis dans chaque team un QA et un PO (parce que Agile). Tu as aussi mis un lead dev, parce que c'est quand même rassurant d'avoir quelqu'un qui prend les décisions importantes.

Tu as disons 3 teams, et pour bien faire, tu as mis un ou deux QA en transverse, qui sont chargés de valider tout ce qui part en prod et faire de la non-régression.

Tu fais des sprints de deux semaines, avec release au même rythme, et tu suis bien toutes les cérémonies Agile : daily, sprint planning, rétro, démo, (boulot, dodo...). Tu payes même Jira / Confluence pour avoir l'outil "agile" par excellence.

Et pourtant, ça ne fonctionne pas :

- bugs et régressions à chaque nouvelle version
- livraisons douloureuses
- comment gérer les sujets transverses ?
- ...

Voilà quelques pistes pour sortir de cette situation.

✅ Réduis la QA, responsabilise et accompagne les équipes.

Les QA ne devraient pas faire du quality control, en tout cas le moins possible. Tes QA qui valident tout, ça envoie le signal à tous les autres membres de l'équipe qu'ils ne sont pas responsables de la qualité.

Chaque team est responsable de ce qu'elle livre, et chaque développeur également.

Responsabilité et ownership.

Bien sûr, il faut accompagner l'équipe sur la montée en compétences et la mise en place des pratiques qui vont bien : tests automatisés, TDD, pair programming, ...

🔃 Casse les sprints et itère plus vite

Tes livraisons sont douloureuses ? Livre plus souvent. Tous les jours. Plusieurs fois par jour. Dès qu'un incrément de valeur est livrable, livre.

Remets à plat ton organisation agile. Casse tout, et remets en place brique par brique ce dont tu as vraiment besoin et quand tu en as besoin : daily, rétro, ...

Commence par mettre en place un kanban, avec une limite "Work in progress" très basse.

Au lieu de faire du sprint planning, apprenez à découper toujours plus fin pour avoir le plus petit incrément possible de valeur livrable (ou permettant d'apprendre quelque chose).

Apprenez à prioriser de façon simple : une liste ordonnée. Une priorité à la fois.

🟢 Revois ton organisation d'équipe

Utilise les outils du Domain-Driven Design stratégique pour comprendre la structuration de ton métier, aligner ton organisation dessus, et gérer les dépendances entre équipes.

🚫 Et puis arrête ton abonnement Jira / Confluence 🙃

---

Publié sur Linkedin https://www.linkedin.com/posts/remihuguet_tu-as-une-%C3%A9quipe-produit-qui-grossit-tu-activity-7297517714179321856-22_R
]]></description><link>https://remihuguet.dev/blog/2025/02/17/problems-agile</link><guid isPermaLink="true">https://remihuguet.dev/blog/2025/02/17/problems-agile</guid><pubDate>Mon, 17 Feb 2025 00:00:00 GMT</pubDate></item><item><title><![CDATA[Un mois avec les stoïciens]]></title><description><![CDATA[Où il est question de mon mois de janvier avec les stoïciens.. - 
Voilà un mois que j'ai commencé à lire Daily stoic.

Une petite dose de philosophie stoïque chaque jour.

Qu'est-ce que je retiens de ce mois de Janvier ?


## Clarté

C'est le thème du mois, et c'est fondamental. 

Avoir de la clarté sur ce qui compte pour nous, ce vers quoi l'on veut tendre, ce qui est sous notre contrôle et ce qui ne l'est pas, ... c'est capital.

Ca tombe bien, c'est un des sujets les plus difficile pour moi 😅

Quels sont les idées que je retiens et que j'emmène avec moi pour la suite:

- prendre le temps d'obtenir de la clarté sur qui je suis, et ce qui m'anime, et ce que je recherche (intentions) [[Have you taken the time to get clarity about who you are and what you stand for ?]]
- lâcher prise sur le passé. Nous devons seulement démarrer [[Let go of the past. We must only begin. Believe me and you will see.]]
- être sans pitié avec ce qui ne compte pas pour moi [[Be ruthless to the things that don't matter]]
- la connaissance permet d'être libre [[Knowledge - self-knowledge in particular - is freedom]]
- prendre conscience de ses addictions
- avoir de la clarté sur ce qui est en mon contrôle
- "keep it simple", se concentrer sur ce que l'on a à faire, et trouver de la clarté dans le fait faire son travail chaque jour
- lâcher prise sur la FOMO. On a pas besoin de s'intéresser à tout. I don't care

]]></description><link>https://remihuguet.dev/blog/2025/02/18/janvier-stoic</link><guid isPermaLink="true">https://remihuguet.dev/blog/2025/02/18/janvier-stoic</guid><pubDate>Tue, 18 Feb 2025 00:00:00 GMT</pubDate></item><item><title><![CDATA[Le grand remplacement ?]]></title><description><![CDATA[Où il est question de l'idée du grand remplacement des devs par des IA... - 
La projection que les IA génératives vont remplacer les développeurs est basée sur deux hypothèses implicites sur la création de produits:

- la productivité logicielle consiste à jeter contre le mur le plus de code le plus vite possible
- la qualité d'un produit se mesure au nombre de features

Deux idées depuis bien longtemps répandues dans le milieu, il me semble largement fausses, et à l'origine de bien des crash industriels, mauvais produits et problèmes récurrents de qualité que l'on connaît tous.

Il y a déjà et il y aura probablement beaucoup d'usages intéressants des IA génératives dans la création de produit logiciels, mais cette prédiction là me semble très hasardeuse.
]]></description><link>https://remihuguet.dev/blog/2025/02/18/ai-remplacement-devs</link><guid isPermaLink="true">https://remihuguet.dev/blog/2025/02/18/ai-remplacement-devs</guid><pubDate>Tue, 18 Feb 2025 00:00:00 GMT</pubDate></item><item><title><![CDATA[Développement zéro bug]]></title><description><![CDATA[Où je râle (un peu) sur notre niveau d'exigence - > Si vous faites du développement logiciel, vous ferez des bugs.



> Un logiciel qui n'a pas de bug est un logiciel qui ne change pas.



> Corriger un bug peut provoquer d'autres bugs, alors il ne faut pas forcément se précipiter pour le faire.



> Les bugs sont inévitables. C'est normal de corriger de nombreux bugs après avoir fait une nouvelle fonctionnalité.



J'entends régulièrement ce genre de phrase, où une forme plus ou moins proche.
Je peux difficilement clamer haut et fort que ces assertions sont fausses.


Effectivement, personne de raisonnable dans notre industrie ne peut prétendre produire du logiciel **zéro bug**.


Pourtant ces phrases me gênent. Je connais le niveau moyen de qualité produit dans les équipes où je suis passé. Je vois, en tant qu'utilisateur, le niveau moyen des applications que j'utilise tous les jours. Je sais que, dans la majorité des contextes, nous pourrions éviter 80 % des bugs en adoptant quelques pratiques.



Je suis gêné donc quand j'entends ces phrases. Elles montrent une forme d'acceptation de la médiocrité moyenne des logiciels que nous utilisons tous les jours, et ce que nous produisons.



Nous pouvons faire mieux. Nous devrions avoir l'ambition de progresser, pas simplement faire toujours plus, mais faire mieux.
]]></description><link>https://remihuguet.dev/blog/2023/01/12/zero-bug</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/12/zero-bug</guid><pubDate>Thu, 12 Jan 2023 00:00:00 GMT</pubDate></item><item><title><![CDATA[Un chiffre, c'est mieux que rien]]></title><description><![CDATA[Où je trouve une parabole sur l'obsession des chiffres en amour et dans le logiciel - Je lisais un article ce week-end ([celui ci, payant] (https://www.courrierinternational.com/article/la-pilule-philosophique-grace-au-tableur-excel-ils-mettent-de-l-ordre-dans-leurs-relations-amoureuses)), qui m'a évoqué quelque chose.

Cet article parle des gens qui essayent d'optimiser leur vie amoureuse à coups de tableur Excel.

Petit extrait savoureux :

> Cet utilisateur a entré dans le tableur une liste de 15 critères classés en fonction de ses goûts et de ses besoins. Un exercice > hautement subjectif, soit dit en passant. Et lorsque la journaliste de The Economist le lui fait remarquer, sa réponse est sans > appel :
>
>    “Une estimation chiffrée sera toujours mieux que rien.”



Je croise cette idée très souvent, y compris (et surtout) dans le cadre professionnel. J'ai régulièrement entendu très exactement cette phrase sur un sujet logiciel (je vous laisse deviner...)

Je la trouve dangereuse. Cette obsession pseudoscientifique des chiffres sert essentiellement à se rassurer à coups de rationalité discount. Il est dangereux de manier les chiffres, les datas, les métriques, sans avoir des cadres conceptuels, des modèles prédictifs, des cadres d'interprétations bien définis. Un chiffre n'est rien, n'a aucune signification.

Nous avons d'autant plus tendance à leur attribuer trop d'importance dans le logiciel parce que c'est une discipline technique, voire qui semble scientifique.

Parfois, il vaut mieux aucun chiffre qu'un chiffre arbitraire.

Je vous laisse apprécier la suite :

> Jacob, c’est le nom de ce fondu d’Excel, évalue ses rencontres en mettant une note pour chaque critère puis le multiplie par un coefficient spécifique, ensuite, il les additionne et obtient une note finale de 0 à 10. Un chiffre qu’il juge fiable, car il élimine de l’équation les émotions et autres faiblesses de l’amour. Mais au bout du compte, il a eu beau faire appel à toutes les fonctionnalités d’Excel, Jacob n’a pas réussi à départager les deux femmes les mieux notées.


C'est une parabole 😇
]]></description><link>https://remihuguet.dev/blog/2023/01/15/chiffre</link><guid isPermaLink="true">https://remihuguet.dev/blog/2023/01/15/chiffre</guid><pubDate>Sun, 15 Jan 2023 00:00:00 GMT</pubDate></item></channel></rss>