L’auteur explique pourquoi il a attendu d’avoir Redis et un worker Messenger avant de migrer vers Symfony Scheduler en production. Selon lui, sans ces deux éléments, le Scheduler ne serait qu’un cron amélioré, sans les fonctionnalités avancées comme l’asynchronicité, la persistance des états ou la gestion des échecs. Il souligne que Symfony Scheduler ne remplace pas cron, mais s’appuie sur une infrastructure adaptée pour offrir des mécanismes de planification robustes.

L’article détaille trois prérequis essentiels avant d’utiliser le Scheduler : un worker Messenger consommant en continu le transport dédié, un transport asynchrone pour éviter les blocages (comme Redis), et un pool de cache non volatile pour stocker l’état des tâches. Sans ces éléments, l’auteur estime que l’on recréerait les limitations des scripts cron, mais avec une complexité inutile.

Enfin, l’auteur illustre son propos avec cinq jobs actuellement exécutés sur son site, montrant comment le Scheduler simplifie la gestion des tâches récurrentes une fois l’infrastructure en place. Il conclut que le Scheduler est pertinent uniquement si l’environnement technique le permet, évitant ainsi les solutions hybrides peu fiables.

L’article interroge la qualité croissante des logiciels et l’impact de l’IA sur leur fiabilité, dans un contexte marqué par des failles de sécurité fréquentes et des fuites de données. L’auteur souligne que les vulnérabilités (CVE) ont fortement augmenté depuis 2017, attribuant cette hausse à des facteurs comme la pression des mises à jour quotidiennes, l’expansion du numérique et l’intensification des cyberattaques, plutôt qu’à l’IA. Il relativise cependant ce lien, notant que les CVE reflètent aussi une meilleure détection des bugs et une industrie cyber en croissance.

L’auteur évoque des exemples concrets, comme des failles majeures chez GitHub ou des attaques contre des institutions françaises, pour illustrer la dégradation perçue de la qualité logicielle. Il critique l’idée selon laquelle l’IA serait la principale responsable, soulignant que la baisse de fiabilité précède son adoption massive et s’explique davantage par des enjeux économiques et géopolitiques.

Enfin, l’article aborde la perception selon laquelle l’IA accélérerait la production de "code de merde", une idée que l’auteur juge exagérée. Il conclut que la qualité des logiciels dépend davantage des pratiques de développement et des pressions du marché que de l’IA, tout en reconnaissant que cette dernière pourrait aggraver certains problèmes si mal utilisée.

L’article explique comment résoudre le problème des requêtes N+1 dans Symfony 8.1 avec Doctrine ORM, un fléau pour les performances des applications. Il détaille d’abord le mécanisme du N+1, où une requête initiale récupère N entités, puis N requêtes supplémentaires chargent leurs relations, dégradant fortement les performances en production.

L’auteur propose des stratégies avancées pour l’éviter, comme l’utilisation de DQL avec JOIN FETCH pour charger les entités et leurs relations en une seule requête, ou encore des modes de récupération précis et l’hydratation via des DTO. Ces méthodes, combinées à des outils comme le Symfony Web Profiler, permettent d’optimiser significativement les endpoints.

Ce dépôt GitHub propose un bundle Symfony natif en PHP pour instrumenter les applications avec OpenTelemetry, sans nécessiter d'extension C. Il permet un traçage automatique des requêtes HTTP, des commandes console, des appels HttpClient, des messages Messenger, des tâches Scheduler, des requêtes Doctrine DBAL, du cache, de Twig et des logs via Monolog, avec une corrélation des traces. Compatible avec divers backends comme Traceway, Jaeger ou Datadog, il supporte Symfony 6.4 à 8.x et garantit une propagation correcte des contextes de trace, même sous charge.

L'installation est simplifiée via Composer, avec une configuration minimale pour exporter les traces en OTLP. Le bundle gère automatiquement l'enregistrement des spans pour chaque composant Symfony, capturant des détails comme les routes, les codes HTTP, les exceptions ou les requêtes sortantes. Une version 2.0 améliore la configuration imbriquée tout en maintenant la rétrocompatibilité.

Le projet met l'accent sur la fiabilité et la performance, avec des tests CI couvrant Doctrine DBAL 3 et 4, et des garde-fous contre les récursions dans les exports. La documentation détaille les composants traçables et les options de configuration avancées, comme les métriques optionnelles pour Messenger ou DBAL.

ROM Finder est un outil en ligne permettant de trouver des ROM alternatives pour smartphones. Il référence 623 appareils compatibles issus de 27 constructeurs, avec 5 systèmes alternatifs disponibles. Les informations sont mises à jour régulièrement et proviennent des sources officielles des projets concernés.

Ce billet de blog, deuxième partie d’un test sur CKE (Clever Cloud Kubernetes Engine), explore les fonctionnalités avancées de stockage sur ce service managé. L’auteur détaille notamment l’activation du Container Storage Interface (CSI) via une commande simple, permettant l’utilisation de Ceph RBD pour des volumes persistants, avec une StorageClass configurée par défaut et la possibilité d’étendre les volumes à chaud. Il illustre ensuite le déploiement d’un PersistentVolumeClaim (PVC) et son utilisation dans un pod, confirmant la persistance des données après redémarrage.

L’article aborde également des cas d’usage concrets comme le déploiement de vCluster, un cluster Kubernetes virtuel fonctionnant dans le cluster hôte, partageant son infrastructure de stockage. L’auteur teste cette solution, soulignant ses avantages potentiels pour l’isolation des environnements (comme des environnements CI) tout en partageant les ressources, bien qu’il reste sceptique sur certains aspects de sécurité.

Enfin, le billet conclut sur les fonctionnalités de gestion du cycle de vie des volumes, incluant les snapshots et la restauration de données, avec une procédure technique détaillée en plusieurs étapes. L’auteur résume son expérience en mettant en avant la simplicité de mise en œuvre et la flexibilité offerte par CKE pour des besoins de stockage avancés dans Kubernetes.

L’article souligne que Symfony, souvent perçu comme un framework monolithique, peut être utilisé comme un simple adapter pour isoler la logique métier du code lié au framework. L’auteur explique que, malgré une architecture apparente propre (contrôleurs légers, services organisés), une application Symfony mature reste profondément couplée à Doctrine et Symfony, ce qui limite sa maintenabilité et sa portabilité. Il illustre ce problème par un exemple concret où l’entité Order gère directement des calculs de taxes via des annotations Doctrine, montrant ainsi une dépendance implicite au framework.

Pour résoudre ce couplage, l’auteur propose une architecture en trois couches : le Domain (PHP pur, sans dépendances externes), l’Application (cas d’utilisation et interfaces) et l’Infrastructure (adaptateurs Symfony/Doctrine). Cette séparation stricte permet de tester et faire évoluer le domaine indépendamment du framework. Un contrôle CI vérifie que le dossier Domain/ n’importe jamais de classes Symfony ou Doctrine, garantissant ainsi l’étanchéité de l’architecture.

Enfin, l’auteur compare cette approche à celle d’un projet Laravel, insistant sur le fait que Symfony, comme tout framework, doit être traité comme un outil d’infrastructure et non comme le cœur de l’application. L’objectif est de rendre le code plus résilient aux changements technologiques tout en conservant la puissance de Symfony pour les aspects HTTP, persistance ou messagerie.

L’article explique comment configurer Symfony pour l’architecture hexagonale en utilisant l’autowiring, simplifiant ainsi la gestion des dépendances. L’idée principale est d’éviter les configurations XML complexes en exploitant les fonctionnalités modernes de Symfony (autowiring, autoconfigure et un bloc bind minimal), réduisant services.yaml à moins de vingt lignes pour un contexte métier entier. L’auteur illustre cette approche avec une structure de projet claire, où les interfaces (ports) définies dans la couche Domain sont automatiquement liées à leurs implémentations (adaptateurs) dans Infrastructure sans configuration explicite.

L’exemple montre comment une classe d’application comme PlaceOrder dépend uniquement d’interfaces (ex. OrderRepository, Clock, EventBus), laissant Symfony injecter les bonnes implémentations (ex. DoctrineOrderRepository, SystemClock) via l’autowiring. Trois paramètres dans services.yaml (autowire, autoconfigure et public) suffisent pour automatiser cette injection, tandis qu’un attribut PHP 8.3 gère les cas ambigus. L’article souligne que cette méthode élimine le besoin de fichiers de configuration verbeux, tout en respectant les principes de découplage de l’architecture hexagonale.

L’article d’Alex Bespoyasov explore l’application de l’architecture propre (Clean Architecture) au développement frontend, en s’appuyant sur une présentation et des exemples concrets. L’idée centrale est de structurer le code en couches distinctes (domaine, application et adaptateurs) pour améliorer la maintenabilité et l’extensibilité des applications, même face à des changements fréquents. L’auteur illustre cette approche en concevant une boutique de cookies avec React et TypeScript, tout en soulignant que la méthode reste compatible avec d’autres frameworks ou bibliothèques.

L’architecture propre vise à séparer les responsabilités selon leur proximité avec le domaine métier, centralisant ainsi les règles métier et réduisant les dépendances externes. Bespoyasov insiste sur la composition des composants pour faciliter les modifications futures, en citant Rich Hickey pour appuyer cette philosophie. Bien que l’exemple utilise React et TypeScript, l’auteur précise que ces outils ne sont pas obligatoires, et que l’accent est mis sur les principes plutôt que sur une implémentation rigide.

Enfin, l’article propose des pistes pour approfondir, comme des méthodologies complémentaires adaptées à différents types de projets. Bespoyasov rappelle que l’objectif est de comprendre l’idée plutôt que de reproduire servilement les exemples, encourageant les développeurs à adapter ces principes à leurs besoins spécifiques.

L’auteur explique pourquoi une nouvelle YubiKey 5C ne pouvait plus déverrouiller sa base KeePassXC, alors qu’il utilisait auparavant une YubiKey configurée avec le même secret HMAC-SHA1. Le problème vient de la méthode de provisionnement : les anciens outils (YubiKey Personalization Tools) utilisaient des options avancées non documentées, tandis que les outils récents (ykman) standardisent le processus, générant des réponses différentes pour un même secret.

Il souligne la dépendance implicite au logiciel initial, désormais obsolète, qui pourrait devenir difficile à utiliser à l’avenir. Yubico a en effet abandonné ses outils graphiques au profit de ykman, rendant la compatibilité rétroactive problématique. L’auteur recommande de reprogrammer les clés avec ykman et de mettre à jour le challenge-response dans KeePassXC, tout en sauvegardant un accès alternatif à la base avant toute manipulation.

Enfin, il détaille brièvement la procédure pour recréer le challenge HMAC-SHA1 dans KeePassXC via les options de sécurité, en utilisant la ligne de commande (ykman) pour configurer le slot 2 de la YubiKey. Une migration proactive évitera des difficultés futures lors du remplacement d’une clé.

Cette page propose le transcript d’une conférence de Pascal Martin intitulée « Des structures de données qui vont vous étonner », donnée notamment lors de la PyConFR 2025. L’auteur y explore des structures de données méconnues mais utiles, soulignant leur importance pour optimiser les performances des applications. Il illustre son propos avec des exemples concrets, comme les éditeurs de texte, et rappelle les bases des complexités algorithmiques (notation grand O) pour justifier le choix des structures adaptées.

La conférence met en lumière la diversité des structures de données, souvent ignorées au profit de solutions classiques comme les tableaux ou les listes chaînées. Pascal Martin en présente trois particulièrement pertinentes pour des besoins quotidiens, tout en insistant sur l’intérêt de ne pas réinventer la roue. Le transcript, proche du style oral, inclut des précisions absentes des slides, enrichissant la compréhension des concepts abordés.

Destiné aux développeurs et développeuses, ce contenu vise à éveiller la curiosité sur des outils peu exploités, tout en rappelant l’importance de sélectionner la bonne structure en fonction des contraintes algorithmiques. Le document s’accompagne de liens vers les slides et d’archives pour approfondir.

L’article explique comment utiliser Symfony Messenger pour gérer les événements du domaine sans créer de couplage excessif. L’idée principale est de séparer clairement l’interface du domaine (ports) de l’implémentation technique (adaptateurs), en s’inspirant de l’architecture hexagonale. Ainsi, le domaine reste indépendant du framework, utilisant des interfaces comme DomainEvent et EventBus pour publier des événements sans dépendre de Symfony Messenger.

L’auteur illustre cette approche avec un exemple concret : un événement OrderPlaced est défini comme une classe PHP simple, sans annotations ni dépendances vers Messenger. Les agrégats du domaine enregistrent ces événements dans une collection interne, puis l’application les publie via une implémentation de EventBus qui utilise Messenger en arrière-plan. Cela permet de changer de transport (AMQP, Redis, etc.) sans modifier le code métier.

Enfin, l’article souligne l’importance de maintenir cette séparation pour éviter les problèmes de couplage, comme des noms de classes ou de namespaces qui briseraient le code en cas de modification du framework. L’objectif est de conserver une architecture propre et maintenable, où le domaine reste au centre et les détails techniques en périphérie.

Les fuites massives de données permettent aux escrocs de personnaliser leurs spams avec des informations précises (adresse, numéro de sécurité sociale, etc.), rendant les arnaques plus crédibles. Ils ciblent désormais des victimes spécifiques plutôt que d’envoyer des messages génériques, augmentant ainsi l’efficacité de leurs tentatives de fraude.

Pour éviter de tomber dans le piège, il est crucial de vérifier l’expéditeur des e-mails. Une adresse frauduleuse peut imiter une entreprise légitime (ex. : vinci-autoroute.com au lieu de vinci-autoroutes.com), ou utiliser un domaine inattendu (ex. : .fi pour une entreprise française). Même les détails subtils, comme une lettre modifiée (rnicrosoft.com au lieu de microsoft.com), doivent être examinés.

Enfin, la règle d’or reste de ne jamais cliquer sur les liens contenus dans un e-mail suspect. Un simple clic peut confirmer à l’escroc que l’adresse est active, même sans interaction supplémentaire. La prudence et la vérification systématique des sources sont essentielles pour se protéger.