L’IA est un outil puissant pour accélérer et optimiser le développement, pas pour remplacer les devs. L’article illustre comment intégrer l’IA à chaque étape d’un projet (ex. : un site de location de voitures) : planification (génération de briefs et wireframes en quelques minutes), design (création d’interfaces et de code HTML/CSS via des outils comme v0.dev), boilerplate (conversion rapide en React/TypeScript avec des prompts précis), et amélioration (refactoring collaboratif pour rendre le code scalable et propre). L’IA automatise les tâches répétitives (recherche, design, code basique), mais c’est au développeur de superviser, architecturer et corriger les imperfections (logique métier, réutilisabilité). L’enjeu ? Travailler plus intelligemment, en utilisant l’IA comme un "pair programmer" pour se concentrer sur les défis complexes (architecture, UX, performance). À condition de rester critique : l’IA génère du code, mais c’est à vous d’en garantir la qualité et l’éthique. "Un dev qui maîtrise l’IA aura toujours un avantage."
L’article démystifie les différences entre piles (jetables, non rechargeables), accumulateurs (rechargeables, souvent appelés à tort "piles rechargeables") et batteries (assemblages de cellules). Il explique les formats standardisés (AA, AAA, 18650, etc.), les technologies (alcaline, NiMH, lithium-ion, sodium-ion), et leurs avantages/inconvénients : les piles alcalines peuvent fuir, les lithium-ion offrent de hautes performances mais sont inflammables, tandis que le sodium-ion émerge comme une alternative plus écologique et sûre. Le choix entre piles et accumulateurs dépend de l’usage : les accumulateurs sont recommandés pour les appareils gourmands en énergie ou critiques, mais leur coût et leur gestion (éviter de mélanger les modèles, surveiller la capacité) peuvent limiter leur intérêt pour un usage occasionnel. L’article donne aussi des conseils pour choisir des marques, des chargeurs (privilégier les modèles USB-C avec mesure de capacité) et optimiser la durée de vie des batteries (éviter les charges/décharges extrêmes, privilégier la charge lente). Une ressource utile pour y voir plus clair et faire des choix éclairés, tant pour l’environnement que pour le portefeuille.
L'auteur analyse et améliore la section "hero" du site Time.com, critiquant notamment le passage trop précoce à un affichage mobile (1 colonne) qui gaspille l’espace disponible sur les écrans intermédiaires. Il propose une approche plus flexible et progressive, en utilisant des techniques CSS modernes : CSS Grid, container queries, display: contents, style queries, grid areas, et le sélecteur :has() pour créer un layout adaptatif et dynamique. L’objectif est de laisser le contenu guider la mise en page, avec des transitions fluides entre 1, 2 et 3 colonnes, tout en optimisant l’espace et la lisibilité. L’article illustre aussi l’utilisation des query units (cqw) pour des tailles de police fluides et des astuces comme text-wrap: pretty pour équilibrer les titres. Une démonstration concrète de comment construire des layouts robustes et modulaires avec du CSS avancé.
L'articleremet en question l'utilisation des service subscribers, une pratique courante dans les projets Symfony pour gérer les dépendances occasionnelles. L'auteur propose une alternative en utilisant des événements et des écouteurs pour cibler les dépendances nécessaires, plutôt que de tout centraliser dans une seule classe. Par exemple, au lieu d'utiliser un AbstractController et de charger toutes les dépendances dans le constructeur, il suggère de créer des événements spécifiques pour chaque action (comme l'envoi d'un e-mail ou la génération d'un PDF) et d'utiliser des écouteurs pour gérer ces événements. Cela permet une meilleure séparation des responsabilités et une plus grande flexibilité. L'article conclut en encourageant les développeurs à réfléchir avant d'utiliser des service subscribers et à envisager d'autres moyens pour éviter les dépendances occasionnelles, comme l'injection de dépendances directement dans les méthodes des contrôleurs.
L'article explore l'outil PHPMD (PHP Mess Detector), qui analyse le code PHP pour détecter des problèmes de qualité et de complexité. L'auteur explique la notion de complexité cyclomatique, introduite par Thomas McCabe, qui mesure le nombre de chemins d'exécution possibles dans un code, et montre comment PHPMD peut aider à identifier des zones problématiques où cette complexité est trop élevée. L'article décrit l'installation et la configuration de PHPMD, ainsi que ses différentes règles pour améliorer la qualité du code, comme CleanCode, CodeSize, et Naming. Il aborde également l'intégration de PHPMD dans des workflows de développement, par exemple avec PHPStorm ou GitHub Actions, et discute des métriques avancées pour évaluer la qualité du code. En conclusion, l'auteur encourage les développeurs à utiliser PHPMD régulièrement pour maintenir un code propre et maintenable, malgré les critiques parfois sévères de l'outil.
L'article discute de la mise en place d'un système de surveillance efficace qui aide les équipes à mieux dormir la nuit sans avoir besoin de tableaux de bord complexes. L'auteure aborde le problème de la fatigue des alertes, où un trop grand nombre d'alertes, souvent fausses, conduit à ignorer les vraies urgences. Elle propose une règle simple : se concentrer sur trois types d'alertes principaux : les pannes, les ralentissements et les pics d'erreurs. L'article recommande de commencer avec des signaux clés comme la latence et le taux d'erreurs, et de concevoir des tableaux de bord simples et lisibles, avec des indicateurs visuels clairs. Il souligne également l'importance de logs utiles et de vérifications de santé efficaces. Enfin, l'auteure suggère d'utiliser des outils simples et de concevoir les alertes en pensant à l'expérience humaine, en les rendant actionnables et informatives.
L'article explore comment certaines propriétés CSS, bien que conçues pour améliorer la mise en page, peuvent nuire à l'accessibilité pour les utilisateurs de technologies d'assistance. Il met en lumière des problèmes subtils liés à l'utilisation de propriétés comme display et list-style, qui peuvent altérer la sémantique des éléments HTML, rendant les tableaux et les listes inaccessibles, notamment sur Safari avec VoiceOver. L'article propose des solutions, telles que l'utilisation de rôles ARIA pour préserver l'accessibilité, et offre une checklist pour garantir que les styles CSS ne compromettent pas l'accessibilité avant le déploiement d'un projet.
Dans son article, Lea Verou aborde les défis rencontrés lors de la création de composants web accessibles et localisables en 2025, tout en présentant deux composants qu'elle a développés pour afficher les "likes" de Bluesky. Elle partage des conseils pratiques sur l'utilisation des éléments <slot> et des attributs pour la personnalisation, tout en mettant l'accent sur la balance bénéfice / effort de développement.
L'article liste une série d'astuces et bonnes pratiques pour la rédaction de prompts pour la programmation
L'article explique comment organiser efficacement votre code pour améliorer la lisibilité et la maintenabilité. Il couvre l'utilisation de lignes shebang pour rendre les scripts exécutables, l'organisation des instructions d'importation selon les conventions PEP 8, et la création de points d'entrée principaux avec des blocs if name == "main". L'article aborde également la gestion des dépendances avec PEP 723, la manipulation des arguments en ligne de commande avec des bibliothèques comme Click, et l'amélioration de la structure interne des données avec des énumérations et des dataclasses. Enfin, il propose des conseils pour améliorer les retours des scripts, comme l'utilisation de bibliothèques telles que Rich pour une meilleure présentation des sorties.
L'article détaille la stack technique de Shopify, révélant comment la plateforme gère une échelle massive avec une architecture qui semble simple en surface, mais qui est en réalité le résultat de décisions architecturales astucieuses et de nombreuses années de refactoring. Shopify utilise principalement Ruby on Rails pour son backend, avec des investissements significatifs dans des outils comme YJIT et Sorbet pour améliorer les performances et la sécurité du typage. Le frontend est principalement construit avec React et TypeScript, tandis que React Native est utilisé pour le développement mobile. Shopify s'appuie sur MySQL pour sa base de données principale, avec des stratégies de sharding et de pods pour assurer l'isolation et la scalabilité. Kafka est utilisé pour la messagerie et la distribution d'événements, tandis que des outils comme Memcached et Redis sont utilisés pour le caching et la gestion des files d'attente. L'infrastructure ML de Shopify utilise des embeddings pour la recherche en temps réel et des pipelines de données basés sur Apache Beam. La plateforme est déployée sur Kubernetes, avec des processus CI/CD robustes et des outils d'observabilité pour assurer la fiabilité et la sécurité. Shopify traite des milliards de requêtes par jour, démontrant l'efficacité de sa pile technologique à grande échelle.
L'article explore l'impact des outils de génération de code assistés par l'IA sur le développement logiciel moderne. Il met en lumière des outils comme Cursor et Windsurf, qui intègrent l'IA pour aider les développeurs à écrire du code plus rapidement et plus efficacement. Cursor, basé sur VSCode, offre des fonctionnalités comme la complétion de code intelligente et un chat intégré pour discuter des améliorations de code. Windsurf, quant à lui, va plus loin en permettant des refactorings complexes et une compréhension multi-fichiers. Cependant, l'article souligne également les défis et les pièges potentiels de ces outils, tels que la génération de code qui compile mais ne fonctionne pas comme prévu, l'accumulation de dette technique, et la dépendance excessive à l'IA qui pourrait entraîner une perte de compétences. En outre, l'article aborde l'intégration de ces outils dans les workflows de développement, notamment avec des plateformes comme Graphite et Diamond, qui automatisent les revues de code et améliorent la qualité logicielle. Enfin, il réfléchit sur l'avenir du métier de développeur, suggérant que les rôles évolueront vers une supervision et une orchestration accrues des outils d'IA, tout en maintenant une compréhension solide des fondamentaux du codage.
L'article explore l'impact de l'IA sur le développement logiciel à travers son expérience personnelle. Initialement sceptique, l'auteur a découvert que l'IA pouvait significativement améliorer sa productivité, notamment en générant du code pour des tâches répétitives et en servant de "rubber duck" pour résoudre des problèmes complexes. Il souligne que l'IA excelle dans l'automatisation des tâches banales, permettant aux ingénieurs de se concentrer sur des aspects plus créatifs et architecturaux du développement. Cependant, il met en garde contre une confiance aveugle dans les outils d'IA, insistant sur la nécessité de revoir et de tester soigneusement le code généré. l'auteur partage également des stratégies pour intégrer l'IA dans les flux de travail, comme l'utiliser dans les éditeurs de code et expérimenter avec différents modèles de prompts. En fin de compte, il encourage les développeurs à adopter l'IA de manière critique et réfléchie pour rester compétitifs dans un paysage technologique en évolution.
L'article explore comment les développeurs peuvent tirer parti de Cursor pour améliorer leur efficacité en codage. Il met en lumière des techniques pratiques telles que l'établissement de règles spécifiques au projet, la documentation de la structure du projet, et la rédaction de prompts efficaces pour guider l'IA. L'auteur partage également des conseils avancés comme le chaînage de prompts et l'itération progressive pour affiner les résultats. L'article souligne l'importance de superviser l'IA et de l'utiliser comme un accélérateur pour amplifier les compétences existantes plutôt que de remplacer l'expertise humaine.
L'article explore l'application de la Clean Architecture dans les applications PHP pour créer des systèmes découplés, testables et maintenables. L'auteur explique comment la Clean Architecture sépare les responsabilités en couches distinctes : Entités, Cas d'utilisation et Interfaces, en insistant sur le fait que la logique métier doit être indépendante des frameworks. Les contrôleurs, souvent surchargés dans les applications MVC traditionnelles, sont allégés en déléguant les tâches aux cas d'utilisation spécifiques. L'article souligne l'importance des interfaces sur les implémentations, facilitant ainsi les tests et la flexibilité. En suivant ces principes, les développeurs peuvent obtenir un code plus propre, plus facile à tester et à maintenir, tout en étant prêt pour une croissance future.
L'article explore une approche pour construire des applications en combinant les principes du Domain-Driven Design (DDD) et de l'architecture Clean. L'auteur propose de se concentrer sur les cas d'utilisation plutôt que sur les entités pures du DDD, en utilisant des cas d'utilisation pour orchestrer la logique métier inter-aggregats de manière claire et ciblée. L'article présente un exemple d'application simple avec des entités comme Student et Course, illustrant comment modéliser le domaine et gérer les relations entre les agrégats. Il préconise l'utilisation de l'ORM pour les opérations C(r)UD et des requêtes JDBC directes pour les requêtes impliquant plusieurs agrégats, s'inspirant des principes CQRS. Les cas d'utilisation sont transactionnels pour garantir la cohérence des états des agrégats. L'article conclut en soulignant les avantages de cette approche, notamment une meilleure compréhension du code et une facilité de test.
L'auteur décrit comment il a utilisé Claude pour développer une simple application météo : depuis le choix des technologies jusqu'à l'implémentation. Il donne quelques conseils sur le bon usage de l'IA pour l'aide au développement : importance du contexte, questionner les choix, etc.
L'auteur donne une série de conseils pour l'écriture de regex en JavaScript, du plus basique au plus complexe : ajout de flags, groupes de capture nommés, etc.
L'article présente une liste de conseils pour les tests avec PHPUnit, certains spécifiques à Laravel et d'autres non. J'en retiens :
- assertEqualsCanonicalizing qui permet de vérifier que 2 tableaux sont "égaux", sans tenir compte de l'ordonnancement des valeurs
- l'attribut #[\PHPUnit\Framework\Attributes\DoesNotPerformAssertions] qui permet de dire à PHPUnit qu'un test ne vérifie aucune assertion (ce qui déclenche normalement une erreur dans PHPUnit)
- l'attribut #[\PHPUnit\Framework\Attributes\RunInSeparateProcess] permet de préciser à PHPUnit d'exécuter les tests dans plusieurs processus... ça permet par exemple de définir une même constante dans 2 méthodes de tests de la même classe.
- la méthode $this->markTestSkipped('test are skipped because ...'); permet de sauter l'exécution d'un test, $this->markTestIncomplete('test are incomplete but not in error'); permet d'indiquer qu'un test est incomplet (??) et $this->fail('test are failed !'); permet de marquer un test comme échoué quoi qu'il arrive.
- phpunit --order-by=random permet de lancer les tests dans un ordre aléatoire - c'est très pratique pour détecter les dépendances implicites entre les tests. phpunit --order-by=random --random-order-seed=1234 permet même de rejouer le même ordre aléatoire, notamment pour reproduire un échec.
- phpunit --stop-on-failure --stop-on-error permet de stopper l'exécution des tests dès la première erreur rencontrée
- enfin en utilisant l'attribut #[\PHPUnit\Framework\Attributes\Group('mon_super_groupe')], on peut exclure les tests de ce groupe vendor/bin/phpunit --exclude-group mon_super_groupe ou au contraire ne jouer que les tests de ce groupe vendor/bin/phpunit --group flaky
L'article introduit les Signaux en tant que nouveau modèle mental pour la réactivité dans Angular, en se concentrant sur des variables réactives plutôt que sur des flux de données. Contrairement à RxJS, où les données sont traitées comme des flux, les Signaux permettent de lire les valeurs comme des variables, simplifiant ainsi la gestion des dépendances et des réactions. Cependant, cette approche nécessite une attention particulière pour éviter les dépendances implicites et les recalculs inattendus. Bien que les Signaux ne remplacent pas RxJS, ils offrent une alternative efficace pour la gestion de l'état local et les données dérivées dans les composants.