Tutoriel Linux : développer en IA gratuitement et efficacement sur son vieux PC pourtant poussif

La sortie récente de la version release d’Opencode 2 est l’occasion de faire un tuto simple qui explique comment utiliser un vieux PC Linux, sans GPU ni RAM mirobolante, pour générer du code gratuitement.

La méthode standard pour générer du code est de prendre un abonnement payant chez un prestataire comme Anthropic (Claude). Cette méthode a l’inconvénient de coûter et d’introduire une dépendance à un tiers.

La méthode alternative reine est donc d’auto-héberger ses propres modèles d’IA, ce qui résout les 2 problèmes d’un coup (gratuité et indépendance). Cependant, dans ce cas, un nouveau problème surgit : la perte de performance, sauf à disposer d’une machine de fou.

Pour Monsieur tout le monde, une solution intermédiaire est d’utiliser Opencode comme agent local mais au lieu de le coupler à un modèle local (très exigeant en ressources), on le couple à un modèle performant via le prestataire opencode. Ces modèles distants proposés par l’intermédiaire d’opencode sont gratuits, performants, et ne nécessitent pas de clé API. Dans cette configuration, votre vieux PC pourri sous Linux ne fait tourner que le client opencode, toutes les requêtes partent sur le réseau Internet et les réponses suivent le chemin inverse.

Où est l’arnaque dans ce cas ?

Si vous gagnez un outil de travail gratuit et performant, il y a une contrepartie. Premièrement, tout ce que vous produisez comme code part sur le réseau. Rien de ce que vous produirez ne vous appartient vraiment. On ne peut donc pas coder des applications sensibles ainsi.

Deuxièmement il n’y a aucune certitude de la disponibilité de ces outils gratuits à l’avenir. Les sociétés qui fournissent des modèles d’IA ne sont pas des sociétés philanthropiques, elles sont là pour rentabiliser les investissements colossaux qu’elles ont réalisés. Pourtant, allez savoir pourquoi, certaines d’entre elles proposent encore des modèles performants gratuits. C’est le cas notamment du géant chinois DeepSeek, dont nous allons utiliser un modèle gratuit dans ce tutoriel. Pourvu que ça dure, mais il n’y a pas de garantie que ce soit le cas. Par contre ces modèles ne sont accessibles que via opencode.

Troisièmement, ce n’est pas open bar, il y a des limites à l’utilisation. Cependant il est très difficile de savoir à combien elles sont réglées exactement. De mon expérience, elles doivent être assez élevées.

Installation et utilisation sous Ubuntu 26.04

Installer opencode par la commande :

Continuer la lecture →

Tutoriel Linux : développement web avec backend en langage C (Episode 10 – Une nouvelle web app complète en C vibe codée en 1j)

J’avais besoin d’une application pour m’aider à gérer mes courses, en les optimisant selon plusieurs aspects : organiser les menus de la semaine de repas de la famille, faire de même avec les articles (hygiène, entretien de la maison, etc.), puis en extraire automatiquement la liste des courses, puis cocher au fur et à mesure de la mise en caddie pour être certain de ne rien avoir oublié.

Certaines applications existaient mais je voulais la mienne. Elle a été intégralement faite sur la journée d’hier, vibe codée pour 0€.

Méthode de développement IA efficace pour 0€

J’ai profité des explications des 9 premiers épisodes pour expliquer à une IA gratuite quelle est ma stack et quelles sont mes habitudes de codage. Je lui ai notamment fourni ma librairie climb.c, que j’ai déjà présentée dans les épisodes précédents. Elle a appris à coder dans mon style, avec mes outils.

Au début elle avait tendance à lutter contre mon style et à ajouter son grain de sel un peu partout. Il a fallu batailler pour la laisser créative au niveau de l’ergonomie, mais respecter impérativement mes principes de code, de sorte que, quoi qu’il arrive, je comprenne le code produit, comme si je l’avais écrit moi-même.

Le résultat est juste parfait par rapport à ce que je voulais. Le projet a germé sous forme d’idée hier matin, il était entièrement codé hier soir. La productivité était incroyable : je voyais des scripts de 400 lignes de C, quasi-identiques à celles que j’aurais écrites, sortir en 25 secondes (là où chaque script m’aurait pris au moins la demi-journée).

Non je n’ai pas utilisé Claude. Je n’ai pas 1€ à mettre dans l’IA. Tout a été codé par DeepSeek, qui de mon point de vue fait de l’excellent travail, gratuitement.

L’application est auto-hébergeable sur un VPS Linux. Le code source est disponible ici.

S’amuser avec

Au choix, l’ouvrir dans un nouvel onglet, ou ci-dessous (moins pratique car moins de place à l’écran).

Dans les deux cas, se connecter pour l’évaluation avec login : mescourses, mot de passe : mescourses

Enjoy 😎 (Et vive le C)

ArtCraft : 13 alternatives libres aux suites Adobe et Microsoft, encore à l’état de prototypes

Le projet ArtCraft, lancé par le développeur Brandon Thomas, propose une série d’applications de bureau natives gratuites et open source, présentées comme des alternatives fonctionnelles aux outils établis comme Adobe Creative Cloud et Microsoft Office. Ce projet s’appuie massivement sur l’intelligence artificielle pour produire du code, ce qui a permis un développement d’une rapidité inhabituelle, mais soulève des questions substantielles quant à sa maturité réelle, sa légalité et la nature exacte de la méthode employée, que l’équipe qualifie de « clean-room » sans qu’il soit possible de le vérifier indépendamment.

La suite logicielle, baptisée « Crafting Apps », comprend treize applications couvrant l’édition d’image (PhotoCraft), l’illustration vectorielle (VectorCraft), le montage vidéo (FilmCraft), la gestion de photos (LightCraft), l’édition PDF (PdfCraft), les effets visuels (EffectCraft), la mise en page (DesignCraft), le traitement de texte (WordCraft), le tableur (GridCraft), les présentations (DeckCraft), l’audio (SoundCraft), la conception assistée par ordinateur (CADCraft) et le design d’interface (FigCraft). Toutes sont développées en langage Rust, compilées en applications natives pour macOS, Windows et Linux, et publiées sous licences libres MIT et Apache 2.0. Le modèle économique repose non pas sur la vente des applications, mais sur la génération d’images via le studio ArtCraft intégré, dont l’accès aux modèles tiers se paie en jetons.

 La liste complète des 13 applications

La suite couvre un large éventail de domaines créatifs, bureautiques et techniques. Chaque application est conçue comme une alternative directe à un standard de l’industrie :

Application ArtCraftAlternative àDomaine
PhotoCraftAdobe PhotoshopÉdition d’image matricielle
VectorCraftAdobe IllustratorIllustration vectorielle
FilmCraftAdobe Premiere ProMontage vidéo
LightCraftAdobe LightroomGestion de photos et développement RAW
PdfCraftAdobe Acrobat ProÉdition et gestion de PDF
EffectCraftAdobe After EffectsEffets visuels et motion design
DesignCraftAdobe InDesignMise en page et publication
WordCraftMicrosoft WordTraitement de texte
GridCraftMicrosoft ExcelTableur
DeckCraftMicrosoft PowerPointPrésentations
SoundCraftAvid Pro Tools (audio)Édition audio
CADCraftAutodesk AutoCADConception assistée par ordinateur
FigCraftFigmaDesign d’interface et prototypage

La genèse du projet est directement liée à l’exaspération de Brandon Thomas face aux pratiques d’Adobe, notamment les frais d’annulation des abonnements annuels. Il a déclaré avoir utilisé le modèle Claude Opus 5.5 d’Anthropic pour analyser les interfaces et les fonctionnalités des logiciels originaux, puis réécrire en Rust un code imitant leur comportement. L’équipe affirme n’avoir utilisé aucune ligne de code propriétaire d’Adobe et n’avoir procédé à aucune décompilation, ce qui correspondrait à une réimplémentation en chambre blanche. Cette affirmation n’est toutefois pas vérifiable : comme le soulignent plusieurs observateurs, il est impossible de déterminer si et comment l’analyse des logiciels originaux a été séparée de l’écriture du code. Les conditions d’utilisation d’Adobe interdisent explicitement la rétro-ingénierie de ses logiciels, et des questions de brevets et de marques déposées subsistent, même en l’absence de poursuites à ce jour.

Sur le plan fonctionnel, l’état des applications reste très éloigné d’une parité avec les originaux. PhotoCraft, l’application la plus aboutie, était évaluée par le projet lui-même à environ 45 % de ce qui serait nécessaire pour un usage professionnel réel à la mi-octobre, avec une estimation de 2 300 à 4 100 heures d’agent supplémentaires pour atteindre une parité complète. LightCraft se situait autour de 61 %. Les tests menés par des utilisateurs et des journalistes ont relevé des bugs critiques, notamment des images supprimées et des calques fusionnés de manière aléatoire dans PhotoCraft, ainsi que des plantages lors de l’import de nombreux clips vidéo dans FilmCraft. La prise en charge des fichiers PSD natifs de Photoshop pose problème, ce qui constitue un obstacle majeur pour les utilisateurs existants. Les capacités de traitement des fichiers RAW et de gestion des couleurs professionnelles sont également jugées insuffisantes.

La promesse initiale de Thomas d’atteindre une parité fonctionnelle totale en un mois a été abandonnée, l’intéressé reconnaissant que cela prendrait probablement plusieurs mois. Il a indiqué avoir rendu le projet public pour rassembler des utilisateurs capables de signaler des problèmes et de contribuer au développement. La réaction de la communauté technique est partagée : certains saluent l’ampleur de ce qu’un développeur seul a pu produire avec l’aide de l’IA, tandis que d’autres mettent en garde contre un code difficilement maintenable à terme et contre la tentation de confondre prototype rapide et produit stable.

L’épisode ArtCraft illustre surtout une évolution technique : la combinaison d’un langage strict comme Rust, d’une suite de tests extensive et d’un modèle de référence observable en permanence (les logiciels Adobe eux-mêmes) constitue un cas idéal pour le développement assisté par agents. Il ne démontre pas pour autant que l’IA puisse remplacer le travail de conception et de décision accumulé sur des décennies.

Continuer la lecture →

Tutoriel Linux : développement web avec backend en langage C (Episode 9 – Une web app complète en C)

Pour mettre en œuvre tous les concepts vus dans les épisodes précédents, voici une web app en C opensource, que j’ai conçue et réalisée à titre de démo sans prétention.

Il s’agit d’une application qui permet de faire le suivi et la gestion d’un compte bancaire complet. Les quatre fonctionnalités implémentées sont simples, mais fonctionnelles: ajout, modification, suppression, et rapprochement de tickets.

Le logiciel réalise les totaux banque (tickets rapprochés uniquement) et personnel (tous tickets) et permet même d’épargner les arrondis.

Le lecteur intéressé peut le tester avec un compte de démo et le télécharger sur un dépôt public.

Compte de démo : login demo, mot de passe demotickechic.

Ou alors aller sur la page d’accueil de la démo.

Voici à quoi ressemble le logiciel :

Code source complet et instructions d’installation

Qu’est-ce qu’un harnais en IA ?

Dans le domaine de l’intelligence artificielle, le terme harnais (harness en anglais) désigne la couche logicielle qui entoure un grand modèle de langage pour le transformer en un agent capable d’exécuter réellement des tâches. Une formule résume bien cette idée : Agent = Modèle + Harnais.

Pourquoi est-ce nécessaire

Un modèle de langage brut, comme GPT ou Claude, est un cerveau très performant mais isolé. Il ne peut que générer du texte, ne se souvient de rien d’une session à l’autre et n’agit sur rien. Le harnais joue le rôle de système nerveux et de manuel d’utilisation. Il fournit au modèle des données à consulter, des outils à manipuler et des règles à respecter. C’est ce qui lui permet de passer de la capacité à parler à la capacité à agir.

Ce que contient concrètement un harnais

Un harnais complet comprend généralement plusieurs composants. D’abord une invite système, qui définit le rôle de l’agent, ses objectifs et les règles qu’il doit suivre en permanence. Ensuite des outils et un mécanisme d’exécution : le modèle décide quoi faire, le harnais se charge d’exécuter l’action réelle, comme un appel d’API ou l’exécution de code, puis renvoie le résultat au modèle. Vient également la gestion de la mémoire et du contexte, qui détermine quelles informations conserver et lesquelles résumer. S’y ajoute une boucle de vérification et de rétroaction, qui permet à l’agent de tester son propre travail et de corriger ses erreurs. Enfin, des garde-fous et un environnement isolé encadrent les permissions de l’agent et exigent une confirmation humaine avant les opérations risquées.

Une analogie simple

On peut imaginer le modèle comme un cheval puissant mais qui pourrait s’emballer. Le harnais est l’équipement complet : la selle, le mors et les rênes. Il ne change pas la force du cheval, mais il permet au cavalier de contrôler sa direction et son allure, de le faire tirer un chariot en sécurité vers la destination voulue au lieu de foncer dans le décor.

Les configurations de harnais courantes en 2026

Tous les harnais ne se ressemblent pas. Le choix d’une configuration dépend de l’usage visé, du niveau de contrôle souhaité et du contexte de déploiement. Voici les principales familles que l’on rencontre aujourd’hui, illustrées par des produits ou projets réels.

La première est le harnais en boucle simple, parfois appelé boucle ReAct. Le modèle alterne raisonnement, action et observation, sans planificateur externe ni état persistant sophistiqué. C’est l’approche la plus légère et la plus rapide à mettre en place. Un exemple représentatif est youtu-agent de Tencent Cloud, décrit comme un harnais minimal de tool-calling. Cette configuration convient bien aux tâches courtes et aux prototypes. En revanche, elle dérive facilement sur les tâches longues : sans mécanisme de rappel de l’objectif, l’agent peut s’éloigner du but initial après une dizaine d’actions.

La deuxième famille est le harnais avec planificateur ou superviseur. Un composant séparé établit un plan, surveille son exécution et déclenche une replanification en cas d’échec. C’est la configuration qui gagne en production lorsque la fiabilité prime sur la vitesse. Claude Code d’Anthropic et Deep Agents illustrent bien ce modèle : ils implémentent le motif planification-plus-sandbox de manière suffisamment aboutie pour être recommandés lorsqu’on veut qu’un seul agent termine une tâche de codage de bout en bout de façon fiable.

La troisième famille est le harnais modulaire, où les composants sont interchangeables. OpenCode en est un exemple important : il s’agit d’un backend d’agent de codage qui peut être utilisé comme runtime par d’autres harnais, comme le montre son intégration dans lh-harness aux côtés de Claude Code, Codex CLI et DeepSeek Harness . OpenCode est également à la base de dérivés comme DrizzyAgent, qui étend OpenCode avec une orchestration multi-agents . Cette modularité facilite les tests A/B et l’évolution indépendante de chaque brique.

La quatrième famille est le harnais multi-agents, où plusieurs agents spécialisés collaborent sous la coordination d’un agent manager. MetaGPT en est le représentant historique : il simule une « entreprise logicielle IA » avec des agents qui jouent les rôles de chef de produit, architecte et ingénieur. CrewAI et AgentVerse s’inscrivent dans la même veine. DrizzyAgent, mentionné plus haut, illustre cette approche appliquée au codage avec ses rôles de Coder, Planner, Oracle, Librarian et Atlas . Cette configuration brille lorsque les sous-tâches sont indépendantes et que la spécialisation apporte un gain réel.

La cinquième famille est le harnais de type microkernel ou plan de contrôle. L’idée centrale est de séparer strictement le plan de contrôle (ordonnancement, état, sécurité, mémoire, audit) du plan d’exécution, où les agents sont hébergés dans des sandbox. QM de YCombinator en est un exemple frappant : il fournit une séparation au niveau de l’organisation, où chaque employé, salon Slack et projet dispose de sa propre mémoire, de ses fichiers, de ses identifiants, de ses permissions et de son environnement sandboxé. Cette architecture offre une stabilité de production et un contrôle multi-tenant.

OpenClaw occupe une place particulière dans cette famille. Il ne se présente pas comme un harnais unique mais comme une plateforme d’exécution d’agents qui peut accueillir plusieurs harnais natifs. Sa documentation décrit explicitement un « harnais Codex » qui permet à OpenClaw de déléguer l’exécution à un serveur d’application Codex natif, tout en conservant la maîtrise du plan de contrôle : résolution du fournisseur et du modèle, authentification, budget de contexte, politique d’outils, sandbox et livraison des réponses . OpenClaw propose également un harnais acpx pour les agents compatibles ACP, avec des alias intégrés pour factory-droid, cursor et d’autres . Cette architecture illustre la tendance à traiter le harnais comme un exécuteur interchangeable, branché sur un noyau qui reste stable.

Enfin, une catégorie plus récente mérite d’être mentionnée : le harnais de flux de travail, qui impose une discipline de phases (spécification, conception, implémentation, vérification, intégration) avec un contexte frais à chaque phase et une persistance d’état dans des fichiers explicites. GSD (Get Shit Done) en est l’exemple canonique : il enveloppe une session de codage IA dans un cycle de vie en six étapes, avec un état de projet stocké dans un répertoire versionné qui survit aux réinitialisations de contexte.

Il faut également citer Pi, qui se distingue par une philosophie de « harnais auto-modifiable ». Pi n’est pas seulement un harnais de codage : c’est un environnement que l’agent peut lui-même inspecter et modifier, avec un système de plugins et d’extensions. Son package pi-harness-runtime illustre cette approche en fournissant une configuration runtime complète, avec gestion des clés API, intégrations Telegram, LangChain et PaperClip, et un mécanisme de boucle planificateur-coder-relecteur-fixeur . Dans une interview accordée à InfoQ, les créateurs de Pi décrivent leur outil comme « une preuve de concept d’un logiciel agentique auto-modifiable », et citent DeepSeek Harness comme une inspiration conceptuelle sur cette même voie . Un package communautaire comme @minhduydev/pi-harness pousse la logique plus loin en proposant un harnais portable avec extensions, compétences, modèles de prompts et thèmes, ainsi qu’un contrat de coordination gouverné pour les sous-agents .

Un point important

Le harnais ne consiste pas à corriger ponctuellement un problème en modifiant une invite. Son objectif central est de corriger une erreur commise par l’IA en modifiant son environnement d’exécution, de sorte que cette erreur ne puisse plus se reproduire. C’est pourquoi on considère souvent que la qualité du harnais détermine le degré de maturité d’un modèle dans des scénarios complexes. Une étude arXiv de 2026 va plus loin : le choix du harnais expliquerait une part plus importante de la variance des résultats aux benchmarks d’agents que le choix du modèle lui-même. Autrement dit, à modèle égal, un bon harnais fait une différence mesurable.

Tutoriel Linux : développement web avec backend en langage C (Episode 8 – Génération de page HTML / CSS / Javascript en C)

Comme on l’a vu dans l’épisode précédent, le script en C qui traite les données envoyées par le formulaire suit 4 étapes :

  1. Recevoir et lire les données brutes envoyées par le formulaire
  2. Retraiter ces données pour qu’elles soient exploitables
  3. Effectuer les traitements requis
  4. Produire et renvoyer une page HTML de réponse

Dans cet épisode nous allons nous intéresser à l’étape 4.

Vous n’y coupez pas, si votre code C doit écrire une page HTML / CSS / Javascript via des printfs, vous devez maîtriser les langages HTML, CSS et Javascript. Ou maîtriser une IA.

Personnellement je n’aime pas particulièrement cette partie, alors je demande à une IA gratuite (DeepSeek en ce qui me concerne) de me générer un couple index.html / styles.css qui donne un look moderne aux widgets (boutons, zones de saisie de texte, zone de saisie de mot de passe, boutons radio, cases à cocher, etc).

Une fois que le fichier styles.css contient le look pile poil aux petits oignons pour tous les widgets, l’IA me génère le fichier index.html qui montre comment invoquer chaque widget dans ce look. Après au niveau du programme en C ce n’est plus que de l’assemblage de lego.

Voici par exemple la page d’accueil de mon réseau social entièrement codé en C, utilisant un look Matrix concocté par DeepSeek :

Sans aller dans un extrême psychédélique comme celui ci-dessus, voici ci-dessous par exemple une page HTML / CSS d’exemple au look moderne, générée par DeepSeek, que j’utilise dans d’autres projets en C :

L’analyse du code source de index.html montre par exemple comment générer en C la zone de saisie de texte « Votre adresse email » :

printf(\"<div class=\"input-group\">\n\
                    <span class=\"input-icon\">✉️</span>\n\
                    <input type=\"email\" name=\"email\" placeholder=\"Votre adresse email\" class=\"input-field\" required>\n\
                </div>\n");

Vous voyez le principe ? Je n’invente rien, mes scripts C ne font qu’afficher via printf ce que l’IA dit qu’il faut afficher pour avoir la zone de saisie de texte dans le look moderne souhaité.

Tutoriel Linux : développement web avec backend en langage C (Episode 7 – Structure type d’un script en C)

Comme nous l’avons vu dans les épisodes précédents, la mécanique est de coupler un formulaire (form) HTML rempli par le client, envoyé au serveur NginX qui renvoie lui-même les données à un script de traitement, que nous ambitionnons d’écrire en langage C.

Ce script aura toujours la même structure :

  1. Recevoir et lire les données brutes envoyées par le formulaire
  2. Retraiter ces données pour qu’elles soient exploitables
  3. Effectuer les traitements requis
  4. Produire et renvoyer une page HTML de réponse

Pour faire tout cela, nous allons utiliser la librairie climb téléchargeable ici.

Recevoir et lire les données brutes envoyées par le formulaire

Voici le code type :

int main()
{
char *request_body;
char *parametre1;
int nb;

request_body=climb_http_post_request_body();
parametre1=(char *)malloc(strlen(request_body));
nb=climb_http_request_body_items_number(request_body);
if(nb>0) climb_http_request_body_item(request_body,1,parametre1);
}

climb_http_post_request_body lit la chaine de caractères brute reçue du formulaire du client

climb_http_request_body_items_number compte le nombre de champs qu’il y a dans cette chaine de caractères brute (ie le nombre d’items renseignés par le client dans le formulaire)

climb_http_request_body_item recopie dans parametre1 la valeur du champ n (ici n=1 donc c’est le dernier champ, 2 pour l’avant dernier, etc.)

Notez comment la variable parametre1 est initialisée : par malloc sur la taille complète de la chaine reçue. C’est un moyen très simple mais pourtant très efficace de ne pas être attaqué par débordement de tampon.

Retraiter ces données pour qu’elles soient exploitables

Comme on l’a vu dans les épisodes précédents, la chaine de caractères envoyée par le formulaire est codée selon les codages HTML, ce qui signifie que ce que le script C reçoit n’a plus que peu à voir avec ce que l’utilisateur a tapé dans son formulaire.

Pour retrouver ce que l’utilisateur a tapé, notre programme C va donc maintenant exécuter :

climb_http_translate(parametre1);

Cette fonction permet à la fois de retrouver ce qu’a tapé l’utilisateur mais empêche également les attaques de type XSS (Cross site scripting).

Effectuer les traitements requis

Nous avons vu dans l’épisode 6 comment notre programme C peut interférer avec une base de données MySQL. Comme mentionné, pour faire cela il faut connaître un minimum les requêtes SQL : nous en verrons le B-A-BA dans un épisode ultérieur.

La librairie climb ne fournit pas que des fonctions utiles au dialogue avec MySQL. Il y aussi :

Une fonction pour hacher une chaine de caractères, que nous utiliserons pour stocker les mots de passe en base de données. Vous savez déjà en effet qu’un mot de passe ne se stocke jamais en clair, mais haché :

void climb_sha56_hash(char *string); 

climb fournit aussi des fonctions utiles pour la gestion du temps, du format JSON, des sémaphores et des cookies HTML :

// Time functions
int climb_time_dayoftheweek(char * date_string);
void climb_time_zeroize(int num, char *out_string);

// JSON functions
struct json_response *climb_json_init();
void climb_json_status_seterror(struct json_response *jr, char *errorstatus);
void climb_json_status_unseterror(struct json_response *jr);
void climb_json_data_record_add_keyvalue_(struct json_response *jr, char *key, char *value);
void climb_json_data_add_record_(struct json_response *jr);
void climb_json_response_(struct json_response *jr);

// Semaphore functions
void climb_semaphore_init(int *sem, int pack);
int climb_semaphore_get(int *sem, int pack);
void climb_semaphore_take_token(int *sem);
void climb_semaphore_release_token(int *sem);

// Cookies functions
int climb_cookies_get_how_many(char *chaine);
int climb_cookies_get_cookie_name(char *chain,int pos,char *result);
int climb_cookies_get_cookie_value(char *chain,int pos,char *result);
int climb_cookies_is_cookie_present(char *chain, char *name); // returns cookie position if yes, -1 otherwise

Produire et renvoyer une page HTML de réponse

Pour envoyer une réponse au client web, le script en C a juste à faire des printf puisque sa sortie standard est de facto connectée à NginX, qui sert de passe plat vers le navigateur du client.

Cependant, il faut veiller à ce que la première partie de la réponse soit :

printf("Content-type: text/html\n\n");

En effet, sans cet entête la réponse HTML envoyée par notre programme ne sera pas considérée comme valide.

De même, si notre script en C devait répondre en JSON et non en HTML, l’entête devra obligatoirement être :

Content-Type: application/json 

Pour info, c’est déjà ce qu’envoie la fonction :

void climb_http_response_init();

Une fois envoyé l’entête HTML, le script en C doit construire une page de réponse en HTML5 / CSS / Javascript, ou utiliser un framework (j’ai longtemps utilisé JQUERY MOBILE mais il est désuet).

Généralement je travaille un look moderne de page avec une IA comme DeepSeek, et l’IA me génère le fichier styles.css aux petits oignons que j’utilise ensuite dans mes réponses en C.

Conclusion

Au final on voit qu’avec la librairie climb tout est super simple : 4 fonctions pour lire l’entrée, quelques fonctions bien senties pour faciliter les traitements, et de simples printf en sortie pour générer la réponse.

Cours Microsoft gratuit en 18 leçons en français pour apprendre l’IA (spécial débutants)

Joignez l’utile à l’agréable, c’est gratuit et en français 😎

Si l’audio des vidéos est en anglais, vous pouvez la basculer en français dans la fenêtre de chaque vidéo.

Leçon 1 : Introduction aux agents IA et cas d’utilisation des agents

Introduction aux agents IA et cas d’utilisation des agents

Leçon 2 : Exploration des cadres agentiques IA

Exploration des cadres agentiques IA

Leçon 3 : Compréhension des modèles de conception agentique IA

Compréhension des modèles de conception agentique IA

Continuer la lecture →

Tutoriel Linux : développement web avec backend en langage C (Episode 6 – Dialogue avec MySQL depuis un programme en C)

Le backend d’une application web doit très souvent stocker et lire des données dans une base de données. Souvent cette base de données fonctionne avec SQL, et parfois il s’agit de MySQL.

Je vais présenter ci-dessous les 7 fonctions que j’utilise en langage C pour accéder à une base MySQL située sur la même machine que le script C de backend.

J’ai mis ces fonctions dans un fichier climb.h et climb.c, dans lesquels il y a des fonctions relatives à beaucoup d’autres sujets, mais aussi les fonctions relatives au dialogue avec MySQL.

La librairie CLIMB (C LIbrary for Modern Backends)

CLIMB est donc la librairie qui regroupe toutes les fonctions utiles perso que j’utilise.

Voici les fonctions utiles, déclarées dans climb.h :

// MySQL functions
#define _MYSQL

typedef struct CLIMB_MYSQL_RESULT_STRUCT CLIMB_MYSQL_RESULT_STRUCT;
typedef CLIMB_MYSQL_RESULT_STRUCT *CLIMB_MYSQL_DBRESULT;

#define CLIMB_MYSQL_DBHANDLER MYSQL *
#define CLIMB_MYSQL_DBSTMT MYSQL_STMT *

CLIMB_MYSQL_DBHANDLER climb_mysql_opendatabase(char *databasename, char *host, char *login, char *password);
int climb_mysql_ntuples(CLIMB_MYSQL_DBRESULT result);
void climb_mysql_clear_result(CLIMB_MYSQL_DBRESULT result);
void climb_mysql_closedatabase(CLIMB_MYSQL_DBHANDLER handler);
void climb_mysql_getvalue(CLIMB_MYSQL_DBRESULT result, int row, int col, char *value, int max);
CLIMB_MYSQL_DBRESULT climb_mysql_query_prepare(CLIMB_MYSQL_DBHANDLER handler, char *query);
CLIMB_MYSQL_DBRESULT climb_mysql_do_query(int nparams, ...);

climb_mysql_opendatabase : ouvre une connexion avec la base MySQL dont le nom est databasename, située sur la machine dont le nom DNS est host (donc localhost pour nous), dont l’utilisateur propriétaire s’appelle login, et son mot de passe password. Si elle réussit, cette fonction ramène un handler qui permet de poursuivre le dialogue.

climb_mysql_query_prepare : prépare une requête query (préparée donc) pour la base de données ouverte (handler).

climb_mysql_do_query : envoie une quantité de nparams paramètres à la requête préparée par climb_mysql_query_prepare, et exécute cette requête SQL. Cette fonction ramène un résultat result.

climb_mysql_ntuples : compte le nombre de lignes (enregistrements) résultats de l’exécution de la requête.

climb_mysql_getvalue : récupère dans la variable value (de taille max) l’enregistrement de ligne row et de colonne col de la requête dont le résultat a été mis dans result.

climb_mysql_clear_result : ferme la requête courante pour permettre de passer ensuite une nouvelle requête.

climb_mysql_closedatabase : ferme la connexion à la base ouverte (handler).

Voici le code source ce ces fonctions dans climb.c :

Continuer la lecture →

Tutoriel Linux : développement web avec backend en langage C (Episode 5 – Installation et configuration de MySQL)

Rares sont les applications web qui n’ont pas besoin de stocker des données dans une base de données. Bien que ce soit PostgreSQL qui ait le vent en poupe, je préfère personnellement utiliser MySQL, ou sa version communautaire MariaDB (MySQL ayant été acheté par Oracle). Elle s’installe et se configure facilement sous Linux, et surtout elle est facile à interférer avec depuis un programme en langage C.

Installation de MySQL sous Ubuntu

sudo apt update
sudo apt install mysql-server mysql-client libmysqlclient-dev

mysql-server est un paquet générique qui installe la dernière version en vigueur du serveur de base de données

mysql-client est un paquet qui installe la commande mysql, qui permet de se connecter au SGBD à la main

libmysqlclient-dev installe un paquet qui fournit ce qu’il faut pour se connecter à MySQL depuis un programme en C

Configuration initiale de MySQL (à faire une seule fois)

Une fois les paquets installés, on lance la sécurisation de MySQL par :

sudo mysql_secure_installation

Ce programme va poser des questions auxquelles il faut répondre. Il faudra notamment donner le mot de passe MySQL de root qu’on choisit, confirmer la suppression des utilisateurs anonymes et des bases de test, et désactiver la connexion à distance de root.

Ensuite on va permettre à root de se connecter facilement. Pour faire ce paramétrage, on tape dans le shell la commande :

sudo mysql

On arrive dans le shell de mysql, dans lequel on tape (remplacer le mot de passe par celui que vous avez choisi pour root) :

ALTER USER 'root'@'localhost' IDENTIFIED WITH caching_sha2_password BY 'VotreMotDePasseDeRoot';

FLUSH PRIVILEGES;

EXIT;

Désormais MySQL est configuré et root peut s’y connecter en tapant la commande :

mysql -u root -p mysql

Cette commande se lit : lancer l’utilitaire mysql (qui est le client MySQL) en utilisant l’utilisateur (-u) root, en demandant le mot de passe (-p) et si l’identification est ok, le connecter à la base mysql (qui est mentionnée derrière -p).

Créer une base de données et un utilisateur pour une future application en C

Maintenant que MySQL est opérationnel, on peut y créer autant de base de données, et d’utilisateurs propriétaires de ces bases de données, que l’on veut.

Chaque application web aura sa base de données (utilisable en lecture et écriture depuis ses scripts en C, on verra par la suite comment faire), et son utilisateur propriétaire de cette base de données.

Imaginons que notre application s’appelle tartemuche. On va donc créer une base de données tartemuche, un utilisateur local (uniquement, il ne pourra pas se connecter à distance par sécurité. Les scripts en C devront donc tourner sur le même serveur que celui qui héberge MySQL) tartemuche qui aura tous les droits sur la base de données tartemuche et qui aura comme mot de passe de connexion à cette base de données tartemolle.

Voyons comment préparer cela. Tout d’abord on se connecte en tant que root à la base de données mysql :

Continuer la lecture →