La durée de vie maximale des certificats TLS publics sera progressivement réduite à 200 jours en 2026, puis à 47 jours en 2029, rendant le renouvellement manuel intenable. Cette décision, adoptée par le CA/Browser Forum, impose un calendrier strict sans dérogation, avec une validation de domaine (DCV) réutilisable seulement 10 jours à partir de 2029. Les autorités de certification, co-sponsors de cette mesure, privilégient désormais des modèles économiques basés sur des souscriptions et des plateformes de gestion automatisée.

Le renouvellement manuel, autrefois annuel, devient ingérable avec des échéances semestrielles dès 2026, trimestrielles en 2027, puis toutes les six semaines en 2029. Les infrastructures automatisées, comme ACM sur AWS ou ACME, deviennent indispensables pour éviter les interruptions de service. Un exemple concret illustre cette contrainte : un certificat wildcard hérité, géré manuellement, a nécessité une intervention urgente en raison de sa durée de vie désormais limitée.

Cette transition, motivée par des impératifs de sécurité (réduction des fenêtres d’exploitation des clés compromises), s’aligne aussi avec les intérêts commerciaux des autorités de certification. Leur modèle évolue vers des abonnements et des solutions de gestion centralisée, rendant les processus manuels obsolètes et coûteux.

L’article explore les solutions pour bloquer les trackers et domaines malveillants via un résolveur DNS menteur, en exploitant le mécanisme RPZ (Response Policy Zone). L’auteur, confronté aux limites d’un adblocker sur son Turris, teste plusieurs résolveurs DNS (Bind9, Knot-resolver, Unbound, Blocky, Pi-hole) pour évaluer leur capacité à filtrer efficacement les requêtes. Il souligne l’importance de RPZ, qui permet de bloquer des domaines, des IP ou des plages d’IP, tout en offrant une alternative aux outils traditionnels comme Pi-hole ou Blocky.

Pour automatiser la gestion des listes RPZ, l’auteur a développé un script Python, rpz-maker.py, capable de combiner, dédupliquer et optimiser des listes de domaines par catégorie, avec des options de personnalisation avancées. Ce script, sans dépendances externes, simplifie la configuration et permet une gestion fine des autorisations et restrictions par réseau client.

Enfin, l’article présente un tableau comparatif des résolveurs testés, évaluant leur simplicité de configuration, leur interface en ligne de commande, leur support des ACL, leur interface web, leur compatibilité avec Prometheus et Redis Sentinel. Blocky et Knot-resolver (version 6) ressortent comme les solutions les plus équilibrées, tandis que Pi-hole et Unbound se distinguent par leur flexibilité mais avec des compromis en termes de complexité ou de consommation de ressources.

L’article de GreenIT propose sept réflexes pour réduire l’impact environnemental de l’intelligence artificielle (IA), en insistant sur l’IA frugale comme solution efficace et économique. L’idée centrale est de questionner le besoin réel d’IA, notamment générative, souvent surutilisée alors que des alternatives plus simples (comme des tableaux de bord) suffisent. Par exemple, une entreprise a remplacé un LLM par un outil classique, économisant 150 kg de CO₂eq par mois, tandis qu’une autre a combiné IA symbolique et générative pour diviser par 100 ses émissions.

L’auteur recommande ensuite d’opter pour le modèle le plus petit possible, car sa taille influence directement sa consommation de ressources. Les modèles massifs, comme ChatGPT (2 000 milliards de paramètres), sont souvent disproportionnés pour des tâches courantes, où des modèles 200 fois plus légers (10 milliards de paramètres) peuvent suffire. Des études, comme celle de Luccioni et al., montrent que des modèles 60 fois plus petits restent performants, voire supérieurs pour certaines applications.

Enfin, l’article souligne que l’IA frugale permet non seulement de limiter l’empreinte écologique, mais aussi de réduire les coûts. En évitant les solutions surdimensionnées et en privilégiant des approches adaptées, les entreprises peuvent concilier performance et durabilité, tout en répondant à leurs besoins réels sans céder à la tendance du "toujours plus gros".

Pour rester motivé face aux échecs, Scott H. Young souligne que la persévérance n’est pas toujours rationnelle : abandonner peut être la meilleure solution si les alternatives sont plus avantageuses. Il explique que les échecs répétés réduisent la motivation, car les progrès positifs comptent moins que les reculs, et que le manque d’efficacité personnelle peut créer un cercle vicieux. Young partage son expérience personnelle, ayant lui-même surmonté des années de doute avant de réussir, tout en insistant sur l’importance d’évaluer objectivement si continuer est justifié.

La « vibecoding fatigue » désigne une lassitude nouvelle touchant les développeurs informatiques, épuisés par l’utilisation intensive de l’IA générative. Cette fatigue, aussi appelée AI brain fry, résulte de la nécessité de valider en permanence le travail des outils d’IA, qui produisent rapidement mais génèrent aussi davantage d’erreurs. Un ingénieur cité dans l’article compare cette situation à « mettre sa bougie de productivité sur un lance-flammes », illustrant l’épuisement accru malgré une cadence de travail soutenue.

Les conséquences de cette tendance sont mesurables : une étude de 2026 révèle que 39 % d’erreurs graves supplémentaires sont générées par l’IA, tandis que 88 % des salariés les plus productifs grâce à ces outils déclarent souffrir de burn-out. Les développeurs, en tant qu’utilisateurs et concepteurs d’outils d’IA, sont en première ligne, mais d’autres métiers du langage, comme les journalistes ou les juristes, pourraient être touchés à leur tour.

Les modèles d’IA actuels, optimisés pour le code en raison de sa vérifiabilité, ont accéléré cette dynamique. Les entreprises du numérique, étudiées dans le cadre de recherches, observent une adaptation difficile à cette nouvelle forme de charge cognitive, soulignant un basculement dans l’organisation du travail.

REX DevLille 2026 : l’IA et le pragmatisme redéfinissent l’ingénierie logicielle

La conférence DevLille 2026 a mis en lumière l’impact croissant de l’IA dans le développement logiciel, au-delà des promesses marketing, ainsi que l’importance du pragmatisme face aux excès d’architectures complexes ou de réunions inefficaces. Les retours d’expérience soulignent une tendance à recentrer les pratiques sur l’efficacité et l’inclusivité, avec des outils concrets pour améliorer la collaboration.

Maxime Clément a abordé la problématique des Pull Requests (PR) interminables, souvent difficiles à relire en raison d’un manque de contexte et d’un ordre de fichiers peu intuitif. Sa solution propose de structurer les commits comme une narration, facilitant la compréhension des modifications. L’IA peut automatiser cette réorganisation, mais son usage doit être encadré pour éviter des commandes risquées, tout en gardant à l’esprit que les commits restent avant tout un outil pour les développeurs.

Par ailleurs, Vanessa Chodaton a évoqué les raisons du départ des femmes de la tech, un enjeu sociétal crucial pour l’industrie. Ces discussions reflètent une volonté de rendre le secteur plus durable et équitable, en intégrant des réflexions sur l’inclusion et les conditions de travail.

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.