JoliCode relate la création d'une machine virtuelle PHP en Rust, rendue possible grâce à l'intelligence artificielle. L'idée principale est que les modèles de langage ont réduit la complexité de comprendre des bases de code inconnues et d'explorer des stratégies d'implémentation, rendant des projets ambitieux comme celui-ci plus accessibles. L'article souligne que l'IA ne produit pas de logiciel prêt pour la production, mais accélère significativement les phases de recherche et de prototypage.

Le premier prototype, bien que fonctionnel et réalisé en une journée, était extrêmement lent et adoptait une approche naïve. Il reproduisait une machine virtuelle à pile, contrairement à l'architecture registre de PHP, ce qui aurait pu poser des problèmes de compatibilité avec l'écosystème PHP existant. Ce prototype a cependant validé la faisabilité du projet, tout en montrant la nécessité d'une architecture plus réfléchie.

L'objectif n'était pas de copier fidèlement le moteur Zend de PHP, mais d'en tirer des enseignements pour concevoir une machine virtuelle alignée avec la philosophie de Rust. Cela implique d'adopter la gestion de la mémoire par ownership, d'éviter les états mutables globaux et de minimiser l'usage de code unsafe, afin de tirer pleinement parti des avantages de Rust plutôt que de simplement traduire du C en Rust.

Quien est un outil en ligne de commande conçu pour analyser en profondeur un nom de domaine ou une adresse IP, offrant une alternative plus complète que la commande classique whois. Il centralise plusieurs fonctionnalités comme la recherche d’informations d’enregistrement, l’analyse DNS, la configuration email (MX, SPF, DMARC) et l’évaluation SEO (balises, données structurées, Core Web Vitals).

L’outil propose une interface interactive (TUI) et une sortie au format JSON pour une intégration dans des scripts. Son installation est flexible, disponible via Homebrew, APT ou directement avec Go. Des sous-commandes permettent de cibler des analyses spécifiques, comme les données DNS ou la stack technique d’un site.

Quien peut aussi être testé sans installation via ssh quien.sh, ce qui le rend accessible rapidement. Il se positionne comme une solution pratique pour remplacer whois au quotidien, en fournissant des données plus détaillées et structurées.

Blackfire permet de profiler du code PHP s'exécutant dans un consumer ou un worker (comme une commande Symfony en boucle), contrairement à l'usage classique déclenché via une requête HTTP. L'outil utilise les signaux POSIX pour activer ou désactiver le profilage à la volée, sans interrompre le processus en cours. Par exemple, un signal comme SIGUSR2 peut lancer le profilage, tandis qu'un autre signal (comme SIGTERM) l'arrête et génère le rapport.

L'article explique comment implémenter cette solution avec Symfony 5.2+, grâce à l'interface SignalableCommandInterface, qui simplifie la gestion des signaux sans recourir à pcntl_signal(). La commande doit définir les signaux à intercepter via getSubscribedSignals() et traiter les signaux reçus dans handleSignal(), en retournant false pour continuer l'exécution ou un code de sortie pour l'arrêter.

Pour activer Blackfire dans ce contexte, il faut d'abord l'installer via Composer (composer require blackfire/php-sdk). L'article souligne que cette approche est particulièrement utile pour analyser les performances de tâches en arrière-plan, comme la consommation de files de messages, sans avoir à modifier le code métier du consumer.

L’article critique l’usage des entités Doctrine dans Symfony, notamment leur double rôle de modèle de données et de formulaire, qui crée des incohérences entre les contraintes PHP, les validateurs et la base de données. Par exemple, une propriété marquée comme obligatoire (#[Assert\NotBlank], colonne SQL non nullable) peut être définie comme optionnelle en PHP (?string $name = null), permettant la création d’objets invalides qui ne seront rejetés qu’au moment du flush(). Cette approche fragilise la cohérence du code, notamment en violant les principes SOLID et DDD, et retarde la détection des erreurs.

L’auteur illustre ce problème par un cas concret où une commande d’import en production échoue à cause d’un champ vide dans un fichier CSV, alors que les tests et PHPStan passaient. Le code PHP autorise temporairement des données incomplètes (pour les formulaires), mais la base de données impose des contraintes strictes, révélant une contradiction entre les couches applicatives. Cette dualité entraîne des invariants non protégés, un modèle anémique et des vérifications redondantes de null dans le code métier.

Pour résoudre ces problèmes, l’article suggère de séparer clairement les responsabilités : utiliser des entités Doctrine strictes pour la persistance et des DTO (Data Transfer Objects) pour les interactions avec les formulaires. Cela permet de garantir la validité des données dès leur création et d’éviter les incohérences entre les types PHP, les validateurs et le schéma de la base de données.

L’article explique comment générer automatiquement la documentation AsyncAPI pour les événements Symfony, en s’inspirant de la génération d’OpenAPI pour les API REST. L’idée centrale est d’utiliser le bundle zeusi/asyncapi-bundle pour extraire les contrats des événements (messages, canaux, payloads) directement depuis le code, via des attributs PHP, évitant ainsi une documentation manuelle sujette aux erreurs.

AsyncAPI standardise la description des systèmes asynchrones (AMQP, Kafka, etc.), offrant des avantages similaires à OpenAPI : interface navigable, validation des schémas et source unique de vérité. Le bundle repose sur l’hypothèse que chaque message est représenté par une classe DTO annotée avec #[AsyncApiMessage], permettant de déduire la structure des données et le canal associé.

La configuration minimale se limite à l’installation du bundle et à la définition des métadonnées du document AsyncAPI. Les messages sont déclarés via des attributs, simplifiant la maintenance et garantissant la cohérence entre le code et la documentation générée.

Cette page explore le fonctionnement du réseau internet et des communications modernes à partir de principes fondamentaux. Elle explique comment les données (voix, messages, vidéos) sont transformées en signaux électriques, lumineux ou radio, traversant des infrastructures complexes et indépendantes pour atteindre leur destination en quelques millisecondes. L’auteur souligne l’absence de contrôle centralisé, malgré la fiabilité impressionnante du système, qui repose sur des protocoles comme le packet switching, TCP ou DNS, chacun répondant à des problèmes spécifiques apparus au fil du temps.

L’article retrace aussi l’évolution historique des réseaux, bien antérieurs à l’informatique, depuis les systèmes mécaniques (comme les fils entre boîtes en métal) jusqu’aux réseaux électriques et numériques. Il montre que l’internet actuel est le résultat d’ajouts successifs, où chaque couche protocolaire corrige des limites concrètes, plutôt que d’une conception globale. Cette approche progressive explique pourquoi certaines technologies, comme les câbles sous-marins, restent essentielles malgré leur âge.

Enfin, l’auteur vise à rendre compréhensibles les mécanismes invisibles du web, comme la sécurité des connexions (TLS), les latences ou les pannes de routage, en les reliant à une vision cohérente des réseaux. L’objectif est de transformer des mystères quotidiens en connaissances intuitives, en partant des bases physiques jusqu’aux couches logicielles.

SANDYNE est une station de travail audio numérique (DAW) gratuite et open source, conçue pour composer, enregistrer et mixer de la musique sur Linux, Windows et macOS. L'application propose des instruments intégrés (12 au total), des effets (27+), ainsi que des outils d'automatisation et d'export (WAV, MP3, pistes séparées). La version 1.5.0, sortie en juillet 2026, introduit des fonctionnalités comme un éditeur de hauteur, la conversion audio vers MIDI et des pistes de tempo.

L'interface repose sur trois éditeurs (notes, audio, batterie) intégrés à une timeline unique, permettant de manipuler mélodies, enregistrements et motifs rythmiques. Les pistes s'organisent via des racks modulables, où l'on peut enchaîner effets MIDI, instruments (y compris des VST3 externes) et effets audio dans n'importe quel ordre. Le mixage inclut des groupes, du ducking et un mastering intégré.

Parmi les instruments intégrés figurent des synthétiseurs originaux (comme Terrain ou Syna), des sons orchestraux, des batteries électroniques et des outils vocaux (vocodeur, voix synthétique). Sandyne se distingue par son approche intuitive, sans abonnement ni compte requis, et s'adresse aussi bien aux débutants qu'aux professionnels grâce à des outils avancés en ligne de commande.

Domenic Denicola partage son environnement de développement agentique optimisé pour l’IA, conçu pour permettre une collaboration fluide avec des modèles avancés comme Claude Code. Son objectif principal est de pouvoir corriger des bugs en production directement depuis un smartphone, même en déplacement, tout en garantissant une continuité de travail entre différents appareils. Pour cela, il utilise une machine virtuelle Linux dédiée et toujours active, couplée à Tailscale pour un accès sécurisé et transparent, ainsi que des outils comme Portless et chezmoi pour centraliser les configurations et préserver l’état des projets.

Son approche repose sur une VM Linux, indispensable pour éviter les limitations des environnements Windows, souvent incompatibles avec les outils en ligne de commande utilisés par les agents. Il insiste sur la nécessité de préserver les sessions, l’état des fichiers et les configurations globales, tout en permettant le lancement de serveurs de développement accessibles uniquement en local ou via HTTPS. La gestion des permissions est simplifiée pour minimiser les interruptions, autorisant même des modes de fonctionnement autonomes pour des tâches parallèles.

MapLibre GL JS est une bibliothèque TypeScript utilisant WebGL pour afficher des cartes interactives dans un navigateur à partir de tuiles vectorielles. Son apparence est définie par un document de style conforme à la spécification MapLibre Style, et elle s’intègre à l’écosystème MapLibre, incluant des versions pour Android et iOS.

La documentation propose un guide de démarrage rapide avec un exemple minimal en HTML et JavaScript, ainsi que des instructions pour l’installation via npm ou en utilisant des modules ES. Elle détaille aussi les sections principales, comme les objets de carte, les marqueurs, les sources de données et la gestion des événements.

L’outil prend en charge divers bundlers (Vite, webpack, etc.) et nécessite une configuration spécifique pour le worker WebGL. Des exemples de code et des ressources complémentaires sont disponibles pour faciliter l’intégration.

L’auteur documente son approche d’une "usine logicielle" intégrant l’IA pour automatiser la production de code, tout en maintenant un contrôle strict sur la qualité logicielle. L’idée centrale est que l’IA excelle dans la génération de code, mais que la qualité dépend aussi de l’intention produit, de la gestion des risques (valeur, utilisabilité, faisabilité, viabilité) et de la fiabilité. L’outillage repose sur un context engineering précis, où des fichiers structurés (CLAUDE.md, règles thématiques, contraintes long terme) fournissent le contexte nécessaire aux agents, optimisé pour éviter la surcharge de tokens et les erreurs.

L’usine logicielle est organisée en couches : contexte (fichiers de référence), compétences (skills déterministes), outils (MCP, GitNexus, mémoire persistante), garde-fous (hooks, tests d’architecture) et processus de production (quality gates bloquantes, tests multi-étages). L’auteur souligne l’importance de standardiser les procédures pour limiter les risques, comme les dépendances non souhaitées dans un futur open source, vérifiées par des tests automatisés.

Enfin, l’auteur reconnaît des défis persistants, comme la standardisation des règles, l’évitement des rabbit holes (dérives coûteuses) et la mise à jour continue des compétences. Bien que le code soit quasi 100 % généré, la responsabilité humaine reste centrale pour garantir que le logiciel répond aux besoins métiers et techniques, au-delà de la simple production de code.

La veille technologique chez Kapt met en lumière l’importance pour les développeurs de s’appuyer sur des outils et bibliothèques existants plutôt que de réinventer systématiquement la roue. L’entreprise, spécialisée dans le développement logiciel, illustre cette approche avec un exemple concret : la restriction d’accès à certaines pages d’un site pour des utilisateurs spécifiques, en utilisant le framework Django. Plutôt que de coder manuellement chaque vérification, Kapt exploite des fonctionnalités intégrées ou des modules prêts à l’emploi pour gagner en efficacité et en fiabilité.

L’article souligne que cette stratégie permet de se concentrer sur des tâches à plus forte valeur ajoutée, tout en réduisant les risques d’erreurs. Cependant, il rappelle aussi que l’utilisation de ces "machins tout faits" nécessite une veille active pour identifier les solutions les plus adaptées et éviter les pièges liés à leur intégration ou maintenance. Une métaphore humoristique compare ces outils à des roues métaphoriques, facilitant le travail des développeurs sans pour autant remplacer leur expertise.

L’article explique les React Server Components (RSC) dans Next.js, une technologie qui sépare clairement le rendu côté serveur et côté client. L’idée centrale est de privilégier des composants "mort" (statiques, sans JavaScript) pour le contenu comme les articles ou les pieds de page, et des composants "vivants" (interactifs) uniquement pour les éléments nécessitant une interaction utilisateur. Cette approche réduit la taille des bundles et améliore les performances, tout en simplifiant la gestion des données (accès direct à la base de données côté serveur).

L’auteur partage son expérience en production, soulignant trois pièges courants : l’ajout excessif de directives "use client" qui alourdit inutilement le code client, les waterfalls de requêtes asynchrones ralentissant le rendu, et l’activation accidentelle du rendu dynamique via des fonctions comme cookies(). Il recommande de limiter les composants clients aux fonctionnalités indispensables et d’isoler les parties dynamiques pour conserver un rendu statique optimisé.

Enfin, l’article conseille d’adopter les RSC dès un nouveau projet Next.js, tandis que pour une application existante, une migration progressive des routes les plus lourdes (en termes de contenu) est préférable. L’auteur illustre ces principes avec son propre site, où les pages d’articles sont entièrement statiques, tandis que des fonctionnalités comme un chat ou des formulaires restent interactives.

L'article de Jay Freestone propose une approche pour éviter la duplication des règles métier entre frontend et backend en privilégiant le partage de politiques plutôt que de code. L'idée centrale est que les règles, comme la validation d'état d'une commande, doivent être centralisées côté serveur pour éviter des incohérences lorsque les deux parties évoluent indépendamment. Plutôt que de partager des fonctions ou des modules (risquant des divergences de versions ou de déploiement), l'auteur suggère de transmettre les décisions sous forme de données structurées, comme les actions autorisées ou les raisons de désactivation, permettant au frontend de s'adapter dynamiquement.

L'auteur illustre cette méthode avec un exemple concret : au lieu de dupliquer une fonction canCancelOrder en TypeScript à la fois dans l'API et l'interface, le backend renvoie un objet JSON contenant les actions possibles (allowedActions) et les motifs de désactivation (disabledReasons). Cette approche, inspirée des principes HATEOAS, simplifie la maintenance et garantit la cohérence des règles, tout en restant compatible avec des architectures polyglottes où le partage de code est complexe.

Nicolas Martignole, Principal Engineer chez Back Market, partage son expérience d’un an à accompagner plus de 300 ingénieurs dans l’adoption de l’IA générative. Il souligne une transformation radicale du métier, passant d’un codage manuel à la supervision d’agents automatisés, comparant ce changement à l’abandon du franc pour l’euro. L’adoption de l’IA s’est généralisée, avec seulement 6 à 8 % de réfractaires, souvent pour des raisons éthiques ou écologiques, tandis que les juniors, sans posture à défendre, sont les plus enthousiastes.

L’expérience professionnelle influence fortement les réticences : les profils seniors, attachés à leur expertise technique, résistent davantage que les juniors. Un conflit interne a illustré cette tension, aboutissant au départ d’un senior ayant tenté de limiter l’accès à l’IA pour des juniors motivés. À l’inverse, Martignole observe que les personnes neuroatypiques, comme un collègue Asperger, progressent rapidement grâce à l’IA, qui facilite leur communication.

Enfin, il évoque les défis organisationnels, comme la gestion des quotas d’utilisation pour éviter l’épuisement, illustrant les ajustements nécessaires face à cette révolution technologique. Son témoignage met en lumière à la fois les opportunités et les résistances liées à l’intégration de l’IA dans les pratiques professionnelles.

Exit Chat Control alerte sur la menace des réglementations européennes Chat Control (1.0 et 2.0), qui autorisent ou imposeraient le scan des messages privés pour détecter des contenus pédocriminels, instaurant une surveillance de masse. En juillet 2026, le Parlement européen a rejeté une motion contre Chat Control 1.0, bien que les messageries chiffrées de bout en bout en soient temporairement exclues. Chat Control 2.0 (CSAR), plus intrusif, prévoit un scan obligatoire même sur ces messageries via une technique de scan côté client, assimilable à un logiciel espion intégré à l’appareil.

Le site propose un manuel de souveraineté numérique pour se protéger, détaillant des alternatives aux outils centralisés et surveillés, comme des messageries chiffrées, des navigateurs respectueux de la vie privée ou des systèmes d’exploitation libres. L’objectif est de reprendre le contrôle de ses données avant que les scans ne deviennent obligatoires, notamment avec l’entrée en vigueur de Chat Control 1.0 en 2028 et les négociations en cours sur sa version 2.0.

L’article met en garde contre le "bruit documentaire" généré par l’IA, soulignant que cette technologie facilite la production rapide de documentation technique, mais souvent au détriment de sa pertinence. Si l’IA peut décrire le quoi et le comment, elle néglige le pourquoi, essentiel pour comprendre les choix d’architecture et leurs contextes.

L’auteur souligne que la documentation automatisée risque de devenir pléthorique sans valeur ajoutée, car elle n’est ni relue ni appropriée par les équipes. Une documentation utile doit refléter une intention humaine et conserver l’historique des décisions, ce que l’IA ne peut pas générer seule.

Enfin, il conclut que l’IA peut assister la rédaction et la maintenance, mais la responsabilité de déterminer ce qui mérite d’être documenté et de transmettre la réflexion derrière les choix reste humaine.

Ce billet de Pascal Martin aborde la réalité du développement logiciel, où les développeurs passent souvent plus de temps à maintenir ou modifier du code existant qu’à en écrire de nouveau. L’auteur souligne que, même au sein d’une équipe, la connaissance approfondie d’un projet est rarement partagée par tous ses membres, chacun intervenant principalement sur des parties spécifiques. Il évoque aussi l’absence historique de pratiques comme les revues de code ou les tests automatisés, qui auraient pu faciliter cette maîtrise collective.

Martin illustre son propos par son expérience personnelle, où il a souvent dû intervenir sur des bases de code inconnues, que ce soit en SSII ou en tant qu’éditeur de logiciels. Il note que même les projets développés from scratch reposent souvent sur des composants partagés, et que l’ajout de nouveaux développeurs ne garantit pas une connaissance exhaustive du code.

Enfin, il remet en question l’idée reçue selon laquelle une équipe connaît parfaitement son propre projet, rappelant que les absences, les départs ou le simple passage du temps rendent cette maîtrise illusoire. Il interroge ainsi les pratiques de passation de connaissances et de documentation au sein des équipes.

L’auteur présente la création d’un serveur MCP (Model Context Protocol) intégré à une application Symfony, permettant à une IA comme Claude d’interagir avec un tableau de bord interne de suivi de projets. Ce serveur, sécurisé par OAuth des deux côtés (client et serveur), utilise l’authentification Google Workspace pour restreindre l’accès aux membres de l’organisation. Les outils MCP, définis comme des classes invocables avec des attributs dédiés, exposent des fonctionnalités comme la liste des projets ou des alertes de sécurité, avec des paramètres typés et des schémas JSON générés automatiquement à partir des signatures PHP.

L’implémentation repose sur le bundle MCP de Symfony AI, configuré via YAML pour définir les transports (stdio pour le développement, HTTP pour la production) et les instructions destinées à l’IA. Chaque outil, comme list-projects, est conçu comme un service Symfony minimaliste, exploitant l’injection de dépendances et des annotations pour décrire ses capacités. Les paramètres, contraints par des attributs comme #[Schema], permettent une interaction structurée avec les données du tableau de bord.

Cette approche illustre une intégration fluide entre Symfony et les protocoles modernes d’IA, offrant une alternative sécurisée aux requêtes manuelles tout en exploitant les mécanismes existants de l’application. L’auteur souligne la réutilisation des bonnes pratiques Symfony (services, configuration, typage) pour un serveur MCP fonctionnel et maintenable.

L’auteur explique avoir migré son blog de WordPress vers EmDash après 12 ans d’utilisation, citant des raisons de maintenance et de sécurité. EmDash, un CMS inspiré de WordPress mais plus léger, permet d’importer facilement le contenu existant, y compris les images, tout en offrant une interface d’administration similaire.

Le nouveau système repose sur Cloudflare Workers, une plateforme serverless qui limite les risques de sécurité grâce à un runtime restreint. L’auteur souligne les avantages de cette solution, comme l’utilisation de services intégrés (D1, R2, KV) et une consommation de ressources optimisée, idéale pour un site à faible trafic.

EmDash adopte une approche plus sécurisée que WordPress en limitant les capacités des plugins, qui s’exécutent dans des environnements isolés. L’auteur souligne que la plupart des fonctionnalités nécessaires sont déjà intégrées ou facilement développables, réduisant ainsi le besoin de dépendre de modules externes.

L’article explique que la commande git rebase -i est souvent redoutée par les développeurs, alors qu’elle est en réalité simple et utile pour réorganiser, modifier ou supprimer des commits. L’auteur illustre son fonctionnement avec un exemple concret où il combine des commits et en supprime un autre, montrant que les changements restent maîtrisables grâce à des commandes comme pick, reword, squash ou drop.

L’auteur insiste sur la sécurité de cette opération, soulignant qu’il est possible d’annuler un rebase à tout moment avec git rebase --abort et que les anciens commits ne sont pas effacés, mais simplement remplacés par de nouveaux. Le reflog de Git permet même de restaurer l’état précédent en cas d’erreur, rendant le processus réversible et sans risque majeur.

Enfin, l’article défend l’importance d’un historique Git propre, considéré comme un indicateur de professionnalisme, et encourage les développeurs à surmonter leurs craintes pour tirer pleinement parti de cette fonctionnalité.