Le premier algorithme d'Ada Lovelace et ce qu'il nous enseigne aujourd'hui

Pourquoi cela compte encore

Les célèbres « Notes » de Lovelace ressemblent à un pont entre mathématiques et conception logicielle. Même si la machine était en grande partie hypothétique, la façon de penser est familière à quiconque a essayé de faire faire quelque chose de fiable à un ordinateur.

Voici ce que nous garderons à l’esprit au fil de l’article :

• Étapes et structure : découper le travail en opérations ordonnées plutôt qu’en intentions vagues.
• Données et notation : décider quelles valeurs existent, comment elles sont nommées et comment elles circulent.
• Répétition : identifier des motifs et les réutiliser au lieu de réécrire les mêmes actions.
• Vérification : concevoir des procédures vérifiables, pas seulement admirables.
• Documentation : rédiger des explications qui rendent le programme compréhensible pour un lecteur.

À la fin, l’objectif est simple : voir le « premier algorithme » de Lovelace moins comme une pièce de musée et plus comme un modèle précoce de pensée computationnelle qui reflète encore notre manière de concevoir des programmes.

Ada Lovelace, Babbage et la Machine analytique

Augusta Ada King, comtesse de Lovelace — mieux connue comme Ada Lovelace — a grandi au croisement de la poésie et des mathématiques. Sa mère encourageait l’étude rigoureuse, et Ada fit rapidement partie d’un petit cercle de scientifiques et penseurs influents. Elle n’était pas un génie isolé ; c’était une collaboratrice douée qui posait des questions particulièrement claires sur ce que les machines pouvaient signifier, pas seulement ce qu’elles pouvaient faire.

Comment Ada et Babbage se sont rencontrés

Charles Babbage était déjà célèbre pour ses projets de calcul mécanique lorsque Ada le rencontra. Babbage pouvait concevoir du matériel dans sa tête : engrenages, arbres et roues numériques arrangés en système. Ada, de son côté, avait le talent d’expliquer : prendre des idées techniques complexes et les traduire en concepts structurés et communicables.

Leur relation a fonctionné parce que leurs forces étaient différentes. Babbage faisait avancer la vision d’ingénierie ; Ada faisait avancer la vision conceptuelle, en particulier l’idée qu’une machine pouvait suivre une séquence d’opérations conçue à l’avance.

Où se situe la Machine analytique

La Machine analytique de Babbage n’était pas seulement une meilleure calculatrice. Sur le papier, elle décrivait une machine à usage général : capable de stocker des valeurs, d’effectuer des opérations et d’exécuter une procédure planifiée étape par étape. Pensez-y comme à un plan précoce de ce que nous appelons aujourd’hui un ordinateur programmable — même si elle n’a jamais été terminée de leur vivant.

Pourquoi les années 1840 comptaient

Les années 1840 furent un moment où mathématiques, industrie et automatisation commençaient à se rejoindre. Les gens cherchaient des méthodes fiables — tableaux, formules et procédures reproductibles — parce que les erreurs étaient coûteuses et la science s’accélérait. Dans ce contexte, l’intérêt d’Ada pour « comment instruire une machine » n’était pas une curiosité : c’était une réponse opportune à un besoin croissant : transformer le raisonnement humain en processus reproductibles et vérifiables.

Une vue simple de la Machine analytique

Avant qu’Ada Lovelace ne puisse décrire un algorithme, il fallait une machine digne d’être « programmée ». La Machine analytique de Charles Babbage était conçue comme une calculatrice à usage général : pas un appareil pour une formule unique, mais une machine configurable pour exécuter différentes séquences d’opérations.

Ce qu’elle était censée faire

L’idée centrale était simple : si vous pouvez décomposer un problème en petites étapes arithmétiques (addition, soustraction, multiplication, division), une machine devrait pouvoir exécuter ces étapes de façon fiable, dans le bon ordre, autant de fois que nécessaire.

C’est le passage d’un calcul ponctuel à une méthode réutilisable.

Les parties en langage courant : mémoire, opérations, entrée/sortie

Babbage décrivait deux composants principaux :

• Le « magasin » (mémoire) : un endroit pour conserver des nombres pendant que le travail est en cours. Pensez-y comme prendre des notes sur un carnet pour réutiliser des résultats intermédiaires.
• Le « moulin » (opérations) : la partie qui effectue des calculs sur des nombres pris dans le magasin, puis y remet les résultats. C’est l’établi où l’arithmétique a lieu.

Pour l’entrée et la sortie, l’Engine devait recevoir instructions et données via des cartes perforées (inspirées des métiers à tisser) et produire des résultats sous une forme utilisable par l’humain — imprimés ou autrement enregistrés.

Une analogie moderne qui aide

Si vous transposez ces idées aujourd’hui :

• Moulin ≈ CPU : exécute les opérations.
• Magasin ≈ RAM : conserve les données sur lesquelles vous travaillez.
• Cartes ≈ programmes et fichiers de données : disent à la machine quoi faire et avec quoi le faire.

C’est pourquoi la Machine analytique compte : elle esquisse la même séparation que nous utilisons toujours — du matériel qui exécute des étapes et des programmes qui définissent quelles étapes exécuter.

Les Notes qui ont changé notre manière de penser les machines

Quand on parle d’Ada Lovelace et du premier algorithme, on pointe souvent un ensemble précis de matériaux : les « Notes » qu’elle a ajoutées à sa traduction anglaise de l’article de Luigi Menabrea sur la Machine analytique de Charles Babbage.

Menabrea décrivait le concept de la machine. Lovelace alla plus loin : elle traita l’Engine comme quelque chose que l’on pouvait instruire — pas seulement admirer. Ce glissement explique en grande partie pourquoi ces Notes sont si importantes dans l’histoire de la programmation. Elles ressemblent à la pensée computationnelle précoce : décomposer un objectif en étapes précises, choisir des représentations et anticiper comment un mécanisme les suivra.

Plus que du commentaire : un manuel pour donner des instructions

Les Notes de Lovelace expliquent ce que nous appellerions aujourd’hui la conception de programmes. Elle décrit les parties de l’Engine (comme le magasin et le moulin) en termes d’enchaînement et de contrôle des opérations. L’idée centrale est simple mais profonde : si la Machine analytique peut effectuer des opérations dans un ordre défini sur des symboles définis, alors le « comment » doit être écrit dans une forme que la machine puisse exécuter.

C’est là que son travail commence à ressembler à la programmation moderne. Ce n’est pas que de la théorie ; c’est une méthode.

Le tableau pas à pas qui rend le tout concret

Surtout, les Notes incluent un exemple détaillé présenté sous la forme d’un tableau d’étapes. Il énonce, ligne par ligne, ce que la machine doit faire : quelles valeurs se trouvent dans quels emplacements, quelle opération est la suivante et où sont stockés les résultats.

Ce format de tableau est l’ancêtre du pseudocode, des organigrammes et des plannings d’instructions : un plan explicite et vérifiable que l’on peut suivre sans deviner. Que vous construisiez ou non une Machine analytique, l’habitude qu’il enseigne — transformer une idée en séquence exécutable — est toujours au cœur de l’écriture logicielle.

L’algorithme des nombres de Bernoulli, expliqué simplement

Un algorithme, au sens courant, est une méthode reproductible : un ensemble d’étapes claires qui vous mènent de points de départ à une réponse. C’est comme une recette qui ne dépend pas de l’intuition : si vous suivez les étapes, vous devriez obtenir le même résultat à chaque fois.

L’exemple célèbre d’Ada Lovelace visait à calculer les nombres de Bernoulli — une suite de valeurs qui apparaît dans de nombreux domaines des mathématiques (par exemple dans des formules pour des sommes comme 1 + 2 + … + n, et en analyse). Il n’est pas nécessaire de connaître la théorie pour apprécier pourquoi ils constituent un excellent cas de test pour une machine de calcul précoce.

Pourquoi les nombres de Bernoulli sont un bon exemple

Ils posent le bon niveau de défi :

• Chaque nouveau nombre de Bernoulli dépend des précédents, on ne peut donc pas faire un seul calcul et s’arrêter.
• Le calcul implique plusieurs opérations (addition, soustraction, multiplication, division), pas une astuce unique.
• Il existe une suite correcte connue, donc les résultats peuvent être vérifiés.

Autrement dit, c’est assez complexe pour prouver que la machine peut suivre une méthode structurée, mais assez ordonné pour être consigné en étapes.

La forme de la méthode : entrées → valeurs intermédiaires → résultat

Au cœur, l’algorithme a une structure familière encore utilisée aujourd’hui :

• Entrées : constantes fixes et nombres de Bernoulli déjà calculés nécessaires pour l’étape suivante.
• Valeurs intermédiaires : résultats temporaires produits en cours de route — sommes partielles, produits et fractions à conserver jusqu’à réutilisation.
• Résultat final : le prochain nombre de Bernoulli de la suite.

Vue ainsi, Lovelace ne se contentait pas de montrer un nombre calculé : elle montrait comment organiser un calcul en plusieurs étapes pour qu’une machine puisse l’exécuter sans improviser.

Décomposition et flux de contrôle : le travail de conception caché

Quand on parle de l’algorithme des nombres de Bernoulli de Lovelace, on se focalise souvent sur le résultat (« un programme précoce ») plutôt que sur le travail de conception qui rend les étapes fiables. La vraie réussite n’est pas seulement d’énumérer des opérations : c’est de les structurer pour qu’une machine puisse les suivre sans improviser.

Décomposer : transformer un grand objectif en petites tâches

Plutôt que de traiter « calculer les nombres de Bernoulli » comme une seule tâche, les Notes le décomposent en parties plus petites pouvant être répétées et vérifiées : calculer des valeurs intermédiaires, les combiner selon une formule, enregistrer les résultats puis passer au cas suivant.

Cette décomposition est importante car chaque sous-tâche peut être validée isolément. Si une sortie est erronée, on ne débogue pas « l’algorithme entier », on inspecte une seule pièce.

État et mémoire : ce qui doit être retenu

Un calculateur mécanique ne « garde pas les choses en tête ». Toute valeur nécessaire plus tard doit être stockée quelque part, et les Notes sont scrupuleuses à ce sujet. Certaines valeurs sont temporaires ; d’autres sont des résultats finaux qui doivent persister pour des étapes ultérieures.

C’est une forme précoce de réflexion sur l’état d’un programme :

• Quelles valeurs doivent survivre à l’étape suivante ?
• Lesquelles peuvent être écrasées en toute sécurité ?
• Lesquelles doivent rester intactes car des étapes ultérieures en dépendent ?

Flux de contrôle : l’ordre comme prévention d’erreurs

L’ordre des opérations est une fonction de sécurité. Certains calculs doivent se produire avant d’autres, non par élégance, mais pour éviter d’utiliser une valeur non préparée ou d’écraser quelque chose encore nécessaire.

En termes modernes, Lovelace conçoit le flux de contrôle pour que le programme suive un chemin clair : faire A, puis B, puis C — car faire B en premier donnerait silencieusement un mauvais résultat.

Boucles, répétition et l’idée d’itération

L’une des idées les plus « modernes » cachées dans le tableau d’étapes de Lovelace est la répétition : la capacité d’exécuter le même ensemble d’instructions encore et encore, non pas par manque d’imagination, mais parce que répéter est la manière la plus efficace d’obtenir un résultat.

Répétition sans mystère

La répétition dans un programme signifie : suivre une petite recette d’étapes, vérifier si vous avez fini, et sinon exécuter à nouveau la même recette. L’important est que quelque chose change à chaque passage — souvent un compteur, une position dans un tableau ou la valeur que vous construisez — de sorte que le programme progresse vers une ligne d’arrivée.

Dans la notation de Lovelace, on peut voir cela comme un retour structuré à des étapes antérieures. Plutôt que de réécrire des instructions identiques de nombreuses fois, elle décrit un motif et indique quand revenir en arrière. C’est la graine de ce que nous appelons aujourd’hui l’itération.

Comment son tableau se transpose aux boucles modernes

Si vous avez écrit du code, vous avez vu ce schéma sous la forme d’une boucle for ("répéter N fois") ou while ("répéter jusqu’à ce qu’une condition soit vraie"). Son tableau implique aussi des ingrédients de boucle familiers :

• Un compteur (quel passage ?)
• Une valeur qui change (le résultat partiel)
• Une condition d’arrêt (quand le compteur atteint la fin)

Un exemple simple : sommer des nombres

Imaginez que vous voulez la somme de 1 à 5.

• Commencez avec total = 0
• Commencez avec i = 1
• Ajoutez i à total
• Incrémentez i de 1
• Si i est toujours inférieur ou égal à 5, répétez l’ajout et l’incrément

C’est l’itération en termes clairs : une petite boucle qui met à jour un compteur et accumule un résultat. La contribution de Lovelace n’était pas seulement ce qu’elle calculait : c’était de montrer que la structure répétée peut être écrite clairement pour qu’une machine (et des humains futurs) l’exécutent de manière fiable.

Variables et notation : rendre les idées exécutables

Une procédure peut être parfaitement logique dans votre tête et pourtant impossible à suivre pour une machine — ou pour une autre personne — sans une façon de désigner des quantités qui changent. C’est là que les variables et la notation entrent en jeu.

Les variables comme boîtes étiquetées

Pensez à une variable comme à une boîte étiquetée sur un bureau. L’étiquette reste la même, mais ce qu’il y a dedans peut changer au fil du travail.

Si vous calculez une suite, vous pouvez avoir :

• une boîte pour le résultat courant
• une boîte pour la prochaine valeur d’entrée
• une boîte pour une valeur intermédiaire que vous jetterez après une étape

Sans ces boîtes, vous seriez obligé de tout décrire en longues phrases (« prenez le nombre calculé il y a deux étapes… »), ce qui devient vite embrouillé.

La notation n’est pas décoration

Dans les Notes de Lovelace, les symboles et étiquettes ne servent pas à paraître formels : ils permettent d’exécuter le processus. Une notation claire répond à des questions pratiques :

• Quelle valeur est en cours de mise à jour ?
• Quelles valeurs doivent être conservées pour les étapes suivantes ?
• Quelles valeurs sont temporaires et peuvent être écrasées ?

Quand les procédures s’allongent, ces clarifications évitent l’erreur la plus commune : confondre des quantités qui se ressemblent.

L’écho moderne : noms et types

Un bon nommage des variables reste l’un des moyens les moins coûteux de réduire les bugs. Comparez x1, x2, x3 avec somme_courante, indice_terme et terme_suivant : le second ensemble indique à quoi servent les boîtes.

Les types ajoutent une couche de sécurité. Décider si quelque chose est entier, décimal, liste ou enregistrement, c’est comme choisir le bon type de contenant : certaines erreurs deviennent impossibles ou plus faciles à détecter tôt.

Variables et notation transforment « une idée brillante » en étapes reproductibles correctement, par n’importe qui (y compris une machine).

Abstraction et réutilisation : des tableaux d’étapes aux fonctions

L’abstraction consiste à se concentrer sur l’essentiel et à masquer volontairement les détails non pertinents. C’est la différence entre dire « trier cette liste » et décrire chaque échange et comparaison à la main. Les Notes de Lovelace montrent tôt cette inclination : elles cherchent à communiquer une méthode clairement, sans forcer le lecteur à s’emmêler dans les spécificités mécaniques de la machine.

Séparer la méthode de la mécanique

Une caractéristique frappante des Notes est la façon dont elles maintiennent l’idée centrale indépendante des actions physiques de la machine. L’Engine a son propre « comment » (engrenages, magasin, moulin), mais les Notes insistent sur le « quoi » : la séquence d’opérations nécessaire pour atteindre un résultat.

Cette séparation est la graine de ce que nous appelons maintenant la conception logicielle :

• L’algorithme décrit l’intention (calculer des nombres de Bernoulli).
• La machine (ou l’implémentation) gère les détails d’exécution (où vivent les valeurs, comment les opérations sont effectuées).

Lorsque vous pouvez décrire la méthode sans réexpliquer la machine, vous traitez déjà le calcul comme quelque chose de portable — réimplémentable sur du matériel différent ou par des personnes différentes.

Des tableaux d’étapes aux composants réutilisables

Les tableaux pas à pas dans les Notes ressemblent à de premières « procédures » : un ensemble défini d’étapes à suivre encore et encore. Le code moderne formalise cela en fonctions, modules et composants réutilisables.

Une bonne fonction fait ce que la présentation de Lovelace réalise :

• nomme une opération pour éviter de répéter l’explication partout,
• prend des entrées et produit des sorties,
• cache les étapes internes sauf si vous avez vraiment besoin de les inspecter.

C’est pourquoi l’abstraction n’est pas de la nébulosité : c’est de l’utilisabilité. La réutilisation suit naturellement : une fois une méthode bien exprimée, on peut l’appeler dans un nouveau contexte, la combiner avec d’autres et bâtir des systèmes plus larges sans se noyer dans les détails.

La documentation comme fonctionnalité, pas comme un ajout

Ada Lovelace n’a pas seulement décrit ce que la Machine analytique pouvait faire : elle a montré comment rendre une procédure non ambiguë pour qu’un autre (ou une machine) puisse la suivre. C’est la puissance discrète de ses Notes : elles traitent l’explication comme faisant partie du travail, pas comme un ornement.

Les tableaux pas à pas comme « pseudocode dont on ne peut pas s’échapper »

Une raison pour laquelle sa présentation paraît encore moderne est l’utilisation de tableaux structurés. Un tableau force des décisions que la prose vague peut masquer :

• ce qui arrive en premier, deuxième et troisième
• quelles valeurs intermédiaires existent à chaque étape
• quand une valeur est mise à jour vs simplement référencée
• où commence et se termine la répétition

Cela réduit l’ambiguïté de la même manière que le pseudocode aujourd’hui. On peut lire un paragraphe et penser l’avoir compris — jusqu’à l’essayer. Un tableau rend le « chemin d’exécution » visible, ce que vise toute bonne documentation de programme.

Notes alors, README maintenant

Les Notes de Lovelace mêlent trois choses que l’on essaie toujours de garder ensemble :

1. Ce à quoi sert le programme (l’intention)

2. Comment il fonctionne (la procédure)

3. Comment interpréter la notation (l’interface : noms, symboles, hypothèses)

Cela correspond aux commentaires, docstrings et README modernes. Un README explique l’objectif et le contexte. Les commentaires en ligne clarifient les étapes délicates. Les docstrings définissent entrées/sorties et cas limites. Lorsqu’un de ces éléments manque, on se retrouve à deviner — et c’est là que naissent les bugs.

Retraité pratique : documenter une procédure pour que d’autres puissent l’exécuter

Quand vous documentez un processus (du code ou non), écrivez comme si quelqu’un devait le reproduire sans vous :

• Indiquez entrées et sorties en termes simples ("Étant donné X, produire Y").
• Listez les hypothèses (unités, ordres, règles d’arrondi).
• Rédigez les étapes en séquence numérotée ou dans un petit tableau d’états.
• Nommez les valeurs intermédiaires et gardez les noms cohérents.
• Incluez un exemple réduit que l’on peut vérifier à la main.

Ce n’est pas du travail en plus : c’est la façon dont une méthode devient réutilisable.

Mythes, débats et ce que nous pouvons dire avec confiance

Ada Lovelace est souvent présentée sous l’étiquette audacieuse de « première programmeuse ». C’est un raccourci utile, mais qui peut aussi aplatir une vérité plus intéressante. Le débat ne porte pas seulement sur la primauté : il concerne ce que nous entendons par programme, ordinateur et auteur.

Ce que signifie vraiment « première programmeuse » (et pourquoi on discute)

Si « programmeuse » désigne quelqu’un qui a écrit des instructions destinées à une machine à usage général, Lovelace a de bons arguments. Dans ses Notes sur la Machine analytique, elle décrit une méthode pas à pas pour générer les nombres de Bernoulli : en pratique, un plan permettant à l’Engine d’effectuer un calcul non trivial.

Mais les historiens contestent l’étiquette parce que :

• la Machine analytique n’a pas été complétée, donc le programme n’a pas pu être vérifié par exécution,
• certains éléments de la méthode peuvent refléter une collaboration avec Babbage, qui réfléchissait depuis longtemps aux procédures mécaniques,
• des automatismes antérieurs existaient, bien que pas dans le même sens généraliste.

Idée vs machine fonctionnelle

Il est important de séparer l’invention d’une idée informatique de la construction d’un ordinateur fonctionnel. L’apport majeur de Babbage fut architectural : une machine proposée avec mémoire (« store »), un processeur (« mill ») et un contrôle via des cartes perforées. L’apport de Lovelace fut interprétatif et expressif : elle a clarifié ce que cette machine pouvait représenter et comment une procédure pouvait être consignée pour que la machine la suive.

Un programme ne cesse pas d’être un programme parce que le matériel n’a jamais été livré. En termes modernes, c’est comme écrire un logiciel pour une plateforme encore théorique — ou spécifier un algorithme avant l’existence de la puce.

Rendre à chacun ce qui lui revient sans transformer l’histoire en concours

Une manière respectueuse d’aborder cette époque est de la voir comme une collaboration de rôles :

• Babbage : conception matérielle, ambition mathématique et développement itératif à long terme.
• Lovelace : traduction, expansion, explication et capacité rare à relier des procédures abstraites à une machine à usage général.
• Menabrea (et d’autres) : descriptions antérieures que Lovelace a traduites et transformées en quelque chose de beaucoup plus détaillé.

Ce que nous pouvons dire avec confiance : les Notes de Lovelace ont contribué à définir ce qu’est la programmation — pas seulement le calcul, mais l’expression soignée d’un processus que la machine pourrait exécuter.

Enseignements pratiques pour concevoir des programmes aujourd’hui

Les Notes de Lovelace importent parce qu’elles montrent comment penser quand on transforme une idée en plan exécutable par une machine. Même si vous ne touchez jamais aux cartes perforées ou aux engrenages mécaniques, les leçons fondamentales se transposent bien à la conception moderne : donnez au travail une structure claire, nommez les choses soigneusement, utilisez la répétition intentionnellement et construisez des blocs réutilisables.

Les leçons durables (encore étonnamment modernes)

La structure vaut mieux que l’astuce. Un programme est plus simple à construire et à maintenir lorsqu’il est découpé en étapes ayant un but clair. L’approche de Lovelace vous encourage à dessiner la forme de la solution avant de vous perdre dans les détails.

La clarté est une fonctionnalité. Ses tableaux et explications n’étaient pas de l’ornement : ils faisaient partie du programme. Quand votre futur vous (ou un coéquipier) peut suivre la logique rapidement, le programme devient plus fiable.

L’itération est un outil, pas une ruse. La répétition (boucles) est la façon de faire évoluer une méthode. L’important est de définir ce qui se répète, ce qui change à chaque fois et quand cela s’arrête.

L’abstraction permet la réutilisation. Si une séquence d’étapes fonctionne une fois, vous devriez pouvoir la réutiliser avec d’autres entrées. C’est la graine des fonctions, modules et bibliothèques.

Où cela apparaît dans les outils modernes

Si vous avez déjà utilisé un flux « décrivez pour construire » — rédiger des exigences, itérer sur un plan puis générer du code fonctionnel — vous avez déjà rejoué l’esprit des Notes de Lovelace : expliciter la procédure, garder l’état clair et documenter les hypothèses pour que l’exécution soit reproductible.

C’est une des raisons pour lesquelles des plateformes comme Koder.ai s’inscrivent naturellement dans cette histoire. Koder.ai vous permet de créer des applications web, backend et mobiles via une interface de chat, mais les fondamentaux restent les mêmes : vous obtiendrez de meilleurs résultats en spécifiant entrées/sorties, en nommant les choses de façon cohérente et en demandant une structure étape par étape (le mode planification peut vous aider à verrouiller les « Notes » avant de générer ou modifier du code). L’outil est nouveau ; la discipline, non.

Une checklist simple pour tout programme que vous concevez

Faites ce rapide passage avant de commencer à coder — ou quand vous déboguez quelque chose de confus :

1. But : Pouvez-vous dire en une phrase ce que le programme produit ?
2. Entrées/sorties : Qu’est-ce qui entre, qu’est-ce qui sort, et sous quel format ?
3. Décomposer : Quelles sont les 3–7 étapes majeures ? (Si c’est 20, regroupez.)
4. Nommez les choses : Quelles sont les valeurs clés ? Donnez-leur des noms cohérents.
5. Trouvez la répétition : Quelle étape se répète ? Qu’est-ce qui change à chaque itération ?
6. Conditions d’arrêt : Qu’est-ce qui met fin à chaque boucle ou processus ? Comment éviter un travail infini ?
7. Blocs réutilisables : Quelle étape pourrait devenir une fonction réutilisée ailleurs ?
8. Expliquez-le : Un lecteur pourrait-il comprendre le plan depuis vos commentaires ou votre doc sans l’exécuter ?

Pour continuer à apprendre (lectures suivantes)

Si vous voulez renforcer le style « notes d’abord » pour la conception de programmes, ces ressources aideront :

• /blog/how-to-write-better-requirements
• /blog/pseudocode-examples

Ensemble, ces habitudes transforment la programmation de « faire fonctionner » en « rendre compréhensible » — le même changement que vers lequel les Notes de Lovelace pointaient déjà.