L’article explique comment structurer une architecture logicielle en trois couches (Domaine, Application, Infrastructure) en respectant la règle d’or centripète et le principe d’inversion de dépendance (DIP). L’idée centrale est que les dépendances doivent toujours aller du plus concret (infrastructure) vers le plus abstrait (domaine), jamais l’inverse, afin de préserver l’indépendance et la testabilité de la logique métier.

Le domaine concentre les règles métier, les agrégats (unités cohérentes comme un dossier de demande de subvention) et les value objects (objets immuables sans identité propre). Il définit des ports (interfaces) pour les besoins externes, sans jamais dépendre d’outils comme Doctrine ou Symfony. La couche applicative gère les cas d’usage via des handlers qui orchestrent les flux, tandis que l’infrastructure implémente concrètement ces ports (ex : adaptateurs pour Doctrine ou S3), sans jamais être importée par les couches supérieures.

Cette approche garantit que le métier reste isolé des détails techniques. Par exemple, un handler utilise DepositRequestRepositoryInterface (port défini dans le domaine) sans connaître son implémentation (DoctrineDepositRequestRepository en infrastructure). Ainsi, les changements d’outils n’affectent pas la logique métier, et les imports PHP respectent strictement la hiérarchie des couches.

L’article de LifeDev présente douze habitudes simples pour une productivité durable, s’opposant à la culture du hustle qui privilégie l’épuisement au travail. L’idée centrale est que des pratiques équilibrées, comme bien dormir ou planifier sa journée à l’avance, préservent la santé mentale et physique tout en maintenant une performance constante sur le long terme. Les études citées montrent que travailler excessivement réduit l’efficacité après 50 heures par semaine, soulignant l’importance de méthodes réalistes.

Parmi les habitudes recommandées, la priorité au sommeil (7 à 9 heures) est mise en avant comme outil clé pour la clarté mentale et la créativité, tandis que la planification nocturne permet d’aborder la journée avec plus de sérénité. D’autres pratiques incluent des pauses régulières, l’activité physique quotidienne et le single-tasking, évitant ainsi la surcharge cognitive.

L’auteur insiste sur l’adaptabilité de ces habitudes à tout mode de vie, les présentant comme des piliers pour éviter l’épuisement et maintenir une productivité stable, surtout dans un contexte de travail à distance et de sollicitations numériques constantes.

SysWatch est un outil en ligne de commande pour diagnostiquer les performances d'un système en temps réel, conçu pour remplacer des commandes comme htop, iostat ou nettop. Il propose douze onglets couvrant les principaux sous-systèmes (CPU, mémoire, disques, GPU, etc.) et affiche des informations claires en anglais, avec des alertes d'anomalies dans un onglet dédié.

L'outil se distingue par sa simplicité d'installation (via Rust) et son interface intuitive, permettant de naviguer entre les onglets, de trier les données ou de rembobiner une session pour analyser l'historique. Une fonction de détection heuristique signale les problèmes courants (surcharge mémoire, processus gourmands, etc.) avec des suggestions de correction.

SysWatch cible principalement les systèmes macOS et Linux, évitant les dépendances système inutiles et les requêtes sudo superflues. Il se positionne comme un complément à NetWatch, avec une approche minimaliste et transparente sur les limitations techniques.

curl.md est un outil open source conçu pour convertir des pages web en markdown optimisé, réduisant ainsi le nombre de tokens utilisés par les agents IA. Son objectif principal est d'améliorer l'efficacité des interactions avec les modèles de langage en fournissant des données structurées et moins volumineuses.

Le projet propose plusieurs méthodes d'utilisation, notamment via une commande curl directe, une installation en ligne de commande (CLI) ou l'intégration avec des agents comme Claude ou OpenCode. Il est également compatible avec des SDK pour une utilisation programmatique dans des applications.

Développé sous licence MIT, curl.md est maintenu par la communauté et offre une documentation complète ainsi qu'un espace de discussion pour les contributions et les retours d'expérience.

Claude-Red est une bibliothèque organisée de compétences en sécurité offensive conçue pour le système Claude Skills, permettant de transformer l'IA en un acteur du red teaming. Chaque compétence est un fichier structuré SKILL.md couvrant des surfaces d'attaque variées, comme les injections SQL, le développement d'exploits, l'évasion d'EDR ou encore les attaques sans fil (Wi-Fi, WPA2/3).

Le projet, développé par SnailSploit, propose une approche modulaire où les compétences sont chargées dynamiquement selon les besoins, évitant ainsi une surcharge contextuelle. Il s'adresse aux professionnels pour des engagements autorisés, des recherches de vulnérabilités, des CTF ou des formations, avec une méthodologie experte intégrée.

L'installation est flexible : clone du dépôt, script dédié ou sélection de catégories spécifiques (web, Active Directory, etc.). Le dépôt inclut aussi des outils comme convert_skills.py pour adapter les compétences et une documentation complète pour contribuer ou exploiter les fichiers.

L’article explique comment intégrer CrowdSec Manager dans l’architecture Pangolin sans exposer directement son interface sensible sur Internet. L’auteur détaille une solution sécurisée en utilisant le SSO de Pangolin et le service Newt, évitant ainsi l’ouverture d’un port externe. L’objectif est de centraliser la gestion des alertes et des décisions de CrowdSec via une interface protégée, tout en maintenant une architecture Zero Trust.

L’auteur souligne les risques liés à l’exposition directe de l’interface (port 8080) et propose une configuration où CrowdSec Manager est accessible uniquement via le réseau Docker interne, protégé par le SSO. Cette approche limite les surfaces d’attaque tout en permettant une administration centralisée. L’article inclut des détails techniques sur la configuration Docker et les bonnes pratiques pour gérer les secrets via Gitea Actions.

Enfin, l’auteur compare les fonctionnalités de CrowdSec Manager (dashboard, gestion des alertes, bouncers) à ses limites, notamment l’absence de remplacement complet des outils de sécurité traditionnels. L’article s’inscrit dans une série dédiée à Pangolin, avec une approche pragmatique pour renforcer la sécurité d’une stack auto-hébergée.

L’article explique pourquoi les architectures CRUD (Create, Read, Update, Delete) compliquent les tests unitaires et augmentent la charge cognitive des développeurs. L’auteur souligne que la logique métier, dispersée dans des contrôleurs, services, FormType ou événements Doctrine, devient difficile à identifier et à tester, favorisant la duplication de code et les erreurs. Les modifications nécessitent de comprendre des interactions complexes, ralentissant le développement et augmentant le risque de régressions.

L’auteur illustre ce problème avec des exemples concrets en Symfony, où des règles métiers se cachent dans des couches techniques variées (validations dans les formulaires, effets de bord dans les écouteurs Doctrine). Cette dispersion empêche une couverture de test efficace, car les tests doivent souvent simuler des dépendances externes (bases de données, envoi d’emails) plutôt que de se concentrer sur la logique pure.

Enfin, l’article critique l’illusion des services génériques, qui masquent la complexité sans résoudre le problème de fond. La solution proposée est de distinguer clairement les contrats d’entrée (validation des données) des invariants métiers (règles de transition), afin de structurer le code de manière plus testable et maintenable.

Cet article présente une approche optimisée pour le développement Symfony en utilisant des Dev Containers sans root, Xdebug 3.4 et PHP 8.4, afin d’améliorer l’expérience développeur (DX). L’auteur met en avant l’utilisation de FrankenPHP, un serveur d’applications performant en Go, remplaçant Nginx + PHP-FPM, pour des temps de réponse rapides. La solution repose sur des conteneurs isolés et sécurisés, évitant les problèmes de permissions classiques avec Docker.

L’accent est mis sur la compatibilité IDE (VS Code et PhpStorm) et la résolution des écueils courants, comme les conflits d’architecture ou les montages de volumes. Les conteneurs rootless résolvent les erreurs de permissions en mappant l’utilisateur du conteneur à l’utilisateur local, éliminant le besoin de commandes comme chmod -R 777.

Enfin, l’article détaille la création d’un projet Symfony 7.4 via un conteneur temporaire pour Composer, sans installation locale de PHP. Le choix de l’image Docker (Alpine vs Debian) est crucial pour éviter des incompatibilités avec certains IDE, comme les plantages de JetBrains.

L’article explique comment réduire significativement la consommation de tokens de Claude Code, un outil d’IA coûteux, en optimisant son utilisation. L’auteur souligne que les coûts explosent rapidement, notamment sur des projets complexes, avec des factures pouvant atteindre plusieurs centaines d’euros par jour en cas de mauvaise gestion. Il détaille ensuite des astuces pour limiter cette dépense, comme l’exploitation du Prompt Caching, qui permet de réutiliser des contextes déjà analysés sans relire systématiquement l’intégralité du code.

L’idée centrale repose sur la compréhension du mécanisme de lecture systématique de Claude Code, qui charge inutilement des fichiers (README, configurations, dépendances) avant toute action, générant des milliers de tokens inutiles. L’auteur propose des solutions concrètes, inspirées de retours d’expérience partagés en ligne, pour cibler cette source de gaspillage. Parmi elles, la configuration d’un fichier CLAUDE.md pour guider l’IA et éviter les explorations redondantes.

Enfin, l’article compare les tarifs des modèles (Sonnet, Opus, Haiku) et insiste sur l’importance de choisir le bon modèle selon l’usage. Il mentionne aussi les alternatives comme LiteLLM pour suivre les coûts sur des plateformes comme AWS ou Google Cloud. L’objectif est clair : diviser par cinq la consommation de tokens sans sacrifier la qualité des résultats, en combinant optimisation technique et bonnes pratiques.

Ce dépôt GitHub propose un outil open source nommé text-to-cad permettant de générer des modèles 3D via des agents de codage comme Codex ou Claude Code. L'idée centrale est de transformer des descriptions textuelles en fichiers CAD (STEP, STL, 3MF, DXF, etc.) et en descriptions robotiques (URDF), avec un workflow local et sans dépendance à un backend. L'outil inclut un explorateur intégré pour visualiser les modèles et des compétences prédéfinies pour la conception, la robotique et la fabrication.

Le projet se distingue par son approche modulaire, avec des compétences regroupées dans des dossiers dédiés (.agents/skills, .claude/skills) et une compatibilité avec les standards industriels. Les utilisateurs peuvent décrire un objet, laisser l'agent modifier les fichiers sources, puis régénérer les artefacts avant de les inspecter et de les valider. Le dépôt met l'accent sur la reproductibilité, avec des références stables (@cad[...]) pour des modifications précises.

En complément, le dépôt propose des benchmarks et des exemples pour évaluer les performances des agents, tout en optimisant les téléchargements via Git LFS pour éviter de charger des fichiers lourds inutilement. La licence MIT et la documentation détaillée facilitent l'adoption et l'extension du projet.

Cet article explique comment utiliser les CTE (Common Table Expressions) avec Doctrine ORM en PHP pour optimiser des requêtes SQL complexes. Les CTE permettent de structurer des requêtes récursives ou décomposées, évitant ainsi des traitements applicatifs coûteux comme le problème N+1. L’exemple illustre la récupération des catégories parentes d’une catégorie donnée via une CTE récursive, plus efficace qu’une approche PHP itérative.

Doctrine ne supportant pas nativement les CTE dans son QueryBuilder ou DQL, l’auteur propose une solution alternative en utilisant une requête SQL native avec un ResultSetMappingBuilder pour mapper les résultats sur des entités. La requête CTE commence par identifier la catégorie de départ, puis remonte récursivement via les relations parent_id, tout en triant les résultats par profondeur.

L’article souligne l’intérêt des CTE pour des cas comme les hiérarchies arborescentes, tout en reconnaissant leur rareté dans le code courant. La méthode proposée contourne les limitations de Doctrine pour exploiter pleinement les capacités des SGBD modernes.

Cette page présente l’infrastructure auto-hébergée de l’auteur, composée d’applications variées déployées via Ansible ou ArgoCD sur un cluster Kubernetes. L’idée principale est de partager ces outils, certains orientés usage quotidien (Nextcloud, Vaultwarden, Jellyfin) et d’autres plus techniques (Paperless-ngx, SignaturePDF), tout en soulignant leur caractère self-hosted pour préserver la confidentialité des données.

Parmi les applications détaillées, Nextcloud avec CollaboraCode et Vaultwarden se distinguent par leur utilité grand public, tandis que Paperless-ngx et SignaturePDF illustrent des solutions spécialisées pour la gestion documentaire. L’auteur met en avant des outils comme Ovumcy, axé sur la santé, ou Fittrackee pour le suivi sportif, reflétant une approche pragmatique mêlant praticité et respect de la vie privée.

L’infrastructure inclut aussi des services comme GoAuthentik pour l’authentification ou Kresus (malgré des limites liées aux changements d’API bancaire), démontrant une volonté d’autonomie technique. L’auteur invite à découvrir ou suggérer d’autres outils, via sa page de contact, tout en insistant sur l’évolution constante de son lab.

L’article de Nicolas Jourdan critique la pratique courante de lier directement les formulaires Symfony aux entités Doctrine, soulignant les problèmes d’architecture qui en découlent. L’auteur explique que cette approche crée un couplage implicite entre la couche de présentation (formulaire) et le modèle métier (entité), transformant cette dernière en simple transporteur de données HTTP. Bien que pratique à court terme, cette méthode introduit des tensions lorsque l’application évolue, notamment en mélangeant les responsabilités (validation, normalisation) et en rendant le code difficile à maintenir.

L’exemple concret d’un formulaire d’inscription à une conférence illustre ces limites. Les règles métier (comme la vérification de la capacité des sessions ou l’expiration des codes promo) finissent par être dispersées entre les contraintes du formulaire et celles de l’entité, complexifiant la logique et réduisant la clarté du code. L’auteur met en garde contre cette approche, qui semble initialement simple mais devient problématique sous la pression des évolutions produit.

Pour remédier à ces problèmes, Jourdan propose une séparation plus nette entre les formulaires et les entités, en utilisant des objets dédiés (DTO) pour capturer les données brutes de l’utilisateur avant de les transformer en entités métier. Cette méthode permet de préserver l’intégrité du domaine tout en gérant plus efficacement les interactions utilisateur, évitant ainsi les compromis architecturaux coûteux à long terme.

En 2026, PHP et Symfony s’imposent comme une stack mature et performante pour les CTO, grâce à des évolutions majeures. PHP 8.5, avec ses fonctionnalités typées (property hooks, pipe operator) et son JIT optimisé, ainsi que Symfony 7 et son écosystème de plus de cinquante composants découplés, couvrent désormais tous les besoins modernes : API (API Platform), e-commerce (Sylius), back-office (EasyAdmin), temps réel (Mercure), interfaces réactives (Live Components) et même le mobile via Hotwire Native. L’outillage industriel (PHPStan, Rector, PHPUnit 13) garantit une qualité de code élevée, tandis que FrankenPHP révolutionne l’infrastructure avec un throughput 3 à 4 fois supérieur à PHP-FPM et une latence divisée par cinq en mode worker.

L’auteur, CTO freelance avec quatorze ans d’expérience, souligne que cette stack n’est plus un compromis nostalgique mais une option par défaut, adaptée aux SaaS, applications métiers complexes ou projets IA-first. L’écosystème Symfony, autrefois perçu comme fragmenté, s’est structuré pour offrir une solution cohérente, réduisant les délais de développement et simplifiant la maintenance grâce à une expertise accumulée.

L’article s’adresse aux CTO et lead tech en quête d’une vision actualisée, mettant en avant la maturité de PHP/Symfony en 2026 : un langage strict et performant, un framework complet et un outillage industriel, le tout sans nécessiter de superposer des technologies front-end ou mobiles.

Kula est un outil léger et autonome de monitoring pour serveurs Linux, conçu pour être simple à déployer. Il fonctionne sans dépendances externes ni bases de données, sous forme d'un binaire unique, et collecte des métriques système en temps réel via les interfaces /proc et /sys. Les données sont stockées dans un moteur de stockage intégré basé sur un buffer circulaire, permettant une rétention efficace des informations.

L'outil surveille un large éventail de paramètres, incluant l'utilisation du CPU, de la mémoire, du réseau, des disques, ainsi que des températures, l'état des batteries et des conteneurs. Les métriques sont accessibles via une interface web en temps réel ou un tableau de bord en terminal, avec une granularité allant jusqu'à la seconde. Kula prend également en charge le monitoring d'applications spécifiques comme PostgreSQL ou Nginx, ainsi que des métriques personnalisées.

Développé en Go, Kula est distribué sous licence AGPL-3.0 et propose des versions précompilées pour différentes architectures. Son architecture modulaire et son approche sans base de données externe en font une solution adaptée aux environnements où la simplicité et la légèreté sont prioritaires.

OpenWarp est un fork décentralisé et open source du terminal Warp, conçu pour intégrer des modèles d'IA directement dans un environnement terminal tout en garantissant la confidentialité des données. Contrairement à la version originale, OpenWarp conserve les données (identifiants, conversations, clés) localement sur la machine de l'utilisateur, sans passer par un serveur externe. Il propose six protocoles natifs (DeepSeek, Anthropic, OpenAI, etc.) et supporte les endpoints compatibles OpenAI, avec une configuration simplifiée via un fichier TOML.

Le fonctionnement repose sur trois étapes : capture des commandes sous forme de blocs contextuels (incluant le répertoire, l'environnement et la sortie), routage direct vers le fournisseur d'IA choisi sans intermédiaire, et retour des résultats dans une interface utilisateur familière. OpenWarp conserve l'ergonomie de Warp (Blocs, Workflows) tout en remplaçant le backend IA propriétaire par une architecture locale et modifiable.

L'outil s'adapte aux préférences de l'utilisateur en permettant de personnaliser les fournisseurs d'IA, les invites et les agents CLI, avec des modèles de prompts dynamiques rendus via minijinja. Disponible sous licence open source, il cible les développeurs souhaitant un terminal intelligent sans dépendre de services cloud externes.

L’article relate l’expérience de l’auteur avec Varnish 9 et son support natif du TLS, combiné à Let’s Encrypt pour sécuriser les connexions. Il détaille le déploiement d’une machine virtuelle Debian 13 sur Hetzner Cloud, où Varnish a été installé via un dépôt APT officiel, simplifiant ainsi le processus. L’auteur souligne l’absence de complications avec IPv6 et l’utilisation d’un sous-domaine dédié pour les tests.

Pour les tests, une application FastAPI minimaliste a été créée, simulant une réponse lente (2 secondes) pour évaluer les performances de mise en cache de Varnish. Les résultats montrent une réduction significative du temps de réponse après le premier appel, passant de 2,4 secondes à 230 millisecondes, illustrant l’efficacité du cache.

Enfin, l’auteur évoque brièvement le fichier de configuration VCL par défaut de Varnish, qui nécessite des ajustements pour une utilisation optimale, notamment pour la gestion du TLS et des certificats Let’s Encrypt, dont la configuration sera abordée dans un futur billet.

Uptime Kuma est un outil open source de surveillance de services web, présenté comme une alternative gratuite et auto-hébergée à Uptime Robot. Contrairement à ce dernier, limité à 50 moniteurs dans sa version gratuite, Uptime Kuma permet un nombre illimité de sondes sans abonnement, tout en offrant des fonctionnalités avancées comme la surveillance SSL/TLS, des alertes personnalisables (email, Telegram, Discord, etc.) et une interface moderne. Il prend en charge divers protocoles (HTTP, TCP, DNS, etc.) et propose une page de statut publique pour informer les utilisateurs.

L’article explique comment installer Uptime Kuma via Docker sur un VPS, en détaillant les étapes de configuration avec Traefik comme reverse proxy. Il souligne que, bien que l’outil soit auto-hébergé et respectueux de la vie privée, ses vérifications dépendent du serveur local, contrairement à des solutions comme Uptime Robot qui testent depuis plusieurs zones géographiques. Les prérequis incluent un VPS, Docker, un nom de domaine et un reverse proxy configuré.

Enfin, le guide met en avant la flexibilité d’Uptime Kuma, avec des options de personnalisation poussées (intervalles de vérification, notifications multi-services) et une sécurité renforcée (authentification, 2FA). Il convient particulièrement aux particuliers ou PME souhaitant surveiller des services critiques sans dépendre d’un tiers, tout en évitant les coûts récurrents des solutions payantes.