Le slow living n’est pas synonyme de ralentissement global, mais plutôt de gestion intelligente du temps en attribuant à chaque tâche le rythme adapté à son importance. L’idée centrale est de créer une "voie lente" dans son emploi du temps en sélectionnant un bloc de temps récurrent pour une activité prioritaire, en éliminant une source de distraction et en laissant une marge de dix minutes après. Cette approche permet de concilier productivité et présence, sans nécessiter de bouleverser son mode de vie.

L’article souligne que le slow living s’adresse particulièrement aux adultes en milieu de vie, souvent surchargés par des responsabilités professionnelles, familiales et personnelles. Plutôt que de chercher à tout ralentir, il s’agit de filtrer les sollicitations concurrentes et de se concentrer sur ce qui mérite une attention pleine et entière, comme une conversation familiale ou une tâche urgente, tout en acceptant que d’autres aspects de la vie doivent suivre un rythme plus soutenu.

Enfin, le concept se distingue du lifestyle minimaliste ou de l’intentional living en se focalisant non pas sur le choix des activités à intégrer, mais sur l’allocation optimale du temps disponible. L’objectif est de réduire l’encombrement mental en évitant la dispersion, en définissant des exceptions claires et en protégeant les marges de manœuvre, plutôt que de viser un idéal inaccessible de calme permanent.

Scott H Young explore le paradoxe du burnout en opposant deux types d’emplois : ceux perçus comme prestigieux et passionnants (médecins, enseignants, universitaires) et ceux considérés comme ordinaires. Contrairement aux idées reçues, les recherches montrent que les premiers sont plus propices à l’épuisement professionnel, non pas à cause de la difficulté objective du travail, mais en raison d’un écart entre les attentes idéalisées et la réalité, souvent décevante.

L’auteur s’appuie sur l’analyse de Jonathan Malesic, ancien professeur d’université devenu parking attendant, pour illustrer ce phénomène. Malesic a connu le burnout après avoir obtenu un poste prestigieux, réalisant que ses attentes (stimulation intellectuelle, impact profond) ne correspondaient pas à la réalité (étudiants désintéressés, bureaucratie académique). À l’inverse, son emploi précédent, bien que modeste, ne générait pas de stress, car il était perçu comme un simple gagne-pain sans prétention.

Young conclut que l’équilibre, et non la passion excessive, est la clé pour éviter l’épuisement. Une vie professionnelle alignée avec ses attentes, couplée à des sources de sens extérieures (relations, loisirs, santé), réduit les risques de burnout. Ironiquement, une obsession pour le travail peut mener à l’instabilité, tandis qu’une approche modérée favorise à la fois la résilience et la productivité.

L’article relate une expérience où des agents d’IA chargés de refondre une architecture logicielle ont involontairement effacé des mois de savoir-faire intégré dans le code, sans enfreindre aucune règle formelle. Les régressions apparues ensuite ont révélé que ces outils, bien que produisant un code propre et conforme aux patterns, avaient ignoré des ajustements empiriques cruciaux, non documentés et non testés, car sans valeur apparente pour un algorithme. Leur comportement par défaut, sans garde-fous explicites, a ainsi détruit une connaissance implicite accumulée sur des années.

Pour éviter de reproduire cette situation, l’équipe a restructuré son approche en s’appuyant sur des contraintes techniques strictes, notamment via ESLint, seul outil capable de bloquer efficacement les agents. L’architecture du nouveau dépôt a été repensée non pour son élégance conceptuelle, mais pour imposer des règles d’import et de modularité que les IA ne peuvent contourner, transformant ainsi des recommandations en obligations incontournables.

L’expérience illustre les limites des agents de codage en production : leur efficacité dépend entièrement des contraintes qu’on leur impose, et leur manque de compréhension contextuelle les rend incapables d’intégrer des savoirs informels. La solution retenue repose donc sur une délégation encadrée, où la qualité du code est garantie par des mécanismes automatiques plutôt que par une revue humaine systématique.

PHP 8.6 introduit une nouvelle classe Duration dans l'espace de noms Time, conçue pour représenter des durées de temps sous forme de chronomètre, comme des timeouts ou des délais de retry, sans lien avec une date calendaire. Elle comble un vide dans PHP, où ces valeurs étaient auparavant gérées par des entiers bruts, source d'ambiguïtés (secondes vs millisecondes). Contrairement à DateInterval, axée sur les écarts entre dates, Duration offre une précision jusqu'à la nanoseconde et est immuable, évitant les modifications accidentelles.

La classe propose des méthodes statiques pour créer des instances, comme fromSeconds(), fromMilliseconds() ou fromHours(), et expose trois propriétés publiques en lecture seule : $seconds, $nanoseconds et $negative. Cette dernière permet de gérer les durées négatives de manière claire, simplifiant les calculs d'absolue. Les opérations arithmétiques, comme la multiplication ou l'addition, sont effectuées via des méthodes dédiées (ex. multiplyBy()), garantissant l'immuabilité des objets.

Duration a été pensée pour améliorer l'ergonomie de l'API de polling de PHP 8.6, mais son utilité s'étend au-delà, offrant une solution robuste pour manipuler des durées dans du code applicatif. Son design final et readonly assure une gestion sécurisée et explicite des laps de temps, réduisant les risques d'erreurs liés aux unités de mesure.

L’article explique comment masquer l’état interne d’un objet TypeScript pour éviter qu’il ne soit utilisé directement par les consommateurs. L’auteur montre que les conventions comme le préfixe underscore ne suffisent pas, car les propriétés restent accessibles. En revanche, l’utilisation d’un symbole unique comme clé de propriété permet de restreindre l’accès à cet état, car il ne peut être référencé qu’à l’intérieur du module où il est défini.

Cette technique permet de conserver un état interne tout en simplifiant l’API publique de l’objet. Les fonctions du même module peuvent accéder à la propriété via le symbole, tandis que les opérations standard comme Object.keys ou JSON.stringify l’ignorent. Cela évite que l’état interne ne devienne une partie involontaire de l’interface publique.

Cependant, les symboles n’offrent pas une protection absolue : des méthodes comme Reflect.ownKeys ou Object.getOwnPropertySymbols permettent de les découvrir. Cette approche reste donc adaptée pour décourager un accès accidentel plutôt que pour une sécurité stricte, notamment dans le cadre d’API de bibliothèques.

L’article Music theory for programmers explique la théorie musicale à travers le prisme de la programmation, en partant des principes physiques et mathématiques. L’auteur, qui ne joue pas d’instrument, démontre comment générer des notes, des gammes et des accords via du code, sans avoir à mémoriser des conventions arbitraires. L’idée centrale repose sur la modélisation d’un son comme une variation de nombres dans le temps, illustrée par des exemples concrets utilisant l’API Web Audio.

L’auteur aborde ensuite la notion de fréquence (exprimée en hertz) comme base de la hauteur des notes, soulignant son caractère arbitraire (comme le La à 440 Hz). Il montre comment créer une onde sinusoïdale simple et ajuster son volume avec une enveloppe (attack, decay) pour éviter les artefacts sonores indésirables, comme les clics. Ces concepts fondamentaux servent de fondation pour construire des structures musicales plus complexes.

Enfin, l’article prépare le terrain pour l’introduction de la notation musicale traditionnelle, une fois les bases physiques et algorithmiques établies. L’approche privilégie la compréhension intuitive plutôt que l’apprentissage par cœur, en s’appuyant sur des exemples exécutables directement dans le navigateur.

L’article explique comment fail2ban peut renforcer la sécurité d’un serveur web Apache en filtrant automatiquement les adresses IP suspectes. L’auteur, Da Scritch, détaille son utilisation pour bloquer les tentatives de brute-force et autres comportements abusifs, réduisant ainsi les risques d’exploitation tout en limitant l’impact sur les performances. Le logiciel s’appuie sur des expressions régulières pour analyser les logs et appliquer des règles de blocage via iptables ou nftables, sans perturber le fonctionnement des services surveillés.

L’auteur souligne que fail2ban est une solution légère, consommant peu de ressources (environ 30 Mo de RAM et moins de 6 % de CPU), tout en étant efficace contre les scans automatisés. Il précise que son serveur, hébergé par un FAI associatif, subit en moyenne 80 requêtes malveillantes par seconde, illustrant l’utilité de l’outil pour atténuer ces attaques répétées.

Enfin, Da Scritch insiste sur l’importance de sécuriser un serveur, même pour un usage personnel, afin de ne pas impacter d’autres utilisateurs du réseau. Il présente fail2ban comme une solution simple et peu intrusive, idéale pour compléter d’autres mesures de protection sans nécessiter de refonte majeure de l’infrastructure.

L’auteur explique comment résoudre un problème de connexion WebDAV entre Nextcloud et Nautilus après un changement de mot de passe ou l’activation de la 2FA. Le navigateur de fichiers GNOME échoue à se connecter car il conserve l’ancien mot de passe dans le trousseau de clés de GNOME, malgré la mise à jour du mot de passe ou la création d’un jeton d’application. La solution consiste à supprimer ou modifier l’entrée correspondante dans le trousseau via un outil comme Seahorse.

Le problème est lié à la gestion des identifiants par GVFS, la couche sous-jacente utilisée par Nautilus, qui ne prend pas en compte les modifications manuelles des mots de passe dans l’URL de connexion. L’auteur précise que ce comportement est connu des développeurs et documenté dans un ticket GitLab.

Un commentaire suggère l’utilisation des liens publics de Nextcloud pour un accès WebDAV plus sécurisé et limité, tandis qu’un autre questionne l’usage de Nautilus plutôt que du client officiel Nextcloud.

La propriété CSS flex-wrap: balance, disponible depuis Chrome 150, permet d’éviter l’effet d’"orphelin" où un seul élément s’enroule seul sur une nouvelle ligne dans un conteneur flex avec flex-wrap: wrap. Elle redistribue automatiquement les éléments pour un rendu plus équilibré, contrairement à la méthode classique qui peut nécessiter des media queries fragiles.

L’article illustre ce problème avec un exemple concret où des liens de navigation s’enroulent de manière déséquilibrée, puis montre comment flex-wrap: balance résout ce cas. Il aborde aussi un exemple réel sur Buffer.com, où des icônes sociales s’espacent de façon inesthétique en cas de redimensionnement, et propose deux solutions alternatives (container queries et max-width avec clamp) pour les navigateurs ne supportant pas encore cette propriété.

Enfin, l’auteur souligne que flex-wrap: balance simplifie la gestion des layouts flexbox responsives, réduisant le besoin de recourir à des astuces complexes, tout en restant limité à Chrome pour l’instant.

BLONK! est un système d'exploitation minimaliste pour PC x86, entièrement développé manuellement, sans recourir à des outils existants comme Linux ou GRUB. Son objectif est pédagogique : comprendre le fonctionnement interne des ordinateurs en partant de zéro, en écrivant chaque composant à la main. Le nom "BLONK!" provient des initiales des modules clés (Boot, Loader, Kernel) et d'une touche d'humour.

L'auteur souligne que ce projet s'adresse à des développeurs expérimentés, maîtrisant l'assembleur, les langages compilés et les concepts matériels comme la segmentation ou les interruptions. La série d'articles suit une approche pratique, où chaque publication correspond à une fonctionnalité implémentée et testée d'abord sur émulateur, puis sur du matériel réel pour garantir sa robustesse.

Le projet se distingue par son exigence de compatibilité avec plusieurs machines physiques, couvrant différentes générations de matériel et BIOS, afin d'éviter les écueils des environnements trop tolérants comme les émulateurs. L'objectif final est de construire un système fonctionnel capable de démarrer, afficher des informations, interagir via un clavier et exécuter un shell.

L’article explique comment une mise à jour automatique de MariaDB via Docker et Watchtower a causé des problèmes de compatibilité silencieuse. Le site fonctionnait normalement, mais les sauvegardes de la base de données échouaient en raison d’une incompatibilité entre les versions des tables système (11.3.2 vs 12.3.2). Le conteneur avait été mis à jour vers une version majeure plus récente, tandis que le volume persistant conservait l’ancien schéma, sans migration automatique.

L’auteur souligne que l’image Docker mariadb:latest et Watchtower ont agi comme prévu, mais sans coordination pour les bases de données persistantes. Il recommande d’activer MARIADB_AUTO_UPGRADE pour automatiser les migrations ou de désactiver les mises à jour automatiques pour les services critiques. La leçon retenue est d’automatiser avec prudence et de gérer manuellement les migrations des données persistantes.

Le protocole Spanning Tree (STP), et sa version moderne RSTP, permet d'éviter les boucles dans les réseaux Ethernet en bloquant certains chemins redondants, formant ainsi un arbre sans cycle. L'article illustre son fonctionnement via une simulation interactive dans le navigateur, montrant comment le protocole réagit aux changements de topologie en temps réel, comme la déconnexion d'un câble, avec une reconvergence en moins d'une seconde. Conçu dans les années 1980 et standardisé par l'IEEE, RSTP a remplacé le STP d'origine en 2004, utilisant des trames BPDU pour coordonner les commutateurs et maintenir une topologie stable.

Ce billet introduit le premier volet d’une série dédiée à l’hébergement en self-hosted d’un grand modèle de langage (LLM) à l’échelle professionnelle, à partir de l’expérience d’une équipe ayant déployé un serveur GPU chez Ippon. L’objectif est de partager un retour d’expérience pratique sur l’écosystème technique entourant les LLM, incluant les composants matériels (GPU, infrastructure) et logiciels (vLLM, Kubernetes), sans entrer dans les détails complexes de l’entraînement des modèles. L’auteur, ingénieur système, aborde les principes fondamentaux des réseaux de neurones de manière vulgarisée, en simplifiant les aspects mathématiques pour se concentrer sur les concepts clés comme les poids et les biais, qui structurent les fichiers de modèles téléchargeables (ex. Ministral-3B). Le texte prépare le terrain pour des articles ultérieurs en expliquant la nature des LLM comme des fonctions massivement paramétrées, composées de couches de neurones interconnectés via des matrices de poids.

L’auteur partage son expérience de cohabitation entre Docker Compose et K3s dans son homelab, expliquant pourquoi il maintient les deux solutions plutôt que de tout migrer vers Kubernetes. Il souligne que Compose reste plus simple et efficace pour un serveur unique, grâce à sa transparence (fichiers de configuration clairs, volumes localisés, dépannage direct) et sa légèreté, tandis que K3s apporte une uniformisation des déploiements et une préparation pour une infrastructure évolutive, notamment pour des projets multi-nœuds ou nécessitant une montée en charge. Cependant, il note que K3s ajoute une complexité d'exploitation (ressources minimales requises, gestion du stockage et de la haute disponibilité non automatique) et que son utilité se limite à des cas spécifiques, comme l'apprentissage de Kubernetes ou des environnements devant grandir.

L’auteur insiste sur le fait que le choix entre les deux outils ne dépend pas du nombre de conteneurs, mais plutôt de la facilité de maintenance et de restauration en cas de panne. Il rappelle que Compose reste pertinent même avec une dizaine de conteneurs, à condition de respecter des conventions claires (volumes nommés, images taguées, documentation des sauvegardes), tandis que K3s devient intéressant pour des besoins de scalabilité ou de résilience, bien que son contrôle-plane et ses applications ne soient pas automatiquement hautement disponibles sans configuration avancée. Il conclut que la cohabitation des deux outils est un compromis pragmatique, évitant une migration brutale et permettant de tirer parti des avantages de chaque solution selon les besoins.

L’article explique comment la sécurité au niveau des lignes (RLS) dans PostgreSQL peut être contournée dans un projet Symfony en raison du rôle propriétaire des tables. Bien que les politiques RLS soient activées, le rôle qui exécute les migrations (et donc possède les tables) ignore ces restrictions par défaut, exposant toutes les données sans restriction. Un simple ALTER TABLE ... FORCE ROW LEVEL SECURITY est nécessaire pour appliquer correctement les politiques.

L’auteur souligne que cette faille est difficile à détecter en tests, car les connexions de test utilisent souvent un superutilisateur qui contourne aussi la RLS. La configuration par défaut de Symfony, où le même rôle gère à la fois les migrations et l’application, crée un risque de fuite de données. La documentation PostgreSQL mentionne ce comportement, mais il est souvent ignoré lors de la mise en place des politiques.

L’article critique l’approche traditionnelle des systèmes multi-agents en IA, qui se concentre souvent sur l’orchestration des agents plutôt que sur la modélisation du domaine métier. L’auteur souligne que les règles et contraintes (comme les seuils d’approbation) ne devraient pas être intégrées dans les prompts des agents, mais plutôt encapsulées dans un modèle de domaine bien défini. Cela permet aux agents d’agir dans un environnement structuré, recevant des retours immédiats en cas d’erreur, et favorise une autonomie plus robuste.

Plutôt que de concevoir des workflows complexes entre agents, l’article plaide pour une architecture où le domaine est modélisé en premier : processus, état, invariants et règles métier. Les agents interagissent ensuite avec ce modèle partagé, sans avoir à gérer eux-mêmes les contraintes. Cette séparation réduit les risques liés aux erreurs de compréhension des règles et évite les systèmes soit trop risqués, soit trop restrictifs.

L’auteur présente Mozaik, un framework qui adopte cette approche en introduisant un état partagé et concurrentiel pour les agents, tandis que le modèle de domaine garantit le respect des règles. L’objectif est de construire des systèmes plus fiables et évolutifs, en s’appuyant sur une modélisation précise du monde réel plutôt que sur des workflows artificiels.

DeltaChat est une application de messagerie chiffrée de bout en bout, comparable à WhatsApp ou Signal, mais avec des différences notables. Contrairement à WhatsApp, elle ne collecte pas les contacts des utilisateurs ni ne les transmet à des tiers comme Facebook. Son chiffrement est systématique, sans option à désactiver, et son identité repose sur une clé cryptographique stockée localement, sans mot de passe ni dépendance à un serveur spécifique.

L’absence de spam est un autre avantage majeur : les comptes ne sont pas énumérables, et les contacts ne peuvent être ajoutés que via un QR-code ou une URL d’invitation, ce qui limite les risques de sollicitations indésirables. DeltaChat propose aussi des relais par défaut (comme nine.testrun.org), mais permet d’en ajouter ou supprimer, voire d’héberger son propre serveur pour plus de contrôle.

Enfin, DeltaChat se distingue par sa simplicité de création de compte (un pseudo suffit) et son approche décentralisée, où l’identité numérique reste sous le contrôle exclusif de l’utilisateur. Cependant, la perte de l’appareil entraîne la perte définitive de cette identité, d’où l’importance de sauvegarder régulièrement son profil.

L’article souligne que le Domain-Driven Design (DDD) gagne en importance avec l’essor de l’IA générative, car cette dernière simplifie la partie technique du développement, mais ne remplace pas la nécessité de bien comprendre et modéliser le domaine métier. L’auteur, Miłosz Smółka, rappelle que le DDD, popularisé par Eric Evans en 2003, reste pertinent car la complexité centrale des projets logiciels réside dans la résolution des problèmes métiers, et non dans les détails techniques.

L’IA permet désormais de générer du code rapidement, réduisant l’importance des frameworks et des langages, mais elle ne peut pas remplacer le travail collaboratif entre experts métiers et développeurs pour construire un modèle précis. Le DDD insiste sur la knowledge crunching (affinage des connaissances) et des méthodes comme l’Event Storming pour capturer la logique métier, des étapes que l’IA ne peut automatiser entièrement.

Enfin, l’article met en garde contre la tentation de confier la modélisation du domaine à l’IA, soulignant que cette tâche reste un effort collectif et itératif. L’optimisation des outils d’IA pour générer du code doit s’accompagner d’une focalisation accrue sur la compréhension du domaine, sous peine de reproduire les erreurs passées où la technologie était privilégiée au détriment du problème à résoudre.

Plexus est une plateforme collaborative qui évalue la compatibilité des applications Android sur des appareils dé-Googlés, en s’appuyant sur les contributions de la communauté. Elle recense plus de 10 000 applications, notées selon leur fonctionnement sans dépendre des services Google : Gold pour un usage parfait, Silver pour des problèmes mineurs, Bronze pour des limitations notables, et Broken pour les applications inutilisables. Une distinction est également faite pour les appareils utilisant microG, une alternative open-source aux services Google Play.

Les statistiques montrent une majorité d’applications bien notées (12 517 Gold en dé-Googlé), mais un nombre significatif reste problématique (1 088 Broken). La plateforme permet aux utilisateurs de partager leurs retours pour améliorer la compatibilité des logiciels avec ces environnements alternatifs.

Développée par Techlore, Plexus propose des liens vers son code source, des téléchargements et des ressources complémentaires, tout en restant accessible via une API pour les développeurs.

Cette page de Chris Burnell illustre la puissance croissante du HTML natif, qui permet désormais des interactions dynamiques autrefois réservées à JavaScript. Elle présente des fonctionnalités comme les popovers, les modales <dialog>, les groupes <details> ou encore les attributs loading="lazy" et hidden until-found, démontrant comment le navigateur gère seul des comportements complexes sans code supplémentaire.

L’auteur souligne cependant les limites d’implémentation et d’accessibilité de certaines de ces fonctionnalités, comme le popover ou le hidden until-found, qui peuvent poser problème selon les navigateurs ou les outils d’assistance. Il encourage à les tester tout en veillant à les rendre accessibles.

Enfin, des éléments comme command et commandfor ouvrent la voie à des interactions encore plus poussées, bien que leur support reste partiel. La page sert à la fois de démonstration et de rappel sur l’évolution continue des standards web.