L’Artisan du Code

Pourquoi je code

Je ne code pas pour le cloud.

Je ne code pas pour la mode.

Je ne code pas pour les buzzwords.

Je ne code pas parce que quelqu’un m’a expliqué que le framework du mois allait changer ma vie.

Je code parce que j’aime comprendre.

Comprendre ce qui se passe.

Derrière l’écran.
Derrière l’abstraction.
Derrière la dépendance.

Je suis un artisan du dimanche.

Retour aux sources

Je ne veux pas retourner dans les années 80.

Je veux retrouver leur état d’esprit.

Il fut un temps où une application pouvait être comprise.

Un fichier.
Un programme.
Un terminal.
Un clavier.

On écrivait quelque chose.

On lançait le programme.

Ça fonctionnait.

Et si ça ne fonctionnait pas, on relisait le code jusqu’à comprendre pourquoi.

Pas de tableau de bord.
Pas de vingt-sept services.
Pas de YAML qui décrit un autre YAML qui décrit encore une autre application.

Juste du code.

Et peut-être un café.

Comprendre

Je ne veux pas seulement que ça fonctionne.

Je veux savoir pourquoi ça fonctionne.

Je veux pouvoir lire mon propre code.

Le modifier.

Le casser.

Le réparer.

Le reprendre six mois plus tard sans avoir besoin d'une documentation de quatre cents pages pour comprendre ce que j'ai écrit un dimanche soir.

Pour moi, programmer n'est pas seulement produire.

C'est comprendre.

Lua

Lua me parle.

Petit.
Lisible.
Simple.

Procédural quand j'en ai envie.

Un langage qui n'a pas besoin de crier pour prouver qu'il existe.

Je débute en Lua.

Et ça me va très bien.

Être débutant signifie encore avoir le plaisir de découvrir ce que fait réellement chaque ligne.

Je n'ai pas besoin de construire une startup.

Je n'ai pas besoin d'une architecture de microservices.

Je n'ai pas besoin de Kubernetes pour afficher :

BONJOUR LE MONDE

Je veux simplement écrire un programme.

Linux

Linux fait partie de ma vie depuis vingt ans.

Pas parce que c'est à la mode.

Parce qu'il me permet de regarder dessous.

Les fichiers sont des fichiers.
Les processus sont des processus.
Les tubes sont des tubes.
Le texte est du texte.

Le shell est toujours là.

Et quelque part sous tout le bruit moderne, il reste cette magnifique idée Unix :

Faire une chose.
La faire bien.
L’assembler.

Cette idée a remarquablement bien vieilli.

Le terminal

Pas besoin de mille fenêtres.

Un terminal suffit.

Du texte.
Des commandes.
Un éditeur.

Un programme qui naît sous mes doigts.

Le curseur clignote.

Le fichier est vide.

Et pendant quelques secondes, le monde extérieur n'existe plus.

Il n'y a plus de notifications.
Plus de métriques.
Plus de réunions.
Plus de tendances.

Juste la machine.

Et moi.

KISS

Keep it simple, stupid.

Pas : restez moderne.

Pas : faites de l’entreprise.

Pas : ajoutez des dépendances.

Simple.

Un programme que je peux relire six mois plus tard a pour moi plus de valeur qu'un programme brillant qui nécessite une conférence pour être expliqué.

Si un fichier suffit, utilise un fichier.

Si dix lignes suffisent, écris dix lignes.

Si la bibliothèque standard suffit, laisse le framework tranquille.

Le programmeur du dimanche

Je ne suis pas un professionnel du code.

Je suis quelque chose de différent.

Je suis programmeur parce que j'aime programmer.

Il n'y a pas de sprint.

Pas de backlog.

Pas de chef qui demande une démonstration pour lundi matin.

Pas de tableau de productivité.

Pas d'urgence artificielle.

Il y a simplement le dimanche.

La machine.
L'éditeur.
Le code.
Et le silence.

Coder lentement

Je ne suis pas pressé.

Mon code n'a pas de deadline.

Le dimanche n'est pas une course.

J'ai le droit de passer une heure sur dix lignes.

J'ai le droit de chercher.
De lire.
D'essayer.
De me tromper.
De recommencer.

Le temps passé à comprendre n'est pas du temps perdu.

C'est le travail.

Le logiciel que je possède

Mon programme tient dans un fichier.

Je peux le copier.
Je peux le lire.
Je peux le modifier.
Je peux le sauvegarder.
Je peux le déplacer sur une autre machine.

Je peux le garder dix ans.

Vingt ans.

Peut-être davantage.

Il n'a pas besoin d'un serveur quelque part pour me rappeler qu'il existe.

Il est là.

Sur mon disque.
Dans mon répertoire.
Dans mon texte.

Et je sais ce qu'il contient.

Le Stradivarius

Un luthier ne commence pas son travail en demandant :

« Comment fabriquer dix mille violons aujourd'hui ? »

Il choisit son bois.

Il écoute.

Il travaille.

Il retire un peu.

Puis encore un peu.

Il sait que l'artisanat ne se mesure pas au nombre d'objets fabriqués.

Le code peut être comme cela.

Un petit programme peut être un instrument.

Pas nécessairement beau parce qu'il est compliqué.

Beau parce que chaque morceau a une raison d'exister.

Je veux construire mon petit Stradivarius du code.

Pas pour des millions d'utilisateurs.
Pas pour des investisseurs.
Pas pour un CV.

Pour moi.

Parce que c'est moi qui l'ai construit.

Et parce que je le comprends.

Pas de bullshit

En 2026, il y a beaucoup de bruit.

IA.
Cloud.
Frameworks.
Conteneurs.
Plateformes.
Buzzwords.
Abonnements.

Abstractions empilées sur des abstractions.

Et parfois nous oublions la question originale :

Que fait le programme ?

Je veux revenir à cette question.

Pas parce que le passé était parfait.

Il ne l'était pas.

Mais parce que la simplicité est intemporelle.

Old school

Être old school ne signifie pas refuser le futur.

Être old school signifie savoir d'où l'on vient.

Lire la documentation.

Comprendre ses outils.

Savoir ce que fait son programme avant de demander à un autre programme de le faire.

Être curieux.

Réparer ses propres erreurs.

Respecter la machine.

Respecter l'utilisateur.

Et surtout :

Apprendre.

L'établi

Mon établi est simple.

Linux.
Un terminal.
Lua.
Un éditeur de texte.
Un répertoire.
Une tasse de café.

Peut-être une vieille machine.

Peut-être une machine moderne qui fait tourner une vieille philosophie.

Et un fichier vide.

dimanche.lua

Le fichier est vide.

C'est la meilleure partie.

Tout est encore possible.

Les règles de l'artisan

1. Comprendre avant d'optimiser.
2. Lire le code que l'on écrit.
3. Préférer la clarté à la virtuosité.
4. Préférer une dépendance que l'on comprend à dix dépendances que l'on ne connaît pas.
5. Ne pas ajouter de complexité simplement parce que tout le monde le fait.
6. Ne pas confondre moderne et meilleur.
7. Ne pas confondre petit et mauvais.
8. Ne pas confondre simple et facile.
9. Garder ses outils à portée de main.
10. Garder sa curiosité encore plus près.
11. Casser des choses.
12. Les réparer.
13. Apprendre de la machine.
14. Prendre son temps.
15. Prendre plaisir à travailler.
16. Ne jamais avoir honte d'être débutant.
17. Ne jamais arrêter d'apprendre.

Dernière note

Je suis un artisan du code.

Un programmeur du dimanche.

Un utilisateur de Linux.

Un débutant en Lua.

Un esprit old school vivant en 2026.

Je ne cherche pas à devenir un meilleur programmeur que les autres.

Je cherche simplement à devenir meilleur que celui que j'étais hier.

Je ne veux pas construire le plus gros système.

Je ne veux pas écrire le code le plus impressionnant.

Je veux écrire du code que je comprends.

Du code qui commence quelque part.

Du code qui finit quelque part.

Du code qui fait ce qu'il dit.

Du code écrit tranquillement, honnêtement, une ligne après l'autre.

Pendant que le monde ajoute des couches,

J'EN RETIRE.

Pendant que tout le monde cherche la prochaine grande chose,

J'OUVRE UN FICHIER TEXTE.

Pendant que les machines deviennent toujours plus complexes,

JE GARDE MON PROGRAMME PETIT.

Pas parce que je ne pourrais pas faire plus gros.

Mais parce que je n'en ai pas besoin.

Je ne veux pas retourner dans les années 80.

Je veux simplement conserver ce qu'il y avait de beau dans leur manière de faire :

la curiosité,
la débrouille,
le partage,
le texte,
la machine,
et le plaisir de comprendre.

Le dimanche, quand le monde ralentit,

j'allume ma machine.

J'ouvre un fichier vide.

Et je commence.

Une ligne.

Puis une autre.

Sans bruit.

Sans urgence.

Sans bullshit.

Juste moi,

la machine,

et le code.