Ce shaarli explique comment utiliser Podman comme un substitut à Docker, en permettant l'exécution des commandes Docker habituelles avec Podman. L'article détaille l'installation du paquet podman-docker, qui fournit un script docker émulant les commandes Docker, ainsi que la suppression du message d'avertissement via la création du fichier /etc/containers/nodocker. Il aborde aussi la compatibilité avec docker-compose grâce à l'installation de podman-compose, et présente deux solutions pour gérer le démarrage automatique des conteneurs (via Quadlet ou en activant le service podman-restart). L'objectif est de faciliter la transition pour les utilisateurs habitués à Docker, tout en profitant des avantages de Podman, notamment son absence de démon.

L'auteur propose une approche innovante de développement piloté par les spécifications (« spec-driven development ») en utilisant le Markdown comme langage de programmation, avec l’aide d’agents d’IA comme GitHub Copilot. L’idée est de décrire l’intégralité d’une application dans un fichier Markdown (par exemple main.md), qui sert à la fois de documentation et de spécification technique, puis de laisser l’IA générer le code source (ici en Go) à partir de ce fichier. Le workflow repose sur quatre fichiers clés : un README.md pour la documentation utilisateur, un main.md pour la spécification technique (incluant la logique métier, les schémas de base de données, et même des extraits GraphQL), et des prompts (compile.prompt.md, lint.prompt.md) pour guider l’IA dans la génération et l’optimisation du code.

L’avantage principal est de centraliser la logique et la documentation en un seul endroit, évitant les incohérences et facilitant les mises à jour. Le développeur édite le Markdown, demande à l’IA de « compiler » la spécification en code, puis teste l’application. Cette méthode permet une itération rapide et une meilleure synchronisation entre la documentation et l’implémentation. Cependant, la compilation peut ralentir à mesure que le projet grandit, et l’approche nécessite une description claire et précise des attentes. L’auteur envisage d’étendre cette méthode à d’autres langages et d’intégrer des tests automatisés. Une expérience prometteuse, surtout avec les progrès des agents IA, mais qui demande une rigueur dans la rédaction des spécifications.

Cet article compare les architectures standalone et haute disponibilité (HA) pour Kubernetes on-premise, en expliquant comment concevoir et opérer un cluster HA. L’article détaille l’importance de redonder les composants critiques (comme l’API Kubernetes) pour éviter les points de défaillance uniques (SPOF), même si cela peut introduire de nouveaux défis (ex. : un load balancer devant les control planes peut lui-même devenir un SPOF). Il présente aussi une solution de stockage HA avec TrueNAS (exposant des volumes bloc via iSCSI) et Longhorn pour orchestrer la réplication, les snapshots et la reconstruction automatique en cas de panne d’un nœud. L’auteur insiste sur la nécessité de bien dimensionner chaque couche (stockage, réseau, contrôle) pour garantir la résilience du cluster, tout en soulignant que la haute disponibilité commence par la redondance du plan de contrôle et une gestion fine des volumes persistants. Le billet s’inscrit dans une série technique explorant les bonnes pratiques pour opérer Kubernetes en production.

L'article introduit la commande Linux tc (traffic control), utilisée pour simuler et contrôler le trafic réseau. L’article montre comment ajouter un délai de 500 ms aux paquets avec tc qdisc add dev wlp3s0 root netem delay 500ms, puis supprimer cette règle avec tc qdisc del. L’outil netem permet aussi de perdre, dupliquer ou corrompre des paquets, idéal pour tester des conditions réseau difficiles. L’autrice mentionne qu’avec un routeur Linux, on peut même ralentir le trafic d’autres utilisateurs (comme celui d’un frère), et invite à explorer tc qdisc show pour voir les règles actuelles. Le zine complet et d’autres comics sont disponibles via abonnement ou sur le site.

L'article explique comment utiliser la commande ss (socket statistics) sous Linux pour identifier et gérer les processus utilisant un port réseau. L’article montre comment ss -tunapl permet de lister les serveurs en cours d’exécution et d’afficher les PID des processus, utile pour libérer un port occupé (comme le 8080). Les options comme -n (affichage des ports en numérique), -p (affichage des PID), et d’autres (-l, -t, -u) sont détaillées pour filtrer les sockets TCP, UDP ou Unix. L’autrice recommande ss plutôt que netstat, plus ancien et complexe, pour une utilisation plus simple et efficace. Le zine complet et d’autres ressources sont disponibles via abonnement ou sur le site.

Cet article explique la commande Linux ip, utilisée pour visualiser et modifier la configuration réseau. L’article détaille quelques sous-commandes utiles comme ip addr list (affiche les adresses IP des interfaces), ip route list (affiche la table de routage), et montre comment changer une adresse MAC pour contourner des restrictions réseau (par exemple dans les cafés). D’autres options comme ip link (gestion des interfaces), ip neigh (table ARP), et ip xfrm (pour IPsec) sont mentionnées, ainsi que des astuces comme l’utilisation de --color pour une sortie colorée ou --brief pour un résumé. Le zine complet et d’autres comics sont disponibles via un abonnement à la newsletter ou sur le site de l’autrice.

Le positionnement par ancre (anchor positioning) est une nouvelle fonctionnalité CSS qui permet de positionner visuellement un élément par rapport à un autre, indépendamment de leur place dans le DOM. Idéal pour les info-bulles, menus contextuels ou modales, il utilise anchor-name pour définir une ancre et position-anchor pour l’associer à un élément positionné (en absolute ou fixed). Le placement s’effectue via anchor() ou position-area, tandis que anchor-size() permet d’adapter les dimensions de l’élément en fonction de l’ancre. La propriété position-try gère les débordements en proposant des solutions de repli. Compatible avec les navigateurs modernes, cette technique offre une alternative flexible aux méthodes traditionnelles, tout en nécessitant une attention particulière à l’accessibilité. Des outils comme Anchor Tool et des démos pratiques illustrent son potentiel.

L’article explique comment transformer des prompts AI efficaces en assistants personnalisés et réutilisables, évitant ainsi de retaper ou copier-coller les mêmes instructions. L’auteur présente les avantages des assistants AI sur mesure (comme les CustomGPTs, Agents ou Gems) : gain de temps, cohérence, adaptation au contexte spécifique d’une équipe, et capitalisation de l’expertise. Il détaille aussi quand ne pas en créer (tâches ponctuelles, données sensibles, processus complexes, etc.).

Le processus MATCH (Map, Add knowledge, Tailor, Check, Hand off) est proposé pour concevoir un assistant, illustré par l’exemple d’un outil analysant des retours clients. L’article souligne l’importance de partir des besoins utilisateurs, d’ajouter des fichiers de connaissance, et de tester rigoureusement. Enfin, il encourage à créer ses propres assistants plutôt que d’utiliser des modèles publics, pour une meilleure adéquation avec ses workflows et son ton. Une lecture utile pour les équipes souhaitant optimiser leur usage de l’IA au quotidien.

Linear explique dans cet article pourquoi l’entreprise a adopté une politique « zéro bug » : chaque bug signalé est corrigé rapidement (sous 48h pour les priorités hautes, 7 jours pour les autres), sans accumulation dans un backlog. L’idée est née après qu’un bug signalé dans une autre application ait mis cinq ans à être résolu, illustrant l’inutilité de faire attendre les utilisateurs. Pour y parvenir, Linear a d’abord nettoyé son backlog existant (175 bugs en trois semaines), puis mis en place des processus stricts : chaque bug est soit corrigé immédiatement, soit marqué comme « ne sera pas corrigé ». Un tableau de bord permet de suivre les bugs ouverts et de rééquilibrer la charge entre les équipes. Cette approche améliore la qualité du produit, renforce la confiance des utilisateurs (qui voient leurs signalements résolus en un temps record) et influence la culture d’ingénierie, incitant à éviter les bugs dès le développement. Résultat : plus de 2 000 bugs corrigés en un an, et une relation client transformée en collaboration positive. Une politique devenue une valeur centrale, que personne ne souhaite abandonner.

Ce zine démystifie les permissions Unix de façon visuelle et accessible : chaque fichier a trois droits (lecture, écriture, exécution) pour trois catégories (utilisateur, groupe, autres), affichables via ls -l. Les permissions sont représentées en binaire (ex. rw- = 110 = 6), ce qui permet d’utiliser chmod 644 pour définir rapidement rw-r--r--. L’autrice explique aussi les bits spéciaux (setuid, setgid, sticky) et leurs effets, comme un exécutable qui s’exécute toujours en tant que root. Pour les dossiers, les droits changent de sens : r permet de lister, w de créer, et x d’y accéder.

Ce zine explique de façon claire et visuelle comment utiliser la commande ps sous Linux pour lister les processus en cours. L’autrice recommande d’utiliser ps aux pour afficher tous les processus avec leur utilisateur, et détaille des options utiles comme w (pour voir les arguments complets des commandes), e (pour afficher les variables d’environnement), ou encore f (pour un arbre ASCII des processus). Elle souligne aussi que ps supporte trois styles d’arguments (UNIX, BSD, GNU), ce qui peut rendre son utilisation un peu déroutante, et propose des astuces comme ps -eo user,pid,wchan,cmd pour personnaliser les colonnes affichées. Enfin, elle rappelle que des outils comme pstree peuvent compléter ps pour visualiser la hiérarchie des processus.

L’article partage l’expérience d’un lead développeur qui, submergé par la multiplication des responsabilités, a réalisé que son emploi du temps était aussi mal optimisé qu’un code truffé de bugs. Il propose une méthode inspirée du développement logiciel pour "refactorer" son agenda : diagnostiquer ses tâches (en les listant, évaluant leur importance et leur urgence via une matrice d’Eisenhower adaptée), prioriser en distinguant l’urgent de l’important, et planifier avec le time-blocking (réserver des plages fixes pour les tâches récurrentes et laisser 30% de temps libre pour les imprévus). L’auteur insiste sur l’importance de la weekly review pour ajuster son planning, déléguer davantage (comme en pair programming), et ainsi retrouver du temps pour l’essentiel : développer, faire de la veille, ou animer des ateliers. Une approche pragmatique pour éviter le syndrome de la "fonction qui fait tout" et réduire le stress, avec des outils concrets comme la matrice de priorisation et des créneaux sanctuarisés. À tester surtout quand on passe de dev à lead ou manager !

L’article s’intéresse à la fonctionnalité CSS la plus décriée selon le State of CSS 2025 : les fonctions trigonométriques, notamment sin() et cos(). Pourtant, ces fonctions offrent des usages pratiques et créatifs, comme la création de dispositions circulaires (placer des éléments autour d’un cercle), des layouts ondulés (effets de vagues ou entrelacs), ou encore des animations amorties (mouvements réalistes de ressorts ou de pendules). L’auteur explique leur principe via le cercle unité et montre comment les utiliser en CSS pour des effets visuels dynamiques, sans recourir à des valeurs magiques. L’objectif ? Réconcilier les développeurs avec ces outils souvent perçus comme complexes, mais en réalité puissants et accessibles. Une invitation à explorer leur potentiel au-delà des préjugés !

Pascal Martin, Principal Engineer et AWS Hero, explique dans cette conférence que les systèmes distribués — ensembles de services communiquant via le réseau — sont omniprésents dans le web moderne, offrant scalabilité, résilience et flexibilité, mais introduisant aussi des défis majeurs : gestion de la cohérence des données, communication complexe entre services, et résilience face aux pannes inévitables. Il aborde des concepts clés comme le partitionnement des données, les compromis du théorème CAP (cohérence, disponibilité, tolérance aux pannes), les patterns Outbox et Saga pour les transactions, et l’importance de limiter le Blast Radius (impact des pannes) via des time-outs, retries intelligents, et une dégradation gracieuse des services. Son message central : tout peut tomber en panne, il faut donc concevoir des architectures résilientes, s’appuyer sur des outils éprouvés, et accepter que les systèmes distribués fonctionnent toujours dans un état "partiellement dégradé". Une conférence essentielle pour comprendre pourquoi et comment construire des systèmes robustes, avec des exemples concrets tirés de sa pratique chez Bedrock et dans le cloud.

L’article présente 5 workflows essentiels pour maîtriser l’utilisation des agents IA et obtenir des résultats fiables et reproductibles, au-delà des simples prompts ad hoc. Il détaille :
1. Le chaînage de prompts (prompt chaining) pour décomposer les tâches complexes en étapes successives, réduisant les erreurs et améliorant la clarté.
2. Le routage (routing) pour diriger chaque requête vers le modèle le plus adapté (léger ou lourd), optimisant coûts et qualité.
3. La parallélisation pour exécuter simultanément des sous-tâches indépendantes (ex : analyse de document, revue de code) et fusionner les résultats, gagnant en rapidité et précision.
4. L’orchestrateur-travailleurs (orchestrator-workers) où un modèle central planifie et distribue les sous-tâches à des modèles spécialisés, idéal pour des projets complexes comme la rédaction ou le développement.
5. L’évaluateur-optimiseur (evaluator-optimizer) qui introduit une boucle de feedback : un modèle génère une réponse, un autre l’évalue et demande des révisions jusqu’à ce que les critères soient remplis, garantissant une qualité constante.
L’auteur insiste sur l’importance de structurer les processus pour éviter les sorties incohérentes, réduire les coûts et gagner en contrôle, avec des exemples de code pour chaque workflow. Une approche systématique qui transforme l’usage des IA en outil professionnel fiable.

Laravel Eloquent utilise le modèle Active Record, qui permet de manipuler les lignes d’une base de données comme des objets PHP natifs, intégrant directement les opérations CRUD (Create, Read, Update, Delete). Chaque modèle (comme Post) correspond à une table et encapsule à la fois les données et la logique de persistance, simplifiant ainsi les interactions avec la base. Ce pattern offre une productivité rapide, une syntaxe lisible et une convention claire, mais peut aussi entraîner un couplage fort avec la base, des modèles surchargés et des tests plus complexes. Pour atténuer ces inconvénients, il est conseillé de garder les modèles légers, d’encapsuler les requêtes complexes et de privilégier les tests d’intégration. L’article illustre ces concepts avec une implémentation minimaliste en PHP pur, démontrant comment Eloquent gère la correspondance table-objet, le suivi des modifications et la persistance des données, ce qui rend son "magie" plus accessible et compréhensible.

En TypeScript, interface et type servent tous deux à définir des formes de données, mais avec des cas d’usage distincts. Les interfaces brillent pour déclarer des objets et des APIs extensibles (grâce à la fusion de déclarations et à l’héritage), ce qui les rend parfaites pour les contrats publics ou les bibliothèques. À l’inverse, les types (via type) sont plus polyvalents : ils gèrent les unions, les tuples, les types mappés et les structures complexes, mais ne peuvent pas être réouverts. Privilégiez les interfaces pour modéliser des objets et favoriser l’extensibilité (ex : classes, APIs), et optez pour les types pour des besoins avancés comme les unions, les utilitaires ou les alias de types complexes. En pratique, utilisez les interfaces par défaut pour les formes d’objets, et les types pour tout le reste, surtout quand la flexibilité syntaxique est requise.

L’article d’Alsacréations explique clairement la différence entre les redirections HTTP 301 (permanente) et 302 (temporaire), deux codes essentiels pour gérer les changements d’URL. Une redirection 301 indique aux moteurs de recherche et aux navigateurs que la page a définitivement déménagé, transférant ainsi le référencement (SEO) et l’autorité de l’ancienne URL vers la nouvelle. Elle est idéale pour les migrations de site ou les changements de structure durables. À l’inverse, la redirection 302 signale un déplacement temporaire, utile pour des maintenance ou des tests, mais sans transférer le capital SEO. L’article détaille aussi comment les implémenter via le fichier .htaccess (Apache) ou la configuration serveur, et souligne l’importance de choisir le bon type pour éviter de nuire au référencement ou à l’expérience utilisateur. En résumé : utilisez le 301 pour les changements définitifs, et le 302 pour les situations provisoires.

Scott H. Young propose dans cet article une méthode efficace pour transformer la lecture en actions concrètes : le "One-Month Knowledge Sprint". L’idée est de choisir un thème précis (santé, carrière, apprentissage d’une compétence, etc.), d’agir immédiatement avec les connaissances actuelles, puis d’approfondir le sujet en lisant 1 à 5 livres de qualité (en privilégiant d’abord les manuels et les ouvrages consensuels, puis les perspectives alternatives). L’objectif est d’ajuster ses actions en fonction des enseignements tirés, sur une durée d’un mois — assez longue pour progresser, assez courte pour rester motivé. Young insiste sur l’importance de combiner action et lecture dès le départ, plutôt que d’attendre une maîtrise théorique parfaite. Cette approche permet d’éviter la procrastination et d’expérimenter rapidement, tout en s’appuyant sur des bases solides. Une méthode idéale pour ceux qui veulent apprendre et changer sans se perdre dans la théorie.

L'auteur explique qu’il n’existe pas de solution miracle pour empêcher les données sensibles (mots de passe, clés API, PII) d’apparaître dans les logs, mais une combinaison de "balles de plomb" — des mesures ciblées et complémentaires — permet de réduire significativement les risques. Il identifie d’abord les causes courantes : logs directs accidentels, objets "éviers de cuisine" (comme les erreurs HTTP contenant des configurations sensibles), changements de niveau de log, secrets intégrés dans des URLs ou des télémetries, ou encore les entrées utilisateurs imprévisibles.

Pour y remédier, il propose 10 pistes :

• Architecture des données : centraliser les flux de logs pour mieux les contrôler.
• Transformations : minimisation, rédactions, tokenisation ou masquage des données avant logging.
• Primitives de domaine : encapsuler les secrets dans des objets dédiés (ex. Secret) pour empêcher leur logging accidentel, avec des vérifications à la compilation ou à l’exécution.
• Objets à lecture unique : des wrappers qui bloquent l’accès au secret après sa première utilisation.
• Vérification de souillure (taint checking) : analyser statiquement les flux de données pour détecter les fuites vers les logs.
• Formatteurs de logs : filtrer ou redacter automatiquement les champs sensibles dans les pipelines de logging.
• Tests unitaires : faire échouer les tests si des secrets sont détectés dans les sorties.
• Scanners de données sensibles : outils comme TruffleHog pour détecter a posteriori les fuites, avec échantillonnage pour optimiser les coûts.
• Prétraitement des logs : nettoyer les flux avant stockage (ex. avec Vector).
• Sensibilisation des équipes : former les devs et leur donner les outils pour signaler et corriger les problèmes.

La stratégie globale repose sur 4 piliers :

1. Poser les bases (culture sécurité, définition des "secrets", logs structurés).
2. Cartographier les flux de données pour identifier les points critiques.
3. Protéger les goulots d’étranglement (ex. pipeline centralisé de logs) avec des contrôles en profondeur.
4. Prévoir la réponse aux incidents : isolation, nettoyage, analyse post-mortem.

En combinant ces approches — et en acceptant que le "zéro fuite" soit un idéal —, on limite efficacement les risques, tout en renforçant la résilience globale du système.