Voici dix conseils. J'aurais aimé que quelqu'un me les donne il y a 15 ans, comme étudiant et comme développeur. Chacun paraît évident à la lecture. Il m'a fallu des années pour mettre chacun en pratique.

Pourquoi apprendre à apprendre avant tout le reste ?

Le premier conseil : apprenez à apprendre vite. Il vient en premier pour une raison. Les langages, les frameworks et les outils changent plus vite que n'importe quel plan de carrière. La compétence qui survit à ces changements, c'est la boucle : essayer, mesurer, corriger, et réessayer. Apprendre, mesurer, désapprendre.

The Pragmatic Programmer, de David Thomas et Andrew Hunt, décrit vos connaissances comme un portefeuille qui demande des investissements réguliers. L'image est utile. Un portefeuille ne se construit pas par hasard. Vous choisissez ce que vous ajoutez, vous passez en revue ce que vous détenez, et vous lâchez ce qui ne rapporte plus.

Faites de l'apprentissage un créneau dans l'agenda, pas un espoir. Une habitude qui dépend du temps libre disparaît au premier mois chargé. Placez la lecture et la pratique dans la semaine comme vous y placez une réunion.

Que livrer, et comment savoir que vous le comprenez ?

Le deuxième conseil : écrivez du code que vous maîtrisez. Si vous ne le comprenez pas, ne le livrez pas. Le troisième : testez toujours avant de committer. Les deux sont étroitement liés.

Un code que vous ne comprenez pas est un code que vous ne pouvez pas changer sans risque. Quand il casse en pleine nuit, vous débuggez la logique d'un inconnu, et le debug est un tel gaspillage. Le temps part à redécouvrir ce que l'auteur savait déjà.

Les tests sont la première preuve que vous comprenez un changement. En écrire un vous oblige à dire ce que le code doit faire, en une phrase, avant d'écrire le code. Un test que vous n'arrivez pas à écrire vous dit que l'exigence est encore floue. C'est une information utile, et vous l'avez avant que le bug arrive.

Les faits vont dans le sens de cette habitude. Nachiappan Nagappan et ses co-auteurs ont étudié quatre équipes industrielles qui écrivaient leur code en test-first. Leur rapport décrit une baisse des défauts pour le code développé en test-first. La leçon n'est pas que chaque ligne a besoin d'un test. La leçon, c'est que les tests font partie de l'activité de code, pas d'une phase qui vient après.

Toujours tester ne veut pas dire tout tester. Testez le comportement qui compte, les règles et les limites. Laissez le reste au code qui a déjà fait ses preuves.

Le quatrième conseil est celui-ci : si vous ne pouvez pas l'expliquer clairement à un enfant, il faut creuser davantage, et pratiquer encore et encore.

Expliquer est un test de compréhension que vous pouvez faire seul. Quand vous expliquez un concept, vous devez nommer chaque partie et dire pourquoi elle existe. Les trous apparaissent vite. Ils ressemblent à « et là, d'une façon ou d'une autre, ça marche ». Cette phrase est le signal pour retourner au code, à la documentation ou à l'expérience, et réessayer.

Un enfant est un bon public parce qu'un enfant n'accepte pas du jargon à la place d'une raison. Faites ce test sur les idées qui sont les vôtres. Vous n'avez pas besoin d'expliquer chaque ligne d'une librairie avant de l'appeler. Creusez là où est le risque : là où les données circulent, là où l'argent circule, ou là où une panne serait difficile à voir.

Pourquoi les décisions d'ingénierie comptent-elles plus que le code ?

Le cinquième conseil : l'ingénierie, ce sont des décisions qui ont de l'impact, la décision de l'ingénieur face à un problème à résoudre. Le sixième : apprenez l'architecture et lisez des livres.

Frederick Brooks a séparé la difficulté essentielle du logiciel de la difficulté accidentelle. Dans « No Silver Bullet », il soutient que l'essence d'un système, ce sont ses concepts imbriqués. La plus grande partie du reste du travail vient des outils et des représentations que nous choisissons. C'est dans les décisions que vous tranchez : quelle part du travail est essentielle, et quelle part vous ajoutez vous-même.

John Ousterhout exprime la même idée en termes de complexité. Dans A Philosophy of Software Design, il traite la complexité comme le problème central du design, et le travail d'un designer est de la réduire. Chaque décision ajoute de la complexité ou en retire.

Alors nommez la décision à voix haute. Écrivez les options, le trade-off, et la condition qui vous ferait revenir sur le choix. Une décision sur laquelle vous pouvez revenir coûte peu. Une décision que vous ne savez pas expliquer devient un piège pour l'ingénieur suivant.

Lire des livres d'architecture vous donne le vocabulaire pour ces décisions. La lecture seule ne donne pas le jugement. Servez-vous des livres pour nommer ce que vous voyez dans votre propre code, puis changez le code.

Comment faire durer votre code et vos idées ?

Le septième conseil : apprenez à écrire du code pour les humains, pas pour les machines. Une machine accepte presque tout ce qui compile. Le lecteur qui compte est une personne, et en général cette personne, c'est vous, quelques mois plus tard.

Donald Knuth a écrit que l'optimisation prématurée est la racine de tous les maux. Pour un étudiant, le message est simple. Écrivez d'abord du code clair, mesurez-le, et n'optimisez que la partie que la mesure montre lente.

Le huitième conseil : apprenez à partager vos connaissances, et à convaincre avec des exemples. Une connaissance qui vit dans une seule tête est un single point of failure. Les exemples convainquent mieux que les adjectifs. « Le panier est vide, alors le paiement doit échouer » se discute moins facilement que « le flux doit gérer correctement les erreurs ».

John Sonmez traite ce genre de travail dans Soft Skills. La communication, le travail en équipe et les choix de carrière font partie du métier d'ingénieur, ce n'est pas un supplément. Accordez-leur le même soin qu'à votre code.

Le neuvième conseil : apprenez à challenger les idées avec empathie. Challengez le design, pas la personne. Demandez quel problème l'idée résout, et ce qui la ferait échouer. Les gens continuent à proposer des idées quand le challenge porte sur le travail.

Le dixième : pratiquez la co-création. Construisez avec ceux qui utiliseront le résultat. Porter le résultat ensemble diffuse la connaissance, et rend le prochain changement moins effrayant pour tout le monde.

Comment attaquer cette liste dès cette semaine ?

Choisissez un point et pratiquez-le pendant une semaine. Les étapes ci-dessous transforment la liste en habitudes.

  1. Choisissez une compétence que vous ne savez pas encore expliquer à un enfant.
  2. Écrivez une courte explication, puis confrontez-la au code.
  3. Lisez un chapitre d'architecture, puis appliquez une idée à votre propre module.
  4. Écrivez le test avant le changement, et lancez-le avant chaque commit.
  5. Supprimez le code que vous ne savez pas expliquer, ou demandez à quelqu'un de vous l'expliquer.
  6. Écrivez un exemple par exigence avant de commencer à coder.
  7. Faites du pair programming avec un collègue sur une feature cette semaine.
  8. Écrivez une page pour l'équipe qui explique une décision que vous avez prise.
  9. Posez une question qui challenge lors de votre prochaine revue, formulée autour du problème.

Quand ces conseils tournent-ils mal ?

La maîtrise peut tourner à la paralysie. Un ingénieur junior qui refuse de livrer quoi que ce soit tant que chaque ligne n'est pas comprise ne livrera rien. Le remède, c'est le pair programming et la revue, qui transforment du code inconnu en connaissance partagée. La compréhension grandit à l'usage, et c'est en revue que cela se passe.

Le test peut tourner au rituel. Un prototype jetable n'a pas besoin de toute la suite de tests. En revanche, il doit rester loin de la branche principale, et il doit être supprimé ou reconstruit avant de devenir du code de production.

La lecture peut remplacer l'action. Une pile de livres sans pratique vous donne du vocabulaire, pas du jugement. Appliquez chaque idée à du vrai code dans la semaine, ou laissez-la tomber.

Le test de l'enfant peut se cacher derrière la simplicité. Certains concepts sont durs, et une explication simple est un résumé, pas la compréhension complète. Utilisez le test pour trouver les trous, puis acceptez que les trous sont réels.

💡 Continuez à apprendre ! Continuez à lire ! Bon code !

Ressources et bibliographie

Publié d'abord sur LinkedIn : le post d'origine