Rendez-le simple pour grand-mère : l’école d’ingénierie de la simplicité| Par Edward Tatchim

Il y a une phrase que j’ai récemment commencé à emporter avec moi dans chaque nouveau système, chaque nouvel outil et chaque stack qui m’est encore étrangère : « Rends-le simple pour grand-mère. »

Non pas parce que grand-mère ne serait pas intelligente.
Mais parce qu’une véritable compréhension technique se révèle lorsque vous êtes capable d’expliquer quelque chose clairement à une personne non technique, sans vous cacher derrière la complexité.

Et dans la tech, il faut bien le dire : la complexité aime souvent se faire passer pour de l’intelligence.
Alors que la simplicité, elle, est la vraie démonstration de maîtrise.

Le jour où la simplicité est devenue ma stratégie d’apprentissage

Il y a quelques années, mon entreprise a opéré un changement majeur.
Nous avons décidé de réduire notre dépendance aux fournisseurs SaaS tiers pour construire notre propre stack interne open source.

C’était un tournant culturel important, qui a aussi redéfini les attentes envers les équipes d’ingénierie.

Pour moi, cela signifiait une chose très concrète : bien que formé en ingénierie logicielle, j’ai dû pivoter rapidement vers la data engineering.

Le problème n’était pas la motivation. J’étais enthousiaste.

Le véritable défi, c’était l’avalanche d’outils inconnus.

Soudain, il fallait comprendre et faire fonctionner des technologies comme : Apache Airflow, Apache Kafka, Apache Iceberg, dbt, Apache Spark, Prometheus, Grafana, Loki…

Au départ, l’écosystème open source me donnait l’impression qu’on m’avait mis entre les mains un puzzle de mille pièces… sans l’image sur la boîte.

Iceberg ? Kafka ? Spark ? dbt ? Grafana ?
Mon cerveau réagissait simplement par :
« Attends… c’est quoi tout ça ? »

Avec le recul, j’ai compris pourquoi je me sentais bloqué : j’essayais de comprendre toute la stack comme un seul bloc.

Et c’est exactement là que beaucoup se perdent lorsqu’ils apprennent des systèmes inconnus :
ils essaient d’avaler l’ensemble d’un seul coup.

Le déclic : revenir au principe fondamental

Un soir, en pleine phase d’apprentissage, une idée simple apprise à l’université m’est revenue.

Une idée presque trop simple.
Mais qui a tout changé :

Entrée → Traitement → Sortie

C’est le principe fondamental de l’informatique.

Un système reçoit une entrée, applique une logique, puis produit une sortie.

En observant l’évolution technologique, on réalise que les grandes avancées ont surtout consisté à améliorer la vitesse, l’échelle et l’efficacité de ce cycle.

Et soudain, tout devient plus clair :

La plupart des outils technologiques — open source, SaaS, PaaS ou autres — font fondamentalement la même chose :

• ils prennent une entrée,
• la traitent,
• produisent une sortie.

Le mystère n’est donc pas dans leur finalité.
Il est souvent dans leur emballage.

Et une grande partie de notre travail consiste à voir au-delà.

Les principes d’abord : la voie la plus rapide vers la compréhension

À partir de ce moment, ma manière d’apprendre a changé.

Au lieu d’être intimidé par le nom d’un outil ou sa complexité apparente, je suis revenu aux fondamentaux.

Pour chaque outil, je me posais simplement deux questions :

• Quelle est l’entrée ?
• Quelle est la sortie ?

Et une fois ces réponses trouvées, quelque chose d’inattendu s’est produit : l’enthousiasme est revenu.

Pourquoi ?

Parce que lorsque l’entrée et la sortie deviennent claires, le traitement cesse d’être intimidant.
Il devient intéressant.

Je pouvais enfin apprécier l’ingénierie du système :

• Comment traite-t-il les données ?
• Comment produit-il le résultat ?
• Comment le fait-il de manière fiable, répétable et à grande échelle ?

Ce « comment » est devenu mon terrain de jeu.

Pourquoi cette approche fonctionne

En utilisant Entrée → Traitement → Sortie comme cadre d’apprentissage, vous cessez de vous noyer dans les fonctionnalités, les buzzwords et la sophistication apparente.

Vous commencez à voir les outils pour ce qu’ils sont : des systèmes avec un rôle précis.

Vous ne demandez plus : « C’est quoi Spark ? » comme s’il s’agissait d’une créature mythologique.

Vous demandez plutôt :

• Que prend-il en entrée ?
• Que produit-il en sortie ?
• Quel problème résout-il ?
• Que se passe-t-il s’il n’est pas là ?
• Où se situe-t-il dans le pipeline ?

Et soudain, ce qui semblait complexe devient digeste.
Pas d’un coup, mais pièce par pièce.

Comme lorsqu’on explique quelque chose à grand-mère.
Sans jargon.
Avec clarté.

Pensée finale

Si vous apprenez quelque chose de nouveau dans la tech aujourd’hui, essayez ceci :

N’essayez pas de tout comprendre en même temps.
Revenez aux fondamentaux.

Décomposez.
Identifiez l’entrée.
Identifiez la sortie.
Puis explorez le traitement avec curiosité, et non avec peur.

Parce que la complexité n’est pas toujours une preuve d’intelligence.
La clarté, si.

Et si vous pouvez le rendre simple pour grand-mère…
alors il y a de fortes chances que vous l’ayez vraiment compris.

Edward Tatchim