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.).

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 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.

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.

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.

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.

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.

Gonzalo Ayuso partage un projet d’agent IA personnalisé pour recommander des films, développé avec Python et Strands Agents. L’objectif ? Automatiser le choix de son film du samedi après-midi en croisant les horaires des cinémas locaux (via SadeCines.com), ses notes et préférences personnelles (Letterboxd), ainsi que les critiques (IMDb/Metacritic). L’agent utilise des outils comme un navigateur sandboxé pour scraper le web, un interpréteur de code Python sécurisé pour traiter les données, et des prompts détaillés pour affiner les recommandations selon ses goûts (action, science-fiction, comédie) et exclusions (films familiaux, drames). Le code, simple et basé sur AWS Bedrock, illustre le potentiel des agents multi-outils, même si l’auteur reconnaît un certain over-engineering pour un usage individuel. Le projet, open source, montre comment combiner LLM, scraping et exécution de code de manière sécurisée pour créer un assistant sur mesure.

L’article relate l’expérience d’un ingénieur utilisant Claude Code pour automatiser des tâches de développement (refactoring, correction de bugs, écriture de tests). Si l’outil excelle pour des corrections ponctuelles, il génère souvent des PRs volumineuses et illisibles, rendant la revue de code difficile. La solution trouvée : apprendre à Claude à structurer son travail en "stacked PRs" (séries de petites PRs ciblées et indépendantes), comme le feraient des humains expérimentés. En guidant l’IA avec des instructions précises et en utilisant l’outil GT MCP de Graphite, l’auteur parvient à obtenir des PRs claires, testables et faciles à relire. Résultat : une intégration plus fluide de l’IA dans le workflow, permettant de construire des fonctionnalités complètes, de corriger des bugs complexes et d’ajouter des tests, tout en gardant un code maintenable et collaboratif.

Ce dépôt présente les principaux design patterns avec des exemples en JavaScript

Résumé pour Shaarli :

Le Domain-Driven Design (DDD) peut sembler complexe pour les développeurs backend habitués à une approche "data-first" (comme avec Laravel ou Symfony), car il inverse la logique : au lieu de partir des données ou des outils, on organise le code autour du métier et de ses règles. Le DDD introduit des frontières claires (Domain, Application, Infrastructure) et un langage ubiquitaire pour aligner code et besoins business, ce qui casse les habitudes de développement procédural ou centré sur le framework. Les concepts clés comme les Bounded Contexts, Entities, Value Objects et Repositories aident à structurer le code pour le rendre plus maintenable et testable. La courbe d’apprentissage est raide car elle demande de passer d’une pensée technique à une pensée métier, mais même une adoption progressive apporte plus de clarté et de modularité. L’article propose une approche "DDD-lite" avec une structure de projet simple et suggère d’utiliser le BDD pour faciliter la transition en collaborant avec les experts métier. En résumé : le DDD, c’est avant tout des frontières et du vocabulaire partagé, pas de la magie architecturale.

Sean Goedecke y explique que le bon design système repose sur la simplicité, la minimisation de l’état (state) et l’utilisation judicieuse de composants éprouvés (bases de données, caches, files d’attente, etc.). Un bon design se remarque surtout par son absence de problèmes et sa discrétion : si tout fonctionne sans accroc et semble plus simple que prévu, c’est souvent signe de réussite. L’auteur insiste sur l’importance de centraliser la gestion de l’état (via une base de données bien structurée et indexée), d’éviter la complexité inutile, et de privilégier des solutions robustes plutôt que des astuces sophistiquées. Les opérations lentes doivent être déléguées à des tâches en arrière-plan, et le cache utilisé avec parcimonie. Enfin, il souligne que les "hot paths" (chemins critiques) méritent une attention particulière, tout comme la journalisation et la gestion des échecs (killswitches, retries). En résumé, un bon design système est souvent invisible, mais efficace et maintenable sur le long terme.

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.

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

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.

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.

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.

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 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 !

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.

Les entreprises ne se soucient ni de la productivité ni du management moderne, seulement du contrôle et des cours boursiers. Malgré les preuves accumulées (bureaux ouverts nuisibles, télétravail bénéfique pour le sommeil et les coûts, etc.), les dirigeants ignorent les théories managériales éprouvées (comme celles de Deming) au profit de la surveillance et de l’autoritarisme. Même si les outils d’IA générative promettent des gains de productivité, leur variabilité et leurs coûts cachés (verrouillage, impact environnemental, risques politiques) en font un pari dangereux, surtout couplés à des licenciements. Pire, leur adoption reflète souvent une logique de bulle spéculative, où les avertissements rationnels sont ignorés — comme avant l’éclatement de la bulle immobilière de 2008. En réalité, ces outils, en augmentant la variabilité des tâches, risquent de paralyser les organisations en surchargeant les processus et en réduisant la capacité réelle de travail. Résultat : une course à l’abîme, où seuls comptent le contrôle et l’illusion de l’innovation, au mépris de l’efficacité et du bien-être. Une analyse systémique révèle leur toxicité, mais personne n’écoute : ceux qui en ont les moyens fuient déjà la bulle, les autres subissent.

Le « vibe coding » permet-il de créer une app iPhone sans coder ? Ludovic Toinel partage son expérience : grâce à GitHub Copilot (avec Claude 3.7) et ChatGPT (GPT-4o), il a développé Contactidy, une app utilitaire pour normaliser les contacts, en une soirée. Si l’IA a généré la majorité du code, du design et même les traductions, des corrections manuelles (refactoring, gestion du Info.plist, bindings SwiftUI) ont été nécessaires pour obtenir un résultat propre et fonctionnel. Malgré quelques limites (code parfois complexe, temps de réponse), l’approche s’avère très efficace pour des projets simples, à condition d’avoir un minimum de connaissances techniques pour guider et corriger l’IA. L’app est disponible sur l’App Store. Une méthode prometteuse, mais pas encore magique !

Il s'agit d'un comparatif de différentes bibliothèques de composants UI pour Vue / Nuxt

EventCatalog est un outil open source qui comble un manque crucial dans les architectures orientées événements : la documentation claire et maintenable. En adoptant une approche "documentation-as-code", il permet de décrire et visualiser les messages (événements, commandes, requêtes), les canaux de communication, les domaines, services et entités (inspirés du Domain-Driven Design), ainsi que les équipes et le langage ubiquitaire. Intégrable avec des registres de schémas (OpenAPI, AsyncAPI, JSON, Avro), il automatise la génération de documentation interactive, facilitant la compréhension et la maintenance des systèmes asynchrones. Grâce à des fonctionnalités comme les graphes de dépendances, la visualisation des schémas et la gestion des équipes, EventCatalog rend accessible et vivante la complexité des architectures événementielles, tout en restant simple à déployer et à mettre à jour. Une solution idéale pour aligner documentation et développement, surtout dans des écosystèmes distribués.

La dette technique est inévitable dans tout projet logiciel, mais la clé réside dans sa gestion stratégique plutôt que dans son élimination totale. Cet article explique comment évaluer quand il est judicieux de réécrire du code (par exemple, avant d’ajouter une nouvelle fonctionnalité ou en cas de risques majeurs) et quand il vaut mieux la tolérer temporairement (lorsque le coût dépasse les bénéfices immédiats). L’auteur propose une matrice décisionnelle et des conseils pour convaincre les parties prenantes en traduisant l’impact technique en arguments business : gain de temps, réduction des risques, et amélioration de la vélocité d’équipe. L’objectif ? Équilibrer pression court terme et santé long terme du code, sans tomber dans le piège de la quête de perfection.

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.

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).

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.

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.

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.

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 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 !

Un éditeur markdown WYSIWYG léger

Suite de https://meyerweb.com/eric/thoughts/2025/08/07/infinite-pixels/ , Eric Meyer explore dans ce billet les comportements inattendus et parfois incohérents entre navigateurs (Safari, Chrome, Firefox) lors de l’utilisation du mot-clé CSS infinity dans des calculs (calc()). Il teste son impact sur des propriétés comme text-indent, word-spacing, letter-spacing, z-index ou encore animation-duration. Résultat : selon le navigateur, les valeurs calculées varient énormément (de 33 millions de pixels à des nombres astronomiques), et certaines propriétés, comme z-index, voient leur valeur plafonner à 2147483647, rendant impossible un "au-delà de l’infini". Les animations avec une durée infinie deviennent inutilisables, surtout sur Safari, tandis que diviser un nombre fini par l’infini donne systématiquement 0, une rare harmonie entre les navigateurs. Une plongée ludique et technique dans les limites (ou leur absence) de CSS ! [

Eric Meyer, au détour d'un message sur Mastodon, est tombé sur une règle CSS intrigante : width: calc(infinity * 1px); Il a décidé de mener des tests avec Chrome, Safari et Firefox afin de voir quelles valeurs sont réellement utilisées, ce qui a donné des résultats assez étonnants.

Un concurrent de ngrok ?

Il s'agiç d'une bibliothèque de composants pour Vue.js basée sur Tailwind et PrimeVue

Le Backend For Frontend (BFF) est un pattern architectural qui agit comme une couche intermédiaire entre les applications frontend (web, mobile, etc.) et les API ou microservices. Son objectif est de simplifier la récupération et la transformation des données en centralisant la logique d’agrégation et d’adaptation des données côté serveur, plutôt que de la laisser aux clients. Cela évite de surcharger les applications frontend avec des tâches complexes et permet d’offrir une réponse sur mesure, optimisée pour chaque type de client (mobile, web, etc.). Contrairement à une API Gateway, le BFF est dédié à un type spécifique de client, ce qui permet de mieux répondre à ses besoins en termes de format de données, gestion d’erreurs ou authentification. Ce pattern est particulièrement utile dans un contexte MACH (Micro Services, API-first, Cloud Native, Headless) ou lorsque les besoins des utilisateurs varient selon le type d’application, mais il ajoute une couche supplémentaire à maintenir et nécessite des compétences fullstack. Son adoption se justifie surtout si l’expérience utilisateur doit être différente selon les plateformes.

Alexandre Touret partage son retour d’expérience sur un atelier d’Architecture Kata organisé lors de la Riviera Dev, où plus de soixante participants ont planché sur la conception d’une plateforme numérique dédiée au tourisme solidaire et durable. L’objectif était de proposer une solution intégrant profils utilisateurs éco-responsables, tableau de bord d’empreinte carbone, gamification et gestion d’activités locales, avec des contraintes techniques et métiers variées. L’article présente trois approches distinctes : deux propositions d’équipes (dont une très détaillée avec des diagrammes Structurizr) et la sienne, soulignant l’importance de clarifier les besoins métiers, de prioriser les flux principaux et d’externaliser les fonctions critiques (comme les paiements). L’exercice illustre la diversité des solutions possibles selon l’expérience des participants et rappelle que la pratique régulière des katas permet d’améliorer la prise de décision, la communication et l’adaptabilité en architecture logicielle. Une ressource utile pour quiconque s’intéresse à l’amélioration des compétences en design système.

Ce guide démystifie l’élément <path> en SVG, souvent perçu comme complexe. À travers des exemples interactifs, il explique comment utiliser les commandes (M, L, Q, C, A, etc.) pour dessiner des lignes, courbes de Bézier et arcs elliptiques, en enchaînant des instructions comme avec un stylo. Le guide couvre aussi les astuces (fermeture de chemin, commandes relatives) et montre comment créer des formes avancées, utiles pour le design et les animations web.