Scott H. Young partage son bilan d’un mois dédié à l’organisation et au rangement, après avoir lu cinq livres sur le sujet. Il en retire des principes clés : jeter avant de ranger, organiser par catégorie (et non par lieu), donner une place unique à chaque objet, et simplifier l’accès visuel aux affaires en évitant les contenants surchargés. Il souligne aussi que la plupart des papiers sont superflus et que le désencombrement passe par une phase de chaos avant d’aboutir à un espace plus fonctionnel et facile à maintenir. Malgré la difficulté du processus (notamment avec des enfants), il constate que ses espaces de vie et de travail sont désormais plus ordonnés et que l’effort d’entretien quotidien s’en trouve réduit. Une expérience qui l’incite à adopter une approche plus radicale face à l’accumulation d’objets inutiles.

L’observabilité full-stack passe aussi par le frontend – Longtemps considéré comme une boîte noire, le suivi des performances côté client (latence des interactions, complexité asynchrone, contexte utilisateur) est désormais possible grâce au tracing (OpenTelemetry, Sentry, Datadog). En instrumentant les clics, requêtes et rendus, on relie les actions utilisateurs aux traces backend, offrant une visibilité complète : identification précise des goulots d’étranglement, corrélation entre latence perçue et temps système, et débogage simplifié. Avec une implémentation simple (ex : @opentelemetry/sdk-trace-web), le frontend s’intègre enfin dans la chaîne d’observabilité, transformant l’expérience utilisateur en données exploitables.

Optimiser les PWAs selon leurs modes d’affichage — Les Progressive Web Apps (PWA) permettent de transformer une application web en une expérience proche du natif, mais cela peut aussi supprimer des fonctionnalités essentielles du navigateur (boutons retour, partage d’URL, etc.). L’article explique comment utiliser les requêtes média display-mode (standalone, fullscreen, minimal-ui, browser) et JavaScript pour adapter l’interface et l’expérience utilisateur en fonction du mode d’affichage. Par exemple, masquer les incitations à l’installation pour les utilisateurs ayant déjà installé l’app, ajouter des alternatives aux contrôles du navigateur, ou personnaliser le contenu pour un usage plus "app-like". Une approche progressive et ciblée permet de créer des PWAs plus intuitives et adaptées à chaque contexte d’utilisation.

L’auteur raconte sa migration de services auto-hébergés depuis un VPS vers un mini-PC à domicile (un Minisforum UM880 Plus), en profitant de l’occasion pour mettre en place une infrastructure plus flexible et robuste avec Proxmox VE. L’objectif est de pouvoir expérimenter (notamment avec Kubernetes) sans risquer de casser sa production, tout en sécurisant ses données via le chiffrement disque et des sauvegardes solides. Après avoir installé Debian avec chiffrement LUKS, il automatise la configuration de Proxmox et du réseau (pont bridge) via Ansible, afin de pouvoir recréer rapidement son infrastructure en cas de vol ou de panne matérielle. Il prévoit d’utiliser OpenTofu et cloud-init pour déployer et configurer des machines virtuelles de manière reproductible, et Ansible pour gérer la configuration des services. Le billet détaille aussi les écueils rencontrés (comme le blocage au démarrage après l’installation de Proxmox, résolu en configurant une IP statique) et explique comment son playbook Ansible permet de tout réinstaller automatiquement. Une suite est annoncée pour aborder le déploiement de VM et la gestion des services avec Kubernetes.

« Getting Creative With Images in Long-Form Content » (CSS-Tricks) explore comment les images, souvent reléguées à un rôle purement illustratif, peuvent dynamiser et enrichir l’expérience de lecture des contenus longs. L’article propose des techniques créatives pour intégrer les images de manière expressive : briser la grille classique pour attirer l’attention, jouer avec les formats (full-bleed, modular grids), utiliser les CSS Shapes pour un habillage de texte plus organique, ou encore repenser les légendes et l’espace blanc pour renforcer l’impact visuel et narratif. L’objectif ? Transformer les images en éléments actifs qui rythment la lecture, guident le regard et renforcent l’émotion, plutôt que de simples interludes visuels. Une approche inspirante pour les designers et rédacteurs qui veulent donner plus de personnalité à leurs articles, rapports ou études de cas.

Symfony, Doctrine et les triggers SQL sont souvent en tension : les triggers offrent une robustesse et une atomicité inégalées pour des logiques critiques (audit, validation, compteurs), mais leur gestion dans un projet Symfony reste complexe, car leur code SQL est souvent perdu dans des migrations ou invisible pour les développeurs. Le Trigger Mapping Bundle propose une solution élégante en permettant de déclarer les triggers directement dans les entités via des attributs PHP, les rendant ainsi visibles, versionnables et gérables comme le reste du code. Le bundle offre des commandes pour intégrer, créer, valider et mettre à jour les triggers, tout en facilitant la transition depuis un projet existant. L’objectif ? Réconcilier la puissance des triggers SQL avec la philosophie de Symfony et Doctrine, en choisissant le bon outil selon le besoin : trigger pour l’intégrité des données, listener Doctrine pour la logique applicative. Une approche qui réduit la dette technique et améliore la maintenabilité.

Gérer les dépendances Python avec pip freeze permet de capturer l’état exact des bibliothèques installées dans un environnement virtuel, en générant un fichier requirements.txt via la commande pip freeze > requirements.txt. Ce fichier liste toutes les dépendances (et leurs versions précises), assurant la reproductibilité du projet sur d’autres machines ou en production. Pour installer ces dépendances, il suffit d’exécuter pip install -r requirements.txt. Cependant, cette méthode ne distingue pas les dépendances directes des dépendances transitives, ce qui peut poser problème en cas de conflits de versions. Pour des projets plus complexes, des outils comme pip-tools ou Poetry offrent une gestion plus fine et structurée des dépendances, en générant un fichier de verrouillage cohérent. L’usage d’un environnement virtuel reste indispensable pour éviter les conflits entre projets. Lire plus.

L’article réfléchit sur l’auto-hébergement à domicile, une pratique qui consiste à gérer soi-même ses services (site web, mails, stockage, etc.) plutôt que de les confier à des prestataires externes. L’auteur rappelle que le cloud et le web reposent sur des machines physiques gérées par des tiers, ce qui soulève des questions de compétence, de sécurité, de souveraineté et de dépendance politique (exemples : incendie du datacenter OVH à Strasbourg, surveillance étatique). Bien que des solutions comme Yunohost ou OpenMediavault facilitent la mise en place d’un serveur domestique, l’auteur souligne les risques (pannes, attaques, perte de données) et la complexité de maintenir un service fiable et sécurisé 24/7. Il distingue l’auto-hébergement "pour jouer" (projets personnels, tests) de l’hébergement professionnel, qu’il préfère déléguer à des experts, même chez les GAFAM, pour des usages critiques (mails, site à fort trafic). Il partage son expérience avec un serveur Ubuntu hébergeant Nextcloud et MiniDLNA, mais conclut que l’auto-hébergement reste un loisir technique, réservé à des usages non essentiels et assumés en conscience des limites et des risques.

Une superbe adaptation des Misérables de Victor Hugo à notre époque. Comme le souligne Gee, cette oeuvre a vraiment peu vieilli à tous les niveaux : la misère et les misérables sont 'toujours bien là, en France, en 2025".

Comment bien scaler les code reviews (et éviter les pièges)
À l’origine, une petite équipe peut se permettre de merger directement dans la branche principale, mais dès que le projet grandit, les code reviews deviennent essentielles pour maintenir la qualité du code. Pourtant, mal gérées, elles ralentissent les équipes (délais serrés, feedbacks sur des détails mineurs), génèrent des conflits (préférences personnelles, ton toxique) et favorisent les incompréhensions (revues asynchrones, PR trop volumineuses). Pour y remédier, auteurs et relecteurs doivent adopter des bonnes pratiques : PR petites et ciblées, feedback constructif et documenté, respect du temps de chacun (réponse sous 24h, slots dédiés), et automatisation (CI, outils comme CodeRabbit pour les checks routiniers). L’objectif ? Améliorer la qualité sans bloquer la vélocité : privilégier le "bon assez" plutôt que la perfection, utiliser des checklists, et résoudre les désaccords en direct. Les outils modernes (GitHub/GitLab, AI comme CodeRabbit) optimisent le workflow en détectant les bugs tôt et en résumant les changements, libérant les humains pour des revues plus stratégiques. En résumé : des revues rapides, bienveillantes et outillées pour un code sain et des équipes motivées.

L'auteur détaille sa migration d’infrastructure en 2025, marquée par l’abandon de Proxmox au profit d’Hyper-V, principalement pour des raisons de performances et de gestion des sauvegardes : ZFS et PBS (Proxmox Backup Server) étaient devenus inadaptés à ses besoins, avec des vitesses de backup limitées à 100-150 Mbps contre 2 Gbps avec Hyper-V et Veeam, essentiel pour ses 7-8 To de données quotidiennes. Son infrastructure repose désormais sur deux serveurs sous Windows Server 2022 : un Supermicro X10SDV-4C-TLN4F (stockage NVMe et HDD en RAID 1) pour l’hyperviseur et un vieux HP MicroServer Gen8 (mis à niveau réseau et stockage) pour les backups, le tout protégé par un UPS APC reconditionné. Les VM, majoritairement sous Debian 12, incluent Ansible (avec Semaphore), LibreNMS, Home Assistant, Paperless-ngx, Jellyfin, Passbolt, Proton-backup, Wazuh et un serveur web. Le réseau est entièrement en 10 Gbps (catégorie 6 STP), avec un firewall OPNsense sur un NUC Intel N100. L’automatisation via Ansible/Semaphore gère mises à jour, backups (local, disques externes rotatifs, Backblaze B2 chiffré) et monitoring, respectant la règle 3-2-1. Il évoque aussi son wiki technique (xWiki) et son désengagement partiel du blog, critiquant l’impact des IA (comme Gemini) sur la visibilité des contenus humains, tout en reconnaissant leur utilité ponctuelle pour la veille ou l’écriture de scripts. Enfin, il souligne la désaffection des blogs au profit des réseaux sociaux et de l’IA, sans pour autant fermer son espace.

Encore un texte passionnant de Ploum qui fait réfléchir (et sourcé, toutes les sources lui permettant d'alimenter sa réflexion).

L'espionnage de masse est bien pire que ce que l'on imagine mais l'Europe protège un tout petit peu ses citoyens.
On est saturés d'indignation sans rien faire mais il y a quelques actions très concrètes (comme supprimer Whatsapp) : il faut accepter la difficulté, l'inconfort et le fait que ces actions ne seront jamais reconnues ou applaudies.
La merdification est à l'oeuvre de partout, même sur des applications qui paraissaient sûres puisque les fondateurs s'y étaient engagés... jusqu'à l'arrivée d'un gros chèque. Seul le logiciel libre peut lutter, à condition de ne pas chercher l'ajout de fonctionnalités superflues.
Ploum nous encourage aussi à ralentir et prendre du recul (cf son dernier échange avec Chris Brannons)
Enfin il nous encourage aussi à faire du vélo, comme symbole d'indépendance et de liberté.

L’article explique comment transformer sa to-do list en un outil efficace et anti-stress, en s’appuyant sur la psychologie du cerveau (effet Zeigarnik, dopamine) et 7 règles clés. L’idée centrale : le cerveau est obsédé par les tâches inachevées, ce qui génère du stress et réduit la concentration. Pour y remédier, il propose de planifier le matin (après avoir vérifié ses mails), de commencer par les tâches faciles pour créer un élan de motivation (« boule de neige »), de découper les projets en actions concrètes (règle des 25 minutes), et de regrouper les tâches similaires (« batching »). Autres astuces : noter chaque soirée les tâches accomplies (« Done List ») pour analyser son temps réel, gérer les imprévus en notant la prochaine micro-étape avant de s’interrompre, et choisir un outil simple (comme Google Tasks) qui permet de déléguer la mémoire à un système externe. L’objectif n’est pas de tout retenir, mais de libérer son esprit pour se concentrer sur l’essentiel.

Une méthode pour passer de la surcharge à la sérénité !

L’article propose un exercice simple pour identifier et réduire la charge mentale au travail, souvent source d’angoisse et de fatigue invisible. L’idée est de noter pendant une semaine toutes les petites contrariétés du quotidien (tâches répétitives, interruptions, demandes hors périmètre) sans les juger, afin de dresser un « relevé brut » de ce qui grignote temps et énergie. À l’issue de cette observation, trois questions clés permettent d’agir : automatiser les tâches répétitives, déléguer ce qui ne relève pas de son expertise, ou supprimer ce qui n’est plus nécessaire. L’objectif n’est pas une solution miracle, mais une prise de recul concrète pour reprendre le contrôle et alléger son quotidien, en se concentrant sur l’essentiel plutôt que sur l’accumulation de détails épuisants.

Un outil utile pour ceux qui se sentent débordés sans raison apparente !

Le 17 août 2025, le blog de l’auteur a subi un incident informatique : environ 179 000 requêtes web en 14 heures, ciblant uniquement trois fichiers sitemap.xml, provenant de 168 000 adresses IP uniques (majoritairement IPv4). L’attaque, jugée naïve et peu sophistiquée, a permis à l’auteur de réviser ses connaissances sur nftables et fail2ban. Après avoir bloqué l’accès aux fichiers ciblés via Apache, il a tenté de filtrer les requêtes avec fail2ban, mais a dû ajuster sa stratégie face à la charge : bannissement par grands blocs d’IP (/8 puis /16 en IPv4), limitation du trafic entrant, et enfin blocage par pays (sauf France). Malgré des erreurs initiales (rechargement intempestif de fail2ban, lecture complète des logs), l’incident a été maîtrisé en combinant ces outils et en nettoyant les logs pour éviter d’alourdir les sauvegardes. L’auteur souligne l’importance de bien connaître ses outils avant un incident et partage des commandes utiles pour nftables et fail2ban.

Un retour d’expérience technique et pédagogique sur la gestion d’un flux massif de requêtes indésirables.

Ce tutoriel détaillé explique comment mettre en place une solution de supervision complète de vos serveurs avec Prometheus (pour la collecte et le stockage des métriques système) et Grafana (pour leur visualisation sous forme de tableaux de bord interactifs).
Il couvre l’installation et la configuration de Prometheus et Grafana via Docker sur un serveur dédié, ainsi que le déploiement d’exporters comme node_exporter (métriques système), cAdvisor (métriques containers Docker), process_exporter (métriques processus), et blackbox_exporter (tests de disponibilité des services). Le guide aborde aussi la sécurisation des interfaces, la création d’alertes, et l’intégration d’Alert Manager pour la gestion des notifications. Idéal pour surveiller en temps réel l’état de votre infrastructure et recevoir des alertes en cas de dépassement de seuils, avec des exemples concrets et des tableaux de bord Grafana prêts à l’emploi.

Un super outil à auto héberger qui permet de convertir des fichiers dans plein de formats

Ce tutoriel explique comment déployer Longhorn, une solution de stockage distribué, sur un cluster K3s (Kubernetes léger).
Il détaille les prérequis (Kubernetes 1.28+, 2 Go de RAM, open-iscsi installé), la préparation d’un dossier dédié (/opt/longhorn), puis l’installation via un manifest YAML personnalisé pour spécifier le chemin de stockage. Après déploiement, il montre comment vérifier l’état des pods, corriger une mauvaise configuration via un patch, et tester le stockage avec un PVC de 1 Go. Des astuces pour la mise à jour, la vérification de l’état du service et le redimensionnement des volumes sont aussi partagées. Idéal pour ajouter du stockage persistant et résilient à un cluster K3s avec peu de ressources.

Ce guide explique comment optimiser le chargement des polices web pour éviter de ralentir un site : privilégiez le format WOFF2 (le plus efficace et universel), hébergez vos polices vous-même pour améliorer les performances et la vie privée, et utilisez font-display: swap pour afficher immédiatement un texte de repli avant le chargement de la police personnalisée. Pensez à pré-charger les polices critiques avec <link rel="preload" as="font" ...>, à sous-ensembliser les polices (unicode-range) et à éviter les formats obsolètes (TTF, OTF, etc.). Intégrez les déclarations @font-face directement dans le <head>, choisissez des polices de repli système bien adaptées, et utilisez size-adjust ou font-size-adjust pour limiter les décalages de mise en page (CLS). Enfin, testez sur des réseaux lents et surveillez l’impact des polices sur les performances, en limitant le nombre de variantes et en évitant les polices d’icônes au profit des SVG. L’objectif : allier design et rapidité sans compromis.

L'auteur montre qu’il n’est pas nécessaire de migrer vers TypeScript pour bénéficier de sa rigueur : PHP 8.1+, couplé à des outils d’analyse statique (Psalm, PHPStan) et à des bibliothèques idiomatiques, permet d’obtenir des garanties similaires en typage, validation et maintenabilité. L’article détaille des équivalences concrètes : DTOs (classes typées + validation runtime), énumérations (PHP enums + match), génériques (via docblocks et analyse statique), métadonnées (attributs PHP), validation (Symfony Validator), gestion des erreurs (objets Result ou exceptions), et asynchrone (queues ou Fibers). L’approche est incrémentale, avec des exemples prêts à l’emploi, et met en avant les forces de PHP (écosystème mature, performances) tout en comblant l’écart avec TypeScript sur la sécurité et l’ergonomie. À retenir : combiner typage statique, validation aux frontières et design explicite pour un code PHP aussi robuste et maintenable qu’une base TypeScript, sans tout réécrire.

L’article explique comment gérer la traduction de contenu statique (menus, titres, boutons) dans Symfony à l’aide du composant Translation. Il détaille les étapes clés : installation via symfony composer require translation, configuration des locales dans translation.yaml et routes.yaml, utilisation de clés (ex: about_us) dans des fichiers YAML par langue (messages.en.yaml, messages.fr.yaml), et intégration dans Twig avec le filtre |trans et un sélecteur de langue dynamique. Il aborde aussi le débogage avec debug:translation et l’extraction automatique des clés manquantes, tout en évoquant l’option d’utiliser des services externes comme Crowdin pour une gestion collaborative. Une approche simple et efficace pour internationaliser une application Symfony.

L’article explique la différence fondamentale entre les DTO (Data Transfer Object) et les Entities dans Symfony, deux concepts clés pour structurer proprement une application. Les Entities représentent les objets métiers persistés en base de données, liés à Doctrine et souvent chargés de logique complexe, tandis que les DTO sont des objets légers, dédiés au transfert de données entre les couches (API, formulaires, services), sans logique métier ni persistance. Utiliser des DTO permet de découpler la validation, la sérialisation et la manipulation des données des Entities, améliorant ainsi la maintenabilité, la sécurité (en évitant d’exposer directement les Entities) et la clarté du code. L’auteur souligne que les DTO sont particulièrement utiles pour gérer les entrées/sorties des contrôleurs ou des services externes, tandis que les Entities restent le cœur du modèle de données. En résumé, bien distinguer les deux optimise l’architecture et réduit les risques d’incohérences ou de fuites de données sensibles.

L'auteur partage son parcours personnel et professionnel avec Kubernetes, soulignant qu’il n’existe pas de réponse universelle. Il a découvert l’orchestration via Docker Swarm, puis Kubernetes à travers des services managés comme AKS (Azure) et GKE (Google Cloud), avant d’expérimenter des solutions plus légères comme K3S et Talos Linux. Chaque approche—services managés, déploiements "the hard way", ou outils simplifiés—offre des avantages et des limites, selon le contexte et les besoins. L’important est de choisir la méthode qui suscite la curiosité et permet d’apprendre en pratiquant, car Kubernetes et son écosystème évoluent constamment, offrant de multiples angles d’entrée. L’essentiel reste d’oser explorer et comparer, sans crainte de se tromper.

Un analyste confronté à une requête lente sur une table de 150 millions de transactions (2 minutes d’exécution, parfois des timeouts) a optimisé son code en utilisant une CTE (Common Table Expression) avec WITH. Au lieu de joindre d’abord les tables puis de filtrer, la CTE filtre d’abord les transactions récentes (20M de lignes au lieu de 150M), réduisant le temps d’exécution de 127 à 11 secondes. En allant plus loin et en agrégeant directement dans la CTE, il a même descendu ce temps à moins de 6 secondes. La clé ? Filtrer tôt pour alléger la charge de jointure, clarifier la logique, et exploiter les optimisations des moteurs modernes (PostgreSQL 12+, BigQuery). Attention toutefois : les performances varient selon le SGBD (risque de matérialisation en tables temporaires sous MySQL ancien). Une leçon simple : une requête bien structurée = des gains de performance majeurs.

L'auteur explique que les bons ingénieurs logiciels fonctionnent en boucle : ils construisent un modèle mental des besoins, écrivent du code, comparent le résultat avec leur modèle, puis ajustent le code ou les exigences. Les LLMs, bien qu’efficaces pour générer ou modifier du code, échouent à maintenir ces modèles mentaux cohérents. Ils se perdent face aux échecs de tests, hallucinent des détails, et peinent à gérer le contexte ou à zoomer entre le global et le local — des capacités essentielles pour résoudre des problèmes complexes. Même avec des avancées, ils restent des outils d’assistance, pas des développeurs autonomes : c’est à l’humain de garantir la justesse des exigences et du code, surtout sur des projets non triviaux. On préfèrera donc miser sur une collaboration humain-agent, mais le développeur reste aux commandes.

Cet article détaille la configuration d’un serveur rsyslog sous Ubuntu 24.04 avec authentification TLS, afin de centraliser et chiffrer les logs en transit sur le réseau. Il explique pourquoi utiliser rsyslog (notamment pour sa compatibilité avec divers équipements et sa simplicité d’intégration), puis présente les étapes clés : génération de certificats (PKI interne ou auto-signés), configuration du serveur avec gtls pour valider les clients via leur certificat (mode x509/name ou empreinte SHA256), et gestion des droits sur les fichiers de certificats. Plusieurs scénarios sont abordés : authentification mutuelle, chiffrement seul, ou utilisation de certificats publics pour l’exposition sur Internet. Des exemples de filtrage des logs (par IP, chaîne de caractères) et de tests de configuration sont aussi fournis, le tout sur le port 6514/TCP. Une ressource utile pour sécuriser la centralisation des logs en respectant les bonnes pratiques (ISO27001, HDS, etc.).

Dans cet article, Milan Milanović partage les cinq livres qui ont marqué sa carrière d’ingénieur et son évolution vers le poste de CTO. Il explique comment "The Pragmatic Programmer" lui a appris à écrire du code professionnel, durable et adaptable, en insistant sur l’importance de l’itération rapide et de la responsabilité collective. "Designing Data-Intensive Applications" a transformé sa vision de l’architecture des systèmes, en mettant l’accent sur les compromis entre cohérence, disponibilité et tolérance au partitionnement, ainsi que sur la rigueur dans le choix des bases de données. "A Philosophy of Software Design" l’a aidé à lutter contre la complexité du code en privilégiant des modules profonds et bien conçus, faciles à maintenir. "Thinking, Fast and Slow" de Daniel Kahneman lui a révélé l’impact des biais cognitifs sur la prise de décision, l’incitant à adopter une approche plus analytique et moins intuitive. Enfin, "The 7 Habits of Highly Effective People" a renforcé ses compétences en leadership, en lui apprenant à se concentrer sur ce qu’il peut contrôler, à écouter activement et à investir dans son développement personnel. Ces ouvrages, au-delà des compétences techniques, lui ont offert des modèles mentaux essentiels pour devenir un meilleur architecte, décideur et leader. Une lecture inspirante pour quiconque souhaite allier expertise technique et croissance personnelle.

Un mémo des actions à faire pour passer de Debian 12 à 13

L'auteur présente 3 techniques pour déclencher un téléchargement de fichier :

• un attribut introduit en HTML5
• la simulation d'un clic en JavaScript, par exemple suite à une action utilisateur
• dans le cas du téléchargement de données générées dynamiquement, les transformer en Blob et utiliser la méthode précédente

Le débat entre monolithe et microservices évolue vers un équilibre pragmatique : la simplicité, l’expérience développeur et la maintenabilité deviennent prioritaires. Les entreprises, après avoir expérimenté les coûts élevés et la complexité des microservices, se tournent de plus en plus vers des architectures modulaires ou des monolithes bien structurés, comme en témoignent des exemples comme Amazon Prime Video, qui a réduit ses coûts de 90 % en revenant à une approche monolithique. La culture du "vibecoding" (optimisation du bien-être et de la productivité des développeurs) favorise aussi les monorepos et les architectures centralisées, tout en intégrant des outils modernes pour garder une flexibilité. L’enjeu n’est plus de choisir un camp, mais d’adapter l’architecture au contexte, en privilégiant la clarté, la résilience et l’alignement d’équipe, avec la possibilité de basculer entre les deux approches selon les besoins. Les outils comme Terraform, les devcontainers ou les CI/CD avancées permettent désormais de repenser les choix architecturaux avec plus d’intention et moins de dogmatisme.

Les branches divergentes : source de conflits en push/pull
Erreurs classiques :

! [rejected] main -> main (non fast-forward)
fatal: Need to specify how to reconcile divergent branches.

Qu’est-ce qu’une branche divergente ?
Local et distant ont chacun des commits que l’autre n’a pas.

4 états possibles avec une branche distante :

1. À jour
2. Besoin de pull
3. Besoin de push
4. Divergée (il faut choisir comment résoudre le conflit)

Comment détecter une divergence ?

git fetch
git status
# Exemple de sortie :
# "Your branch and ‘origin/main’ have diverged, and have 1 and 1 different commits each."

Solution rapide :

git pull --rebase

(Mais il existe d’autres options, comme merge.)

À retenir :

• git fetch récupère les derniers commits.
• git pull = git fetch + git merge (ou rebase).

Git affiche constamment des diffs – mais parfois, ils semblent étranges.

Pourquoi ?

• Git ne comprend pas les intentions : un renommage (git mv old.py new.py) est traité comme une suppression + ajout.
• L’algorithme de diff compare simplement deux versions et essaie de résumer les changements de façon lisible… mais pas toujours avec succès.

Astuce :

• Git propose plusieurs algorithmes de diff. Par exemple, pour mieux gérer les réorganisations de code :

  git diff --histogram

Git utilise un processus de commit en 2 étapes :

1. Ajouter les modifications à la zone de staging (git add, git rm, git mv).
2. Valider avec git commit.

La zone de staging, 3 noms pour une seule chose :

• staged (--staged)
• cache (--cached)
• index (--keep-index)

Astuces :

• git add -p permet de commiter seulement certaines parties d’un fichier.
• git diff ne montre que les modifications non staged :
  • git diff HEAD → toutes les modifications non commitées.
  • git diff --cached → seulement les modifications staged.
• git commit -a ne prend pas en compte les nouveaux fichiers (il faut les add avant).

Git n’a pas de bouton "Annuler"
Pas de unadd, uncommit, unmerge ou unrebase. À la place, il y a git reset – puissant, mais dangereux.

Comment fonctionne git reset ?

• La plupart des commandes Git avancent la branche (git commit, git merge, git pull).
• git reset peut déplacer la branche n’importe où : en arrière, en avant, ou "de côté".
• Exemple : git reset HEAD^ force la branche à pointer sur le commit parent, et déstage les changements.

Options clés :

• Par défaut : conserve les modifications dans le répertoire de travail.
• --hard : supprime les modifications non commitées (attention, irréversible !).

Risques :

• Facile de "perdre" des commits en reculant une branche.
• Avec --hard, perte définitive des changements non commités.

Le reflog Git, c’est quoi ?
Un historique de tous les IDs de commit qu’une branche, un tag ou HEAD a déjà pointés. Utile pour retrouver des commits "perdus".

Différences avec git log :

• Le reflog est local (non partagé entre dépôts).
• Il montre l’état des branches avant un rebase (contrairement à git log).
• Les entrées de plus de 90 jours peuvent être supprimées par git gc.

Comment l’utiliser ?

1. Lancer git reflog (ou git reflog BRANCH pour moins de bruit).
2. Chercher un message de commit pertinent.
3. Inspecter le commit avec git show $COMMIT_ID ou git log $COMMIT_ID.
4. Récupérer le commit avec git reset --hard $COMMIT_ID ou git branch $NAME $COMMIT_ID.

Limites :

• Le reflog d’une branche est supprimé si la branche l’est.
• Inutile pour récupérer un stash supprimé (git stash drop).
• Les entrées ne correspondent pas toujours aux commandes Git exécutées.

Dernier recours :
Si le commit n’est plus dans le reflog, utiliser git fsck pour lister les commits non référencés.

Exposer son localhost sur internet est indispensable pour tester des webhooks, partager des démos en direct, ou tester sur des appareils mobiles réels. L’outil open source Tunnelmole permet de créer un tunnel sécurisé entre un serveur local et une URL publique en quelques secondes. Après avoir lancé son serveur local (ex: localhost:3000), il suffit d’installer Tunnelmole (npm install -g tunnelmole ou via un script d’installation), puis de lancer tmole 3000 pour obtenir une URL publique HTTPS accessible partout. Idéal pour le développement, le débogage ou la collaboration, Tunnelmole est transparent, open source et permet même l’auto-hébergement pour plus de contrôle. Une solution simple et efficace pour sortir de l’isolement de localhost.

Ce dépôt propose une collection d’agents personnalisés pour Claude Code, conçus pour assister les développeurs dans diverses tâches.

Installation

• Pour un projet spécifique : Copier les agents dans .claude/agents/ à la racine du projet.
• Pour une utilisation globale : Copier les agents dans ~/.claude/agents/.

Agents disponibles

• code-refactorer : Aide au refactoring de code
• content-writer : Rédaction de contenu
• frontend-designer : Assistance en design frontend
• prd-writer : Rédaction de documents de spécifications produit
• project-task-planner : Planification de projets et découpage des tâches
• security-auditor : Audit de sécurité
• vibe-coding-coach : Coaching et guidance en codage

Utilisation
Une fois installés, Claude Code détecte et utilise automatiquement ces agents selon les besoins.

Symfony 7 utilise les attributes PHP (syntaxe #[...]) pour remplacer les annotations et déclarer des métadonnées directement dans le code. L’article montre comment créer des attributes sur mesure (ex : #[Audit] pour le logging, #[FeatureToggle] pour gérer des fonctionnalités, #[RequiresRole] pour la sécurité, #[Throttle] pour limiter les requêtes) et les exploiter via des event listeners. Ces outils simplifient la maintenance, évitent la duplication de code et rendent le comportement du code plus explicite. Les attributes peuvent aussi cibler des classes et être packagés en bundles réutilisables. Une fonctionnalité puissante pour structurer vos applications Symfony de manière déclarative et élégante.

L'auteur explique pourquoi repenser les architectures logicielles en privilégiant les événements plutôt que les requêtes synchrones. Au lieu de s’appuyer sur le modèle classique « demande/réponse », l’approche event-driven (EDA) émet des faits immuables (ex : UserSignedUp, OrderPlaced) via des brokers (Kafka, RabbitMQ, etc.), permettant un découplage total, une scalabilité asynchrone et une observabilité native. Les avantages sont majeurs : flexibilité, extensibilité sans modifier les sources, et traçabilité des actions. Des géants comme Shopify, Netflix ou Stripe l’utilisent pour synchroniser des services, déclencher des workflows ou alimenter l’analytics. Attention cependant aux pièges : surcharge des payloads, absence d’idempotence, ou manque de versioning. L’EDA n’est pas une solution universelle (coûts, complexité accrue), mais elle transforme la résilience et l’évolutivité des systèmes — à condition d’adopter une discipline rigoureuse et de traiter les événements comme des contrats versionnés.

6 semaines avec Claude Code : Orta Therox (Puzzmo) raconte comment cet outil d’IA a révolutionné sa productivité, lui permettant de réaliser en solo des mois de tech debt (migrations, tests, refactoring, etc.) en quelques semaines, sans surcharge. Claude Code agit comme un pair programmer ultra-rapide, accélérant prototypage et maintenance, tout en laissant l’humain garder le contrôle et la responsabilité finale. Une avancée majeure, mais qui pose question sur l’évolution du métier de dev.

Balises <strong>, <b>, <em>, <i> : quand et pourquoi les utiliser ?
En HTML, le choix entre ces balises dépend avant tout de la sémantique : <strong> et <em> apportent du sens (importance ou emphase, utiles pour les lecteurs d’écran), tandis que <b> et <i> servent à une distinction visuelle ou typographique sans valeur sémantique. <strong> souligne un contenu crucial (avertissements, instructions), <em> modifie le sens d’une phrase par l’emphase. <b> attire l’attention sans importance particulière, et <i> s’emploie pour des termes techniques, noms d’œuvres ou mots étrangers. Pour un style purement décoratif, privilégiez le CSS avec <span>. L’objectif : séparer structure (HTML) et présentation (CSS) pour un code propre et accessible.

Points clés

1. L’internationalisation, bien plus que la traduction

L’i18n ne se limite pas à traduire du texte : elle inclut aussi le formatage des dates, des nombres, des listes, la pluralisation, etc., selon les attentes culturelles de chaque locale. L’API Intl de JavaScript offre une solution native, performante et standardisée pour gérer ces aspects, sans dépendre de bibliothèques tierces lourdes.

2. Qu’est-ce qu’une locale ?

Une locale (en-US, fr-FR, ja-JP, etc.) définit non seulement la langue, mais aussi la région, le script, et d’autres préférences culturelles. Elle permet d’adapter finement l’affichage des données.

3. Les principaux outils de l’API Intl

• Intl.DateTimeFormat : Formate les dates et heures selon les conventions locales (ex. : 27/06/2025 vs June 27, 2025).
• Intl.NumberFormat : Affiche les nombres, devises et unités avec les séparateurs et symboles locaux (ex. : 123,456.79 $ vs 123.456,79 €).
• Intl.ListFormat : Génère des listes naturelles avec les conjonctions adaptées (ex. : « pommes, oranges et bananes » vs « apples, oranges, and bananas »).
• Intl.RelativeTimeFormat : Affiche des expressions temporelles relatives (« hier », « dans 3 mois ») de manière localisée.
• Intl.PluralRules : Détermine la catégorie de pluralisation (singulier/pluriel, mais aussi « zero », « one », « two », etc. pour l’arabe).
• Intl.DisplayNames : Fournit les noms localisés des langues, régions ou scripts (ex. : « French » vs « français »).

4. Avantages

• Natif : Intégré à tous les navigateurs modernes, sans besoin de polyfills.
• Performant : Réduit la taille des bundles et améliore les performances.
• Flexible : Permet de surcharger la locale par défaut (via navigator.language ou un attribut lang en HTML).

5. Cas d’usage

• Afficher des prix, dates ou listes adaptés à l’utilisateur.
• Gérer la pluralisation complexe (ex. : arabe, russe).
• Éviter les solutions maison ou les bibliothèques externes.

6. Limites

L’API Intl gère le formatage des données, mais pas la traduction de contenu, la typographie RTL/LTR, ou les nuances culturelles profondes.

7. Ressources utiles

• Documentation MDN sur Intl
• Spécification ECMA-402

Pourquoi l’utiliser ?
L’API Intl simplifie l’internationalisation tout en respectant les standards du web. Idéal pour des applications multilingues légères et maintenables.

L’article met en lumière un piège courant en JavaScript : l’utilisation de Array.includes dans une boucle (comme source.some(item => target.includes(item))) peut devenir extrêmement coûteuse en performance avec des tableaux volumineux, car la complexité algorithmique passe à *O(nm). Par exemple, avec des tableaux de 60 000 éléments, l’exécution peut prendre plusieurs secondes. La solution consiste à utiliser des structures de données optimisées pour des recherches en temps constant, comme un objet, une Map, ou mieux, un Set (new Set(target)), réduisant la complexité à O(n + m)** et rendant le code quasi instantané même pour de très grands jeux de données. Une astuce simple, mais cruciale pour éviter des goulots d’étranglement inattendus dans le code JavaScript.

L'article explique pourquoi privilégier l’immuabilité en programmation orientée objet permet d’éviter des bugs subtils liés à l’état partagé. L’auteur illustre le problème avec un exemple en PHP où la mutation d’un objet DateTime affecte involontairement une autre partie du code, rendant le débogage difficile. Les objets immuables (comme DateTimeImmutable) évitent ce genre de piège en retournant une nouvelle instance à chaque modification, plutôt que de modifier l’original. Les avantages incluent une meilleure prévisibilité du code, une réduction des effets de bord et une gestion plus sûre de la concurrence. Cependant, l’immuabilité peut introduire un surcoût en performance et n’est pas toujours adaptée (ex. : objets builders éphémères). L’article conclut en encourageant à adopter l’immuabilité par défaut, sauf besoin contraire, pour un code plus robuste et maintenable.

Ce comic explique simplement ce qu’est un dépôt distant (remote) dans Git : un autre dépôt vers lequel on pousse (push) ou depuis lequel on tire (pull) du code. Un remote peut être hébergé sur GitHub, GitLab, un serveur personnel, ou même un dossier local. La syntaxe git push origin main signifie "pousser la branche main vers le remote nommé origin". Les remotes sont configurés dans .git/config avec un nom et une URL, et peuvent utiliser différents protocoles (HTTP, SSH, ou local). Les remotes sont aussi le lieu de "drames" typiques, comme les conflits lors d’un git pull après qu’un·e collègue a réécrit un fichier. Astuce : activer push.autoSetupRemote true pour simplifier le suivi des branches. Une introduction claire et pratique pour comprendre l’interaction entre dépôts locaux et distants !

Ce comic illustre comment des commits peuvent se "perdre" dans Git, même s’ils restent souvent stockés quelque part. Les causes fréquentes : git commit --amend, git rebase, la suppression d’une branche non fusionnée ou git stash drop. Trois niveaux de gravité sont décrits : "énervant" (le commit n’est plus référencé par une branche/étiquette mais reste facile à retrouver), "cauchemar" (il faut fouiller tous les commits), et "catastrophe" (le commit est supprimé). Heureusement, Git conserve généralement les commits "perdus" : on peut les retrouver via le reflog pour les cas simples, ou git fsck pour les situations plus complexes. Une bonne raison de ne pas paniquer et de connaître ces outils de récupération !

Ce comic explique de façon visuelle et accessible comment Git stocke les fichiers en interne. À l’aide de la commande git cat-file -p, on peut explorer un commit : celui-ci contient un arbre (tree) pointant vers des fichiers (blobs) ou d’autres arbres, chaque objet étant identifié par un hash SHA-1. Par exemple, un commit affiche son auteur, sa date, son message, et l’ID de l’arbre racine ; cet arbre liste les fichiers et leurs hashs, permettant à Git d’éviter les doublons en réutilisant les mêmes objets si le contenu ne change pas. Une façon simple et concrète de comprendre que Git fonctionne comme un système de fichiers basé sur des hashs, où chaque modification crée de nouveaux objets tout en réutilisant ceux inchangés. Une astuce utile pour mieux appréhender le fonctionnement interne de Git !

Pour résumer l'article, je paraphrase les derniers paragraphes.
[Ce qui suit] n'est pas une checklist. C'est une boucle de récupération. Vous pouvez commencer n'importe où, reculer ou sauter [une étape] selon la saison.

Mais lorsque la vie perturbe votre rythme, n'attendez pas de vous sentir prêt.

• Manque de confiance ? Construisez des preuves.
• Manque de preuves ? ​​Développez des compétences.
• Manque de compétences ? Développez la discipline.
• Manque de discipline ? Développez la responsabilisation.
• Manque de responsabilisation ? Changez votre environnement.

Chaque niveau crée les conditions du suivant. Au fil du temps, vous passez de l'immobilisme à l'autonomie.

Ajouter la GeoIP à Nginx Proxy Manager (NPM 2.12+) permet de bloquer ou logger les visiteurs par pays. Il suffit d’activer les modules GeoIP via root_top.conf, de télécharger les bases GeoLite2 de Maxmind (gratuites, après inscription), et de configurer les règles de blocage dans http_top.conf. Les logs peuvent aussi être enrichis avec les infos géographiques.

Un éditeur markdown WYSIWYG léger