Ce tutoriel explique comment configurer Codex, l'agent IA d'OpenAI, pour l'utiliser avec un modèle de langage local (LLM) hébergé via llama.cpp. L'idée principale est d'éviter les abonnements payants des plateformes cloud en auto-hébergeant le LLM, tout en conservant les fonctionnalités de Codex. L'auteur insiste sur l'importance d'installer Codex sur une machine dédiée pour limiter les risques liés à son accès au système.

L'installation de Codex se fait via un téléchargement manuel depuis GitHub, suivi de son déplacement dans /usr/local/bin. L'outil bubblewrap est requis pour sécuriser l'exécution de Codex en mode bac à sable. La configuration repose sur un fichier config.toml où l'utilisateur définit le fournisseur de modèle (llamacpp), un nom personnalisé et l'URL locale de l'API de llama.cpp.

L’article explore l’évolution des pseudo-classes CSS qui, bien que conçues pour gérer des états, peuvent parfois imiter le comportement des écouteurs d’événements JavaScript. L’auteur souligne que des pseudo-classes comme :hover, :active, :focus ou :checked réagissent à des interactions utilisateur (clic, survol, focus), offrant une alternative à JavaScript pour des cas simples. Par exemple, :focus-visible utilise des heuristiques pour déterminer si un élément doit afficher un indicateur de focus, une logique difficile à reproduire efficacement en JavaScript.

L’auteur aborde aussi des pseudo-classes plus avancées comme :focus-within et :has(), qui permettent de cibler des éléments parents en fonction de l’état de leurs enfants, réduisant ainsi le besoin de scripts. Ces fonctionnalités illustrent comment CSS gagne en expressivité, notamment avec des spécifications émergentes comme les Animation Triggers, qui pourraient un jour permettre de déclencher des animations via des événements. Cependant, ces innovations restent encore en développement.

Enfin, l’article mentionne des pseudo-classes liées aux formulaires (:valid, :invalid, etc.), qui simplifient la gestion des états de validation sans recourir à JavaScript. L’auteur conclut que, malgré ces avancées, CSS et JavaScript restent complémentaires, chacun ayant ses forces pour gérer les interactions et la logique applicative.

Cette page présente une sélection de ressources pour la réparation électronique, à la fois pour les particuliers et les professionnels. Elle met en avant des plateformes collaboratives comme iFixit, qui propose des tutoriels et pièces détachées, ainsi que des services spécialisés comme Murfy pour la réparation d’électroménager à domicile.

Elle recense également des acteurs professionnels tels qu’AdExcel pour la maintenance électronique industrielle ou Repturn, spécialisé dans la réparation de composants électroniques. Les liens sont soumis à modération avant publication sur OpenNews, qui compte plus de 12 000 références partagées.

L’article souligne que l’IA facilite la génération de code, mais que la véritable difficulté réside dans la production de code de qualité, maintenable et évolutif. L’auteur, développeur expérimenté, rappelle que les problèmes actuels (logique dispersée, tests inefficaces, architectures mal conçues) existaient déjà avant l’IA, simplement amplifiés par son usage massif. Il insiste sur l’importance des bonnes pratiques d’ingénierie logicielle, comme l’abstraction, le découplage et la responsabilité métier, plutôt que sur l’outil utilisé.

L’article de Romain Lanz explore une méthode pour utiliser efficacement l’IA dans le développement logiciel sans déléguer la réflexion stratégique. Il souligne que, contrairement à une idée reçue, déléguer l’écriture du code à l’IA ne signifie pas renoncer à la maîtrise du processus, à condition d’adopter une approche structurée.

L’auteur détaille trois concepts clés : le modèle (le LLM utilisé), le contexte (les informations fournies pour guider la réponse) et le harness (l’environnement technique qui encadre l’IA). Il insiste sur l’importance de limiter le contexte, car un excès d’informations dégrade la qualité des réponses, et sur le rôle du harness, qui agit comme un intermédiaire entre le modèle et les outils concrets (lecture/écriture de fichiers, exécution de commandes).

Enfin, Lanz rappelle que l’IA reste un outil prédictif, incapable d’agir sans ces extensions techniques. Sa méthode vise à optimiser l’interaction avec ces outils pour en tirer le meilleur parti tout en conservant le contrôle sur les décisions techniques.

La suppression de la revue de code est parfois perçue comme une simplification justifiée par l’efficacité, mais l’auteur souligne que cette approche repose sur des raisonnements erronés. Si l’IA et les outils automatisés accélèrent la production, ils ne remplacent pas l’expertise humaine pour détecter des erreurs d’intention, de logique ou de cohérence dans le code. Une revue superficielle ou simulée, où les développeurs se contentent d’approuver sans analyser, crée une fausse sécurité et aggrave les risques en production.

L’écart entre la vitesse de production et la capacité de relecture humaine est devenu ingérable. Un relecteur ne peut examiner que quelques centaines de lignes par heure, tandis qu’un agent IA génère des milliers en quelques secondes. Cette asymétrie rend la revue traditionnelle caduque, poussant les équipes soit à ralentir le processus avec des revues longues et inefficaces, soit à adopter une approbation de complaisance, pire que l’absence totale de contrôle.

L’auteur propose une alternative : assumer l’absence de revue pour forcer l’équipe à trouver des solutions alternatives, comme des outils de validation automatisée ou des tests renforcés. Plutôt que de supprimer la revue par facilité, il faudrait repenser son rôle et ses méthodes pour qu’elle reste pertinente dans un contexte où l’IA domine la production de code.

L’auteur explique avoir réduit le nombre d’agents IA qu’il utilise simultanément après avoir constaté que cette pratique créait une surcharge décisionnelle. Malgré une méthode de travail structurée (spécifications, tests d’acceptation), il a progressivement lancé plusieurs agents en parallèle, se retrouvant submergé par leurs questions et incapable de prioriser efficacement.

Il illustre ce problème avec la théorie des contraintes, soulignant que multiplier les tâches en amont d’un goulot d’étranglement (ici, sa capacité à arbitrer) ne fait qu’accumuler du stock invisible (branches ouvertes, PR en attente) sans améliorer la productivité. La fatigue décisionnelle qui en résulte affecte la qualité du travail, notamment la relecture de code généré par IA.

L’auteur conclut que cette dérive, bien que non imposée, révèle un défaut de gestion des priorités, aggravé par l’illusion de productivité offerte par les agents. Il compare cette situation à l’effet contre-productif d’ajouter des développeurs à un projet déjà en retard.

Ce journal de Jérôme Flesch, publié sur LinuxFr.org, explore les interfaces utilisateur (frontends) pour interagir avec des grands modèles de langage (LLM) auto-hébergés. L’auteur, après avoir abordé les principes généraux, le matériel et l’optimisation des LLM, se concentre ici sur les outils pratiques pour les utiliser au quotidien. Il souligne que ce domaine évolue rapidement, rendant certaines informations potentiellement obsolètes en moins d’un an.

L’article détaille plusieurs solutions comme Open WebUI et OpenCode, en expliquant leur installation, configuration et fonctionnalités, notamment la gestion des agents, des outils intégrés et des plugins. Il aborde aussi des concepts techniques comme les sous-agents, la génération augmentée par récupération (RAG) ou encore l’intégration avec des services comme Home Assistant. L’auteur met en garde contre les pièges courants, comme les problèmes liés au RAG ou aux licences controversées.

Enfin, le journal propose des exemples concrets de configuration, incluant des fichiers Docker et des paramètres pour optimiser l’utilisation des LLM. Il se termine par des mentions hors-sujet sur de nouveaux modèles d’IA, illustrant l’actualité et la dynamique du secteur.

L’article explique comment détecter des pages web similaires, même si leur contenu n’est pas strictement identique, en utilisant l’algorithme SimHash. Contrairement aux fonctions de hachage classiques comme MD5, qui produisent des empreintes radicalement différentes dès qu’un caractère change, SimHash génère des signatures numériques proches pour des contenus proches. Cela permet de repérer des doublons partiels, comme des fiches produits identiques avec une seule ville modifiée.

L’auteur détaille le fonctionnement de SimHash, inspiré d’une méthode publiée en 2002 et popularisée par Google en 2007 pour dédupliquer des milliards de pages. L’algorithme repose sur une "élection" de 64 questions binaires, où chaque mot du texte "vote" en fonction de son propre hachage. Le résultat final est une empreinte de 64 bits reflétant la similarité globale du contenu.

Enfin, l’article propose une implémentation en PHP sans dépendances, adaptée à des comparaisons en base de données pour des millions de pages. Cette approche évite le recours coûteux à des modèles de langage (LLM) tout en restant efficace pour des cas comme le crawler de redirection.io.

L’auteur explique comment persister la mémoire et la configuration personnalisée de Claude Code dans une sandbox Docker (sbx) pour éviter de tout perdre après suppression. Il utilise des kits mixin pour créer un lien symbolique vers un dossier .claude-project/ sur l’hôte, où sont stockés l’historique, les transcripts et les fichiers de config (comme CLAUDE.md ou les hooks). Cette méthode permet de conserver les données entre les sessions, même après un sbx rm.

L’article détaille aussi la configuration du kit via un fichier spec.yaml, exécuté au démarrage de la sandbox pour automatiser la création du lien et l’exclusion du dossier de la gestion Git. L’auteur partage son implémentation pour ceux qui souhaitent éviter de configurer manuellement ces éléments. La solution repose sur la version v2 des kits, compatible avec sbx 0.38.0.

CineLibre propose une sélection de films gratuits en replay, référencés depuis des plateformes officielles comme Arte, France.tv, M6+, TF1+, NOVO19, TV5Monde+ et HENRI. Le site permet de rechercher des films par titre, réalisateur ou acteur, et les classe par diffuseur, genre, langue originale ou décennie. Il facilite ainsi l’accès à des œuvres variées, issues de sources légales.

Parmi les films mis en avant, Fenêtre sur cour d’Alfred Hitchcock (1954) est un thriller où un photographe immobilisé observe son voisin et soupçonne un meurtre. Django unchained de Quentin Tarantino (2012), disponible sur M6+, mêle drame et western dans l’Amérique d’avant-guerre de Sécession. D’autres titres comme Call me by your name (2017) ou The Usual suspects (1995) complètent la sélection, avec des durées, notes et genres indiqués pour chaque œuvre.

La plateforme archive également des films via Internet Archive et met en avant des réalisateurs ou acteurs populaires. Les films sont présentés avec leur durée, année, note et plateforme de diffusion, offrant une vue d’ensemble pratique pour les spectateurs.

Ce billet explique comment moderniser un firewall iptables vieillissant sans perturber Docker, en prenant l’exemple d’un serveur exposé directement sur Internet. L’auteur souligne que les règles doivent refléter le chemin réel des paquets, qui a évolué depuis 2017, notamment avec l’intégration de Docker. Il revient sur quatre articles précédents pour montrer comment Fail2ban, SYNPROXY, ipset et CrowdSec ont été adaptés, tout en corrigeant des pratiques obsolètes comme le filtrage sur eth0 ou l’absence de gestion des connexions Docker.

L’article détaille les pièges rencontrés, comme l’impact de conntrack et SYNPROXY sur les connexions SSH, ou la nécessité de réviser les règles pour éviter de bloquer l’accès aux ports 22, 80 et 443. L’auteur insiste sur l’importance de maintenir des outils comme Fail2ban, CrowdSec et AbuseIPDB de manière complémentaire, plutôt que redondante, et partage des bonnes pratiques pour sécuriser le serveur dans un environnement "à peine agressif".

Enfin, le texte propose une mise à jour des règles iptables pour 2026, en intégrant les évolutions récentes comme la gestion des ipset, la rotation des clés API et une meilleure validation des données externes. L’objectif est de concilier sécurité renforcée et compatibilité avec Docker, tout en évitant les erreurs d’architecture qui pourraient rendre le serveur inaccessible.

Cette page propose neuf méthodes pour optimiser l’apprentissage grâce à l’IA, en s’appuyant sur des principes pédagogiques éprouvés comme la récupération active, l’espacement et la pratique exigeante. L’idée centrale est d’utiliser l’IA comme un coach plutôt que comme une simple machine à réponses, en évitant de déléguer entièrement le travail cognitif à l’outil. Par exemple, transformer l’IA en tuteur socratique, qui pose des questions et guide l’utilisateur vers la compréhension plutôt que de fournir des solutions toutes faites, maximise la rétention des connaissances.

L’article insiste sur une règle fondamentale : l’IA doit assister l’effort d’apprentissage sans le remplacer, car c’est l’effort personnel qui renforce la mémoire. Les techniques proposées, comme la création de flashcards automatisées suivies de révisions espacées, illustrent cette approche en combinant gain de temps et efficacité pédagogique. L’accent est mis sur l’interaction active avec le contenu, plutôt que sur la consommation passive d’informations.

Enfin, le texte met en garde contre les limites de l’IA, notamment ses erreurs potentielles, et recommande de croiser ses réponses avec d’autres sources pour éviter les biais. Destiné aux apprenants de tous niveaux, l’article encourage à appliquer ces méthodes immédiatement sur un sujet précis, en adaptant les prompts fournis pour une utilisation concrète.

L’auteur critique l’usage des chatbots, qu’il compare à une forme d’onanisme intellectuel ou de Guitar Hero créatif : amusant mais stérile, car il ne développe aucune compétence réelle. Il souligne que les utilisateurs, même en ayant la réponse sous les yeux, échouent à la restituer, illustrant l’absence d’apprentissage. L’analogie avec un plaisir solitaire et peu partageable renforce son rejet de cette pratique, qu’il juge à la fois inefficace et dénuée de valeur ajoutée.

Ploum admet avoir lui-même cédé à la tentation, en testant un chatbot pour générer des images, mais souligne l’absurdité de l’exercice : l’outil produit des résultats superficiels, comme une musculature exagérée imposée à un personnage, révélant ses biais. Il insiste sur le paradoxe où l’IA, présentée comme un gain de temps, exige en réalité un investissement disproportionné pour un résultat médiocre, à l’image d’un jardinier trop coûteux pour une petite pelouse.

Enfin, il généralise cette critique aux dynamiques managériales ou parentales, où déléguer une tâche simple à un "expert" (humain ou machine) s’avère contre-productif. Son ton mêle ironie et sérieux, dénonçant une mode technologique qui sacrifie l’effort personnel au profit d’une illusion de facilité, sans réel bénéfice durable.

L’article explique comment implémenter le pattern Unit of Work dans Symfony pour centraliser la gestion des opérations (création, mise à jour, suppression) sur différentes sources de données, y compris des services externes comme des API REST ou des files de messages. L’idée est de regrouper ces opérations dans une seule transaction logique, garantissant cohérence, clarté et testabilité, à l’image d’un panier d’achat où les modifications sont validées en une seule fois.

L’auteur propose une architecture en quatre composants : un objet Change pour représenter une opération, un service UnitOfWork pour collecter les changements, des Committer (interfaces) pour gérer l’écriture des données selon le backend, et des Repository modifiés pour enregistrer les changements au lieu de les exécuter immédiatement. Chaque Committer est spécialisé pour un type d’entité et un système de stockage.

L’implémentation repose sur une séparation claire des responsabilités, où le UnitOfWork agit comme un coordinateur central. Les changements sont regroupés par type d’entité avant d’être transmis aux Committer correspondants, permettant une intégration flexible avec Doctrine, des API ou d’autres services.

Parkinson’s Law, théorisé en 1955 par le historien britannique Cyril Northcote Parkinson, stipule que "le travail s’étend pour remplir le temps disponible pour son accomplissement". Cette observation, initialement une satire sur l’inefficacité bureaucratique, révèle un phénomène universel : plus une tâche dispose de temps, plus elle tend à occuper cet espace, souvent avec des ajustements superflus ou une procrastination déguisée en perfectionnisme.

L’auteur illustre ce principe par des exemples concrets, comme un courriel prenant une journée entière ou un projet de deux semaines réalisé en trois jours si le délai est serré. Cette expansion du travail s’explique par l’absence de pression initiale, qui encourage la lenteur, les micro-décisions et l’anxiété de dernière minute, transformant une tâche simple en un processus chronophage et souvent moins efficace.

À l’inverse, des contraintes temporelles strictes forcent une concentration accrue, éliminant les excès de perfectionnisme et accélérant la prise de décision. Le résultat est souvent une exécution plus directe et parfois même de meilleure qualité, car le manque de temps réduit les distractions inutiles.

L’article explique l’ATProto, un protocole ouvert développé par Bluesky pour créer des réseaux sociaux décentralisés, distinct d’ActivityPub utilisé par Mastodon. Contrairement à ce dernier, l’ATProto sépare l’identité de l’hébergeur, permettant aux utilisateurs de migrer sans perdre leurs données. Bluesky n’est qu’une application parmi d’autres possibles sur ce protocole.

L’identité dans l’ATProto repose sur trois éléments clés : le handle (nom lisible et modifiable), le DID (identifiant stable et permanent) et le PDS (serveur hébergeant le dépôt). Le DID, lié à une clé publique, permet de vérifier l’authenticité des données et de changer de PDS sans perdre son identité.

L’article détaille aussi le fonctionnement technique, comme les records (données structurées) et les blobs (fichiers adressés par leur contenu), ainsi que la vérification des signatures pour garantir l’intégrité des données. Il montre comment déployer son propre PDS ou écrire une application sur l’ATProto, soulignant son approche auto-certifiée et décentralisée.

L’article présente la création d’un assistant de code review basé sur l’IA, spécialisé dans le projet Symfony, en combinant PHP, Ollama et Qdrant. L’idée centrale est d’exploiter les milliers de retours historiques de la communauté Symfony pour générer des critiques de code plus pertinentes et adaptées, plutôt que des conseils génériques. L’auteur a développé un système utilisant une recherche sémantique (RAG) pour analyser les pull requests et les commentaires des contributeurs expérimentés, comme stof ou Nicolas Grekas, afin d’offrir des retours ciblés.

L’outil, nommé Symfony Reviewer MCP, repose sur une architecture en deux parties : un pipeline de génération de données vectorielles (à partir des archives GitHub) et un serveur MCP exposant ces données via une interface standardisée. L’indexation a été réalisée localement avec Ollama (modèle embeddinggemma-300m) et Qdrant, sans recourir à un GPU, au prix d’un temps de traitement long mais économiquement acceptable. L’application est développée en PHP 8.5 et Symfony 8.1, démontrant une approche pragmatique pour intégrer l’IA dans des workflows de développement existants.

L’article explique comment moderniser un script de sauvegarde obsolète en utilisant Codex via l’extension Remote SSH de VS Code, plutôt que de réécrire aveuglément le code. L’auteur, confronté à des changements d’infrastructure (migration Debian, conteneurs Docker disparus), a préféré auditer le script existant en temps réel sur le serveur, en s’appuyant sur l’IA pour vérifier la validité des chemins, des commandes et des ressources (conteneurs, volumes, espace disque). Cette approche interactive permet de confronter les hypothèses du code à la réalité du serveur, évitant ainsi des erreurs liées à des hypothèses erronées.

L’outil Remote SSH de VS Code joue un rôle clé en transformant le serveur distant en espace de travail direct, où Codex peut analyser les fichiers et exécuter des commandes dans le contexte réel. L’auteur souligne l’importance de ne pas laisser l’IA agir sans contrôle, notamment en matière de privilèges : Codex propose des commandes en lecture seule et demande explicitement l’autorisation avant toute opération sensible, garantissant ainsi une supervision humaine constante.

Le processus a révélé des incohérences majeures dans le script, comme des chemins de sauvegarde inexistants ou des conteneurs Docker disparus, prouvant l’utilité de cette méthode. En combinant audit interactif et vérification immédiate, l’auteur évite une refonte hasardeuse et s’assure que la nouvelle version du script correspond à l’état actuel du serveur.

L’article de Maxence Maireaux analyse le retour du mythe du 10x engineer avec l’essor de l’IA, illustré par une thèse récente selon laquelle l’IA polariserait le métier de développeur. Les ingénieurs les plus compétents, capables de superviser et valider le travail des agents IA, deviendraient indispensables, tandis que les profils moyens seraient marginalisés. Les données, comme celles du rapport DORA 2024 ou des études METR, montrent cependant que l’IA peut aussi réduire la stabilité des livraisons et creuser l’écart entre productivité perçue et réelle, comme en témoignent des cas concrets de code généré sans vérification approfondie.

L’auteur reconnaît la pertinence du diagnostic sur les risques de la confiance aveugle dans l’IA, qui accélère l’accumulation de dette technique et la perte de connaissance des systèmes. Cependant, il critique la conclusion économique qui en découle, comparant ce raisonnement au mythe du 10x engineer, popularisé par une étude contestable des années 1960 et aujourd’hui relancé par l’IA. Ce mythe, qui glorifie les "stars" individuelles, ignore les leçons des recherches en psychologie organisationnelle, comme celles de Google, qui soulignent l’importance de la sécurité psychologique et du travail d’équipe plutôt que du talent isolé.

En conclusion, l’article met en garde contre la résurgence de cette croyance simpliste, rappelant que l’efficacité collective repose davantage sur des dynamiques collaboratives que sur des individus exceptionnels. L’IA, loin de justifier une segmentation extrême du métier, devrait plutôt inciter à repenser les méthodes de travail pour éviter les pièges de la productivité illusoire et de la dépendance technologique.