Programme

Le projet Loom a déjà livré les threads virtuels et les scoped values. Il reste encore un élément en preview : l'API de Concurrence Structurée, qui permet de lancer des tâches en parallèle tout en conservant les paradigmes de la programmation structurée. Pour le moment, cette tâche est remplie par le pattern Executor, ou par la programmation réactive. L'API de Concurrence Structurée nous apporte de nouveaux patterns de code, qui utilisent les threads virtuels.


Le code que l'on écrit est plus lisible, plus facile à comprendre. Les éventuelles exceptions générées donnent des piles d'appel qui emmènent là où le code à échouer, ce qui permet de débugger ces applications efficacement.


Cette présentation vous montre ces patterns, construits sur l'utilisation de nouveaux objets : les StructuredTaskScope, qui utilisent des Joiners afin de préciser les stratégies de fonctionnement du système et d'analyse des résultats produits.

L’accessibilité numérique reste un enjeu majeur : selon l’Observatoire du respect des obligations d’accessibilité, moins de 5 % des sites internet sont réellement accessibles aux personnes handicapées.

Dans cette conférence, je propose de découvrir :

• les six erreurs d’accessibilité les plus courantes sur les sites web ;
• comment les corriger facilement grâce à des bonnes pratiques simples en HTML, CSS et Javascript ;
• comment réaliser des tests utilisateurs d'accessibilité avec un lecteur d’écran et le clavier ;
• et dans quelle mesure il est possible d'automatiser ces tests.
  
  J’ai créé un site volontairement inaccessible pour une démonstration en live-coding.
  
  Mon objectif est de montrer que l’accessibilité numérique est à la portée des développeurs et développeuses.

Tout a commencé par une idée un peu folle : créer un jeu… sans savoir coder, sans designer, sans équipe, et sans le moindre budget.
Quelques mois plus tard, un prototype fonctionnel existait. Entre les deux ? Une alliance inattendue : un Product Owner et quatre IA génératives travaillant comme une équipe Produit éclair.

Cette session vous embarque dans les coulisses d’une expérience radicale : transformer une idée en produit grâce à l’IA, en appliquant (et parfois bousculant) les bonnes pratiques du Product Management.
Vous découvrirez comment l’IA a participé à la vision, au story mapping, au backlog, aux architectures, au prototypage, et même au gameplay — mais aussi où elle a échoué, et ce que seule l’expertise humaine peut réellement décider.

Un récit, un apprentissage, et surtout une question ouverte : sommes-nous prêts pour la conception produit “IA-native” ?

Dans le paysage du frontend, il y en a un qui met (presque) tout le monde d’accord. Au point où, mi-2025, son nombre de téléchargements a dépassé celui de Webpack.

Vite est devenu, en l’espace de quelques années, un incontournable, une plateforme et une infrastructure communes pour le frontend. Vue, Nuxt, Remix, TanStack Start, Angular, Analog, Solid, Qwik, Astro, Slidev, Storybook, Tailwind CSS, Cloudflare, Laravel, Nitro et bien d’autres se basent désormais dessus. Il n’y a que Next qui résiste.

Au-delà d’utiliser Vite, toutes ces librairies et frameworks reposent sur un unique et même concept : les plugins, seul moyen d’étendre les capacités de Vite. Même les fonctionnalités de Vite sont des plugins ! Mais sais-tu comment ils fonctionnent ? Comment en développer un ? Et ce qui se cache dans la pipeline qui les orchestre tous ?

Dans cette session, plonge dans le monde fascinant (et parfois énigmatique) de la pipeline de Vite. Ensemble, nous repasserons sur l’histoire de Vite, de son passé à son futur, puis nous nous intéresserons à son fonctionnement en analysant la pipeline à travers de véritables plugins. À la fin, Vite n’aura plus de secret pour toi.

There’s something weird in your fridge today… food you can’t recognize, ingredients that look like they’ve been living there since July.

• Weird Al Yankovic -
  
  In this hands-on workshop, you’ll learn how to tame that chaos with your very own local MCP server:
• Resources: see what’s actually available so you can finally answer “what’s in this fridge?” without fear.
• Tools: manage your inventory, add or consume ingredients, and stop the mold from growing… well, mostly.
• Prompts: ask targeted questions like “What vegetarian dish can I make in under 30 minutes?” or “Is this liver cake or woolly mammoth steak?”.
  
  By the end of the session, you’ll walk away with a fully working MCP instance ready to help you manage meals, inventory, and maybe even your roommate’s mysterious leftovers, no carbon dating required. It’s your fridge, your rules…

Dans la Tech, les projets n'échouent pas à cause du code, mais souvent à cause d'incompréhensions humaines. Et si vos "problèmes de communication" étaient en fait des "incompatibilités d'interface" cognitive ?

Votre mission sera de lancer AlienConnect, le premier réseau social intergalactique capable de connecter des milliards d'espèces biologiques différentes.

Le pitch est beau, mais la réalité du projet est un champ de mines. Dans cet atelier, le sort vous attribuera deux cartes qui définiront votre expérience :

• Votre rôle métier : Serez-vous ce Développeur pragmatique qui ne jure que par la scalabilité ? Ce PO pressé par les investisseurs ? Ou ce Designer qui veut innover à tout prix ?
• Votre planète cognitive : C'est là que tout bascule. Vous incarnerez peut-être un habitant de Zeris (profil TDAH), moteur d'énergie créative mais impatient face aux réunions qui s'éternisent. Ou une espèce qui communique par la littéralité absolue, ou l'hypersensibilité sensorielle.
  
  Durant cet atelier immersif de 110 minutes, vous allez :
  
• Incarner la friction : Vivre de l'intérieur comment un rituel agile classique peut devenir un enfer sensoriel ou un obstacle cognitif pour votre voisin.
• Hacker le système : Collaborer sous contrainte pour livrer votre mission malgré (et grâce à) vos différences.
• Designer l'inclusion : Co-créer une "Checklist Intergalactique" pour debugger vos échanges dès votre retour au bureau.
  
  Venez tester votre empathie en conditions réelles. Aucun prérequis, juste l'envie de construire une équipe où chaque cerveau a sa place.

Et si la clé pour des équipes performantes était de les laisser échouer ? Dans un monde où l’on célèbre la réussite à tout prix, cette session propose un regard décalé : les murs contre lesquels vos équipes se cognent sont des opportunités d’apprentissage inégalées. Que ce soit en développement logiciel, en gestion de projet ou en organisation d’équipe, les erreurs sont des catalyseurs de croissance — à condition de savoir les exploiter.
Nous explorerons ensemble :

Pourquoi l’échec est un cadeau : Comment les bugs, les retards et les conflits transforment les équipes en machines à innover.
Les bonnes pratiques pour "bien" échouer :

En développement logiciel : L’art de casser du code pour mieux le reconstruire (TDD, refactoring, post-mortem).
En gestion de projet : Quand un sprint raté devient une leçon de planification.
En organisation d’équipe : Les conflits comme outil de clarification des rôles et des attentes.

Créer une culture du "Fail Fast, Learn Faster" : Comment les managers et les leaders peuvent encourager la prise de risque sans mettre en danger l’entreprise.
Retours d’expérience d’équipes qui ont transformé leurs échecs en succès
Public cible :
Développeurs, Scrum Masters, Product Owners, managers, et toute personne convaincue que la performance naît de l’audace, pas de la perfection.

Il paraîtrait que “plus d’agents = plus d’intelligence”, et qu’il suffirait donc de se construire une armée d’agents pour résoudre tous vos problèmes…

Sauf que dans la réalité, les tokens explosent, la latence grimpe, la maintenabilité disparaît, et vos utilisateurs s’arrachent les cheveux. Comme les Minions : un agent IA seul, c’est mignon ; collectivement, c’est le chaos !

Dans ce talk, nous explorerons plusieurs patterns d’architectures multi-agents, et surtout comment faire collaborer efficacement vos IA tout en gardant le contrôle sur la mémoire, les coûts et la performance.

Vous repartirez avec des idées concrètes et adaptables à vos cas d’usage, pour construire des systèmes multi-agents robustes, efficaces et… un peu moins chaotiques.

Dark mode ou light mode : on a tous une opinion… mais rarement de bons arguments !

Dans ce talk, on vous embarque dans une enquête pleine de surprises : études scientifiques, lisibilité, fatigue visuelle, myopie, accessibilité, perception, consommation énergétique…

À partir d’un thème clair, nous montrons comment concevoir un thème sombre cohérent en nous appuyant sur des bonnes pratiques de design et en exploitant les design tokens qui définissent un langage commun design/dev pour faciliter l'implémentation et l'évolutivité du code.

Les ingénieurs des petites et grandes entreprises déploient leurs applications à l'aide de services Kubernetes gérés dans le cloud, car ils sont convaincus que cela leur permettra de migrer facilement leurs appli entre fournisseurs differents.
Cependant, en réalité, la plupart des plates-formes de conteneurs ne sont pas complètes en termes de fonctionnalités. Cette décision s’accompagne donc d’une série de préoccupations externes qui peuvent la rendre problématique : par ex. monitoring, gestion des identités, data gravity, pipelines de déploiement, services dépendants et bien d'autres encore !
Dans cet exposé, nous suivrons le parcours de migration d'une application demo d'AWS vers GCP et nous identifierons une série de bonnes pratiques pratiques en matière de développement logiciel et d'architecture système que vous pouvez suivre pour augmenter le niveau de portabilité de votre application Kube.
De plus, nous examinerons la configuration et les composants de l'écosystème Kubernetes que vous pouvez déployer pour simplifier considérablement les contraintes de verrouillage de la plate-forme.

Et si les mots étaient un moteur d’action ? Le content design permet d’explorer, tester et décider autrement. En l’intégrant dès la conception, on aligne parcours, intention et clarté. Une autre façon de faire du produit, plus fluide, plus lisible, plus engageante — où chaque mot compte pour faire gagner du temps à l’utilisateur.

Depuis une dizaine d’années, les animations web ont profondément transformé notre manière d’interagir avec les interfaces numériques. Qu’il s’agisse de transitions fluides, de micro-interactions ou d’effets de défilement, elles sont devenues un langage visuel à part entière. Ces animations enrichissent l’expérience utilisateur, attirent l’attention, facilitent la compréhension… et parfois, en font trop.

Mais derrière cette légèreté apparente se cachent des enjeux plus profonds : performance, accessibilité, sobriété numérique. Une animation mal pensée peut ralentir un site, exclure des utilisateurs sensibles aux mouvements, ou simplement détourner l’attention du message. À l’inverse, une animation bien conçue peut guider, apaiser, clarifier — sans surcharger.

Aujourd’hui, dans ce talk, je vous propose un voyage à travers les bonnes pratiques, les outils CSS modernes, et les choix de design qui permettent de faire bouger nos interfaces… sans les alourdir.

Vous avez créé une application web avec un framework frontend JavaScript comme Vue, React ou Svelte.

Votre application fonctionne très bien. Seul défaut ? Vous n'avez pas la moindre idée de comment votre appli marche.

De simples questions comme "Comment s'affiche initialement la page ?" ou "Comment change-t-elle dynamiquement ?" sont complexes à répondre.

D'autres restent sans réponse, comme "Quelle est la différence entre le mode "dev" et le mode "production" ?" ou "Comment l'application s'optimise-t-elle ?"

Vous lisez la documentation pour comprendre, mais les explications sont confuses : DOM virtuel, transpilation, signals, fine grained reactivity, diffing algorithm, tree-shaking... On n'est pas rendu (HTML) !

Mais tous ces concepts sont accessibles, il faut juste les décomposer en petits éléments, en des petites briques.

Et avec ces briques, nous pouvons reconstruire les fondations du web pour qu'il soit, plus léger, plus simple, et qui ne vous cachera plus rien !

Embarquez dans cette aventure et construisons ensemble notre propre framework JavaScript !

Kubernetes est devenu le standard de facto pour déployer et exploiter des applications conteneurisées. Mais comprendre Kubernetes peut s’avérer difficile ou prendre beaucoup de temps.

Il y a quelques années, je me suis demandé comment j'imaginais les concepts de Kubernetes : un pod, un déploiement, un service, un secret, une configmap, un cronjob… et j'ai ensuite créé une nouvelle façon d'expliquer les technologies Cloud visuellement.

Dans la première partie de ce talk, je vais vous raconter une histoire, je vais vous raconter mon histoire. Comment, pendant plusieurs années, j'ai travaillé chaque soir/nuit/week-end pour expliquer Kubernetes dans des sketchnotes, des articles de blog, des vidéos et finalement publié dans un livre illustré de plus de 270 pages (avec tous les concepts incluant le Debugging ainsi que des outils et des tips) et pourquoi je continue à le faire.

Et dans la deuxième partie, je vous expliquerai Kubernetes et ses concepts... de manière visuelle :-).

Vos rétrospectives tournent en rond depuis des mois. Les bonnes idées de l'équipe produit ne croisent jamais celles de la tech. L'amélioration continue existe, mais elle reste fragmentée, noyée dans l'opérationnel. Résultat : vous améliorez beaucoup dans votre coin, mais le système dans son ensemble n'évolue pas vraiment.
Infinity propose un méta-framework pour casser ces silos et structurer l'adaptabilité : 4 Ligues transverses (Valeur, Construction, Process, Leadership) où des volontaires travaillent SUR le système (pas DANS), 7 Règles minimales qui garantissent liberté et cohérence, et une gouvernance qui protège le temps de l'adaptation. À travers des retours terrain concrets (automobile, télécom), cette session vous donnera des leviers actionnables pour installer cette capacité dans votre contexte.

Key takeaways :

Comprendre pourquoi l'amélioration continue reste fragmentée malgré vos efforts
Découvrir un système en 3 piliers pour structurer l'adaptabilité (applicable dès lundi)
Identifier les premières actions concrètes pour démarrer dans votre équipe/organisation
S'inspirer de retours terrain : ce qui marche, les pièges à éviter

Venez assister au grand show du CSS, un véritable défilé des techniques pour habiller vos applications web 📸

Vanilla, Sass, CSS Modules, CSS-in-JS, Tailwind, frameworks… Toutes les approches sont réunies sous les feux des projecteurs, prêtes à dévoiler leurs plus belles coupes, leurs motifs distinctifs et même leurs petits défauts de couture 🪡

Chacune montera sur le podium pour défendre ses caractéristiques. Fonctionnalités, maintenabilité, performances, expérience de développement, flexibilité… Elles seront examinées sous toutes les coutures 🔍

Vous hésitez entre un style classique et un look ultra-moderne à la manière du CSS-in-JS ? Entre une tenue faite main et un ensemble prêt-à-porter d’un framework ? Venez découvrir quelle méthode saura vraiment sublimer votre projet et repartez avec une valise pleine d’accessoires pour habiller vos applications avec goût et efficacité 🎨

Rust est probablement le langage le plus excitant de ces dernières années. Il souffre toutefois d’une réputation qui le cantonne parfois aux outils bas niveau. Dans cette présentation, nous vous montrerons qu’en plus de répondre aux problématiques bas niveau, Rust se prête très bien à la création d’une application REST.

Dans un premier temps, nous commencerons par une introduction à Rust (30 minutes) pour explorer les concepts de base : ownership, borrowing, structs, enums, traits…

Ensuite, sous forme d’exercice, nous vous ferons créer pas à pas une application moderne :

un modèle métier au cœur de l’architecture
la persistance dans une base de données SQL
l’exposition sous forme d’API REST
la collecte de logs et de métriques OTLP

Notre quotidien — pro comme perso — est plein de paradoxes. Et souvent, ça nous rend fous !

• Peut-on récompenser individuellement tout en prônant le collectif ?
• Faut-il innover sans cesse ou stabiliser ce qui marche ?
• Centraliser les décisions… ou laisser l’autonomie s’exprimer ?
• Et cette fameuse tension vitesse vs qualité — qui n’a jamais râlé dessus ?
  
  Ces dilemmes ne sont pas des problèmes à résoudre, mais des polarités à gérer.
  
  Le piège, c’est de choisir un camp, de se rigidifier dans le « pour » ou le « contre ». Non seulement ça ne résout pas la tension, mais c'est souvent là que les relations se tendent et que la dynamique collective s’éteint :(
  
  Dans cet atelier ludique, participatif et joyeusement paradoxal, nous vous ferons expérimenter comment accepter, cartographier et naviguer dans ces polarités.
  
  Vous repartirez avec des clés concrètes pour en faire des alliées plutôt que des freins.
  
  Alors, prêt·e à apprivoiser vos paradoxes et à en rire un peu au passage ?

Les applications GenAI ne jouent pas selon les mêmes règles: non-déterminisme, surface d’attaque mouvante, pression réglementaire (EU AI Act, NIST, …). Bref, si vous ne pentestez pas votre LLM, ce sont vos nerfs qui le seront. Ce talk est un retour d’expérience sur la mise en production d’applications GenAI complexes (RAG et Agentic), avec exemples concrets, démos et leçons apprises. Il s’appuie sur plus de trois ans d’expertise terrain à concevoir, déployer et opérer des applications GenAI en production. On pose d’abord le cadre, puis on passe aux choses sérieuses, démos à l’appui. Parce que la sécurité, ce n’est pas qu’un poster dans l’open space !

D’abord, l’état de l’art pour ne pas piloter à vue: OWASP Top 10 for LLM Applications (et sa déclinaison Agentic), et les liens concrets avec la conformité (EU AI Act/DORA).


Puis, nous présenterons des démos interactives très pratico-pratiques sur une application GenAI:

Architecture défensive et observabilité d’abord (intégrations LangSmith, Langfuse).

AI Guards en I/O pour contrer prompt injections, contenus toxiques, fuites et exécutions hasardeuses; sécurisation de toute la chaîne, y compris les serveurs MCP.

Data residency et choix du modèle: région/rétention, chiffrement, hébergé vs self-hosted.

Prompt injection & output handling, filtrage sémantique; policy-as-code + sandbox pour les actions d’agents; quotas/rate limiting (les attaquants détestent).

QA sécurité en continu: jeux d’attaque Garak en CI/CD, et pentests externes pour valider le tout.

Vous repartirez avec un playbook pratique pour passer de “ça marche en démo” à “c’est solide en prod”, sans magie !




Public cible: devs/architectes, MLOps et SecOps.

Niveau: intermédiaire.

Nous mesurons le coût de l’IA générative en centimes par tranche de 1 000 tokens ou en millisecondes de latence. Mais chaque prompt s’accompagne d’une facture invisible, réglée en kilowattheures et en litres d’eau.

À mesure que l’adoption de l’IA s’accélère, son impact environnemental devient une contrainte d’ingénierie majeure. Une seule interaction avec un LLM peut consommer jusqu’à dix fois plus d’énergie qu’une requête de recherche traditionnelle, tandis que le cycle de vie du matériel génère des niveaux record de déchets électroniques.

Dans cette session, nous évaluerons le « véritable coût d’un token », en dépassant le battage médiatique pour analyser les données concrètes liées à l’entraînement et à l’inférence des modèles d’IA.

Nous passerons ensuite des métriques aux solutions, en montrant que l’« IA verte » est bien souvent synonyme d’IA efficace et économiquement pertinente.


Vous repartirez avec une boîte à outils pratique pour mieux gérer notre dépendance à ces modèles : apprendre à dimensionner correctement votre architecture, optimiser vos pipelines et mettre en œuvre des approches sensibles au carbone afin de construire une intelligence qui ne coûte pas la planète.

Le numérique répond à des besoins fondamentaux : communiquer, travailler, exercer sa citoyenneté. À l’heure où les GAFAM mettent la démocratie en péril, les logiciels libres semblent être une réponse adaptée.

Or, nous pensons qu’ils méritent d’être repensés pour être réellement à la hauteur de ces enjeux.

À travers des exemples tels que PeerTube, nous partagerons notre point de vue d’UX designeuses sur ces questions :

• En quoi l’UX et le libre se rejoignent autour des principes de démocratie ?
• Comment apporter davantage d’UX dans les projets libres, en prenant en compte les limites de temps et de budget qui peuvent se poser ?
• À l’inverse, en quoi la philosophie libriste est-elle utile à l’UX ?
  
  Quel que soit notre niveau d’aisance technologique et nos compétences, construisons ensemble le numérique populaire que nous désirons !

Dans les années 1970/1980, de nombreux enfants ont eu la chance de grandir avec des petits trains électriques, au format HO (1:87). Le principe était simple : on pose des rails, qu'on alimente en 18V, et les trains circulent sur les rails.

Un demi-siècle plus tard, mon grand-père de 85 ans et moi-même nous sommes lancés dans le projet un peu fou de faire passer au numérique ses trains électriques de cette époque. Bienvenue dans ce retour d'expérience, avec du matériel, et des humains, qui ont traversé les générations.

Au menu : de l'électronique (pas trop, promis !), des Raspberry, du TinyGo... et des petits trains, bien entendu.

Livrer en production une fois par mois, avec un monolithe partagé, des tests centralisés et un pipeline unique : c’était notre quotidien… et aussi la source de beaucoup de frustrations. Les équipes avançaient lentement, se gênaient mutuellement et butaient sur un goulot d’étranglement permanent côté validation. Impossible d’imaginer délivrer sereinement plusieurs applications par an, encore moins par trimestre.

Nous avons alors changé de vision : rendre les équipes produit autonomes, responsables et capables de délivrer elles-mêmes en production, tout en garantissant sécurité, cohérence et visibilité globale.
Pour y arriver, les Ops et les Devs sont devenus platform engineers et enablers, en construisant un véritable FastPass vers la production.

Dans ce talk, je partagerai comment nous avons :

• mis en place une plateforme Kubernetes et une CI GitHub Actions adaptée au self-service,
  
• créé un Golden Path et un système de templating permettant de démarrer rapidement et de rester alignés,
  
• introduit Tracker, un outil open source donnant une vue fiable de tout ce qui se passe en production,
  
• démontré que livrer plus souvent ne veut pas dire provoquer plus d’incidents,
  
• affronté les défis restants : homogénéité des dizaines de projets, culture d’autonomie, et passage progressif vers plus d’infrastructure-as-code.
  
  Au-delà de la technique, c’est surtout une histoire de confiance : comment passer d’une organisation bloquée à une organisation qui délivre vite, souvent… et de manière responsable.
  
  Si vous vous demandez comment construire une plateforme qui libère au lieu de contraindre, ce retour d’expérience est pour vous.

Face à l'explosion des IA dans nos logiciels et applications, les critiques sur leurs effets sociaux et environnementaux sont nombreux. Notre équipe de chercheurs et de chercheuse en design a voulu enquêter et décrypter les stratagèmes exploités par les entreprises pour nous forcer à utiliser ces fonctionnalités, que vous le vouliez ou non.

Résultat ? Jamais une fonctionnalité n’aura autant été poussée en si peu de temps, à la fois spatialement, graphiquement, interactivement et de manière autant répétée. Une mise en avant probablement inédite dans l’histoire des interfaces, symbole d’une technologie aux investissements massifs qu’il faut désormais rentabiliser.

Cette enquête inédite met aussi en lumière comment le design façonne considérablement l'avenir, au profit d'enjeux politiques et économiques profonds et pas toujours démocratiques.

Les assistants IA pour le code (Claude Code, GitHub Copilot, Cursor AI...) ont émergé et envahi l'écosystème de notre métier en développement logiciel.

Mais comment ça marche ? Quelle est la magie qui permet de créer et de modifier mon code, d'exécuter des commandes, etc...

Je me posais la question. Alors j'ai creusé le sujet et j'ai développé mon propre assistant IA.... du moins, un début de mini assistant 😉.

Je vous partagerai mon REX sur ce projet : les principes de base (LLM, tools, historique), des démos pour voir si ça marche, les difficultés que j'ai rencontrées, les choses que j'ai apprises, et les bonnes surprises.

L’industrie du développement a tendance à vouloir mettre les développeur·euse·s dans des cases, à nous pousser à devenir expert·e·s dans un seul domaine, une seule stack, un seul langage. Nos carrières évoluent souvent soit vers du management soit de l’expertise.

A la suite de mes études, j’ai commencé ma carrière en Delphi en client lourd et je me suis spécialisée dans ce langage et cet environnement pendant 13 ans. J’étais bien partie pour continuer dans cette voie. Jusqu’au jour où j’ai eu l’opportunité de sortir de ma zone de confort et de découvrir C# et l’environnement .NET.
Une fois l’appréhension initiale passée, je me suis rendue compte que ma formation et mon expérience allaient m’être très utiles pour que la transition se passe sans accroc.

Alors comment ai-je fait pour appréhender cette nouvelle stack?
Quels outils m’ont aidé?
Quelles difficultés ai-je rencontré?

En partageant mon expérience, j’aimerais vous montrer que grâce à notre métier, nous avons toutes les cartes en main pour nous réinventer si on le souhaite.

Et si on questionnait nos définitions du “bon code” pour mieux comprendre ce qu’elles révèlent de nos valeurs, de nos équipes et de nos cultures professionnelles.

Comment, au sein des équipes, se construit la légitimité à définir ce qu’est le “bon code” voir ce qu'est un "bon dev".

Du recrutement à la code review, on questionnera nos pratiques quotidiennes : parce que réfléchir à ce qu’on juge “bon”, c’est déjà développer autrement.

L’IA générative peut-elle vraiment rivaliser avec les humains dans les décisions de conception logicielle ?

Mais, d'abord, c'est quoi une bonne conception logicielle ?

Je vous propose de participer à une conférence interactive où vous serez confrontés à une série de situations concrètes et où vous devrez faire des choix de conception. Quelle solution est la plus simple ? La plus maintenable ? À chaque étape, vous voterez via une web app. Les décisions de l’assemblée seront comparées en direct à celles choisies par les IAs et nous en ferons l'analyse.

Nul besoin de connaître une techno ou un langage particulier - promis, il n'y aura même pas de diagramme UML. Les situations sont volontairement indépendantes de tout élément technique pour mettre tout le monde sur un pied d’égalité et se concentrer sur les principes et activités de conception : couplage/cohésion, SOLID, smells, refactoring...

Venez profiter d'un moment ludique avec ce format participatif pour explorer des principes de conception, vivre des choix complexes, faire mieux que les IAs (on l'espère) et apprendre, ensemble, à mieux concevoir.

Dans nos produits, le manque d’accessibilité n’est pas qu’un oubli. C’est souvent le résultat d’un système qui valorise la vitesse, la perfection et les personnes valides avant tout le monde. Dans ce talk, je propose une lecture systémique du « design validiste » : comment le capitalisme, le perfectionnisme et le productivisme nourrissent des normes qui excluent les personnes handicapées, parfois même quand on pense bien faire.

On verra comment ces mécanismes se traduisent très concrètement dans nos pratiques (outils, critères de qualité, culture du « joli beau », chambres d’écho) et ce que ça change de les regarder en face. Puis je partagerai des pistes d’action à la portée des équipes produit : poser des questions et accepter les réponses provisoires, faire de la recherche inclusive même avec peu de moyens, expérimenter le design fiction, structurer l’AccessibilityOps et sortir de nos bulles confortables.

L’objectif n’est pas de viser la perfection, mais de donner aux équipes des repères pour avancer, en dépit du système qui ne joue pas toujours en faveur de l’accessibilité.

Alors que la Developer Experience s'immisce timidement dans les réflexions techniques et managériales de nos organisations, notre Ops Experience, elle, est encore trop souvent oubliée.
Pire, lorsqu'on construit une solution technique basée sur une plateforme interne, que l'on doit respecter des jalons, améliorer la qualité du code, la fiabilité des tests, automatiser les process,... nous, Dev et Ops, restons des ressources au service des autres équipes métiers de l'entreprise, considérés comme un centre de coût à optimiser.

Et si on inversait ce prisme ?
Que se passerait-il concrètement si on se considérait nous-mêmes comme des utilisateurs, voire des clients, avec nos besoins, nos irritants et nos attentes, souvent différentes ?

Au travers de ce retour d'expérience, je vous propose de penser nos expériences Dev & Ops, comme on pense l'expérience utilisateur.

Je vous parlerai des techniques pour comprendre et améliorer le quotidien des équipes de réalisation et traiter nos plateformes internes comme un produit. Je vous emmènerai dans un monde mêlant techniques de marketing (Design Thinking, expérience utilisateur...), d'industrie (Value Stream Mapping, Kaizen...) et de psychologie (Communication Non Violente, sécurité psychologique...).

Venez (re-)découvrir des techniques actionnables pour transformer vos DevEx et OpsEx en commençant par le plus simple : considérer Dev et Ops comme des clients précieux dont il faut vraiment écouter les besoins !

Février 2025, chez Datadog. Je travaille sur les Google Core Web Vitals, des métriques pour quantifier la performance d’un site web : chargement, interactivité et stabilité visuelle. En les utilisant dans le cadre de mon projet, je découvre une anomalie dans Chrome : certaines dimensions sont exprimées en pixels physiques au lieu de CSS pixels, faussant les calculs pour des milliards d’utilisateurs. Le correctif paraît évident : modifier le code source. Mais c’est bien plus facile à dire qu’à faire.

Développeuse frontend habituée à React et TypeScript, je plonge alors dans l’univers massif de Chromium : des millions de lignes de C++, des outils propriétaires et des standards rigoureux. Cette conférence retrace cette aventure de 9 mois, de la découverte du bug jusqu’au merge final de mon patch en octobre 2025.

Je montrerai comment traquer l’origine d’un bug dans le moteur d’un navigateur, comprendre la culture d’un projet open source et oser contribuer malgré l’incertitude. Au-delà de Chromium, cette expérience m’a appris à naviguer dans des systèmes complexes, à collaborer à grande échelle et à persévérer, des compétences essentielles pour mener des projets ambitieux.

La refonte de l’étape du paiement de la billetterie Roland-Garros était critique. Mais à cause de la complexité des différents cas fonctionnels, je me suis retrouvé empêtré avec des tests peu lisibles et une implémentation difficile à suivre.

Dans cet atelier, je vous propose de découvrir l’architecture événementielle que j’ai pu mettre en place, lors d’un refactoring guidé, basé sur deux patterns puissants : Command/CommandHandler et Event/EventListener.

🔧 Ce que vous apprendrez :

• Structurer la logique métier avec Command/CommandHandler
• Publier et consommer des événements métier pour une architecture extensible
• Simplifier les tests unitaires en isolant les comportements
• Construire un tunnel de vente maintenable et évolutif
  
  ⏱️ Déroulement : 30 min de présentation, 10 min de setup, 60 min de refactoring guidé, 10 min de Q&A
  
  🎯 Public cible : dév backend avec un niveau intermédiaire minimum sur une stack Java/SpringBoot
  
  🏁 Résultats : code refactoré, use case réutilisables et plus lisibles, réduction des cas de test

Avez-vous déjà eu à guider quelqu'un d'autre à travers des contenus qu'il ne voyait pas ? Par exemple, décrire au téléphone un menu de restaurant ? Vous avez peut-être remarqué qu'une simple lecture du texte écrit ne suffisait pas : vous avez dû fournir des indications complémentaires pour aider à la compréhension.

Cet atelier est une occasion de se plonger dans ces indices visuels qui transmettent des informations non-écrites, implicites et souvent essentielles à la compréhension du contenu.

Nous discuterons aussi ensemble des alternatives invisibles à ces indications visuelles, nous interrogeant sur leur intégration dans nos contenus : doivent-elles toutes être retranscrites ? Devons-nous les retranscrire le plus fidèlement possible ? Ou au contraire proposer des synthèses ? …

Cet atelier est ouvert à tous les profils, que vous soyez dans le développement, le design, la rédaction web ou autre…

Avez-vous récemment lu un bout de code propre… mais difficile à comprendre ?

Et si le problème ne venait pas du code, mais de la façon dont il raconte ce qu’il fait ?

Cette présentation introduit le concept de Narrative Code : une approche d’écriture qui ne cherche pas seulement à produire du code “propre”, mais à écrire du code qui raconte.

Nous explorerons les schémas narratifs récurrents, les personnages qui habitent nos méthodes, les techniques d’écriture qui rendent le code expressif, et même les épilogues d’un bon récit logiciel.

Vous repartirez avec de nouvelles clés pour devenir auteur de ce nouveau genre littéraire.

Entre les fils Twitter, le flux LinkedIn, les épisodes de podcasts et les newsletters qui s’empilent, la veille techno tourne vite au bruit de fond. Pourtant, rester à jour est vital quand on écrit du code — ou qu’on pilote un produit — dans un écosystème qui bouge chaque semaine.

Développeur depuis plus de vingt ans, j’ai affiné une méthode 100 % sous contrôle : zéro algorithme, zéro FOMO, centrée sur les bons vieux flux RSS, orchestrés avec Inoreader et complétés par quelques agrégateurs clés (Hacker News, Lobsters, Human Coders News, etc.).

Ce dont nous parlerons :

• Composer sa “sources list” : transformer n’importe quel site, newsletter ou profil social en flux RSS et dénicher de nouvelles pépites via les agrégateurs.
• Organiser et filtrer : répertoires thématiques, indice de popularité, règles automatiques, résumés IA, traduction — viser la pertinence plutôt que la quantité.
• Ritualiser la veille : ménage régulier, file d’attente « lire plus tard », créneaux dédiés et astuces anti-dispersion.
• Passer à l’action : publier un mémo hebdo, partager sa veille sur ses réseaux ou avec son équipe, alimenter un blog...
  
  Repartez avec une méthode pragmatique, extensible et, surtout, toujours au service de votre curiosité plutôt que d’un algorithme.

Pas évident de sensibiliser les citoyens à la vie privée en ligne et à la cybersécurité. Certains n'ont "rien à cacher", d'autres redoutent la moindre interaction avec le numérique, craignant de se faire arnaquer.

Grâce à mon expérience sur le projet open source Unlock My Data et la collaboration avec de nombreux bénévoles, j’ai appris à rendre ces enjeux plus accessible.

Je souhaite donc partager ce que j'ai appris au fur et à mesure de mes ateliers, conférences et utilisation d'Unlock My Data sur la manière de sensibiliser des publics non techniques.


L’objectif est de proposer des pistes aux des équipes tech/produit :

• à être plus transparent sur leur utilisation des données personnelles, en communiquant auprès du grand public.
• des bonnes pratiques pour rendre visibles les efforts de sécurité sans jargon.

Pendant longtemps, on a pensé que le test-coverage était le meilleur indicateur pour suivre la qualité de la stratégie de test. Spoiler alert : ça ne suffit pas, l’enjeu n’est pas de tout tester, mais de “bien tester”.

Dans cette session, je vous propose de découvrir le Mutation Testing, une pratique qui met à l'épreuve vos tests en introduisant des bugs volontairement.


Oui, vous avez bien lu : on sabote notre application pour mieux la fiabiliser !

Au programme :

• Comprendre pourquoi la couverture de code ne suffit pas et donner une nouvelle lecture de ce que les tests valident réellement
• Rappeler de bonnes pratiques liées aux tests pour s’approprier les différentes stratégies
• Découvrir le Mutation Testing : comment ça marche, quels types de mutations existent
• Analyser des “mutants survivants” en live coding pour identifier les failles de vos tests
• Corriger et renforcer ses tests pour qu'ils deviennent de véritables filets de sécurité
• Comment intégrer le Mutation Testing dans son workflow : configuration CI/CD, optimisation des performances, adoption progressive
  
  Vous repartirez avec une compréhension fine du sujet et la capacité de le mettre en oeuvre simplement sur vos projets.
  
  Prêts à tester vos tests ?

Vos utilisateurs en ont marre d’attendre...

Nos applications s’essoufflent sous le poids du polling et des loaders plus ou moins maîtrisés . Et si les Server-Sent Events (SSE) étaient la solution simple et légère que vous cherchez ?
Les SSE permettent de basculer d’un modèle où le navigateur demande à un système où le serveur murmure à son oreille. Ce changement de paradigme a de nombreux impacts sur l'architecture, le code, et même sur la conception de l’expérience utilisateur.

Charline et Nicolas, Lead Tech Frontend et Backend, vous partagent leur retour d’expérience sur cette mise en place dans des cas d'usages réels. Dans des jeux multi-joueurs, ou dans des applications de gestion traditionnelles, ils vous montreront les cas d'usages concret, les gains et les pièges à éviter.

Venez découvrir comment les SSE influencent votre code, de l'intégration aux frameworks Frontend, jusqu'à la séparation lecture/écriture côté backend. Vous verrez aussi comment cette approche fait évoluer la conception des échanges Front/Back et l'expérience utilisateur, tout en offrant de nouvelles possibilités...

L’IA est en train de réécrire le métier de développeur. Pas demain. Maintenant.

Complétion de code, assistants, agents intégrés au cycle de vie de développement : produire plus vite n’a jamais été aussi simple. En parallèle, comprendre réellement ce qui est produit devient un enjeu central.

Quelles compétences créent encore de la valeur lorsque l’exécution devient largement automatisée ? Et comment continuer à progresser lorsque l’apprentissage repose de plus en plus sur la supervision d’une machine ?

Cette conférence défend une thèse claire : l’IA ne constitue pas une évolution de plus, mais une rupture profonde. Elle déplace le rôle du développeur, l’éloigne de la production de code, avec un risque réel de perte de compréhension et d’obsolescence des compétences en l’absence d'anticipation.

À partir de ce constat, le talk propose un cadre de priorisation des compétences, destiné aux profils juniors et seniors. Il s’appuie sur des retours de terrain variés et se conclut par une approche pragmatique de la montée en compétences, au niveau des organisations comme à l’échelle individuelle, afin de permettre aux développeurs de rester acteurs de leur évolution professionnelle.

Chez Eviden HPC et AI, non contents de fournir des supercalculateurs souverains, nous avons l’ambition d’être exemplaires sur la cybersécurité, notamment en anticipant la conformité de nos logiciels au Cyber Resilience Act, qui entrera en vigueur en 2027.

Dans ce cadre, nous devons, toutes et tous, sécuriser chaque étape de la chaîne de production logicielle pour protéger le moindre composant de nos produits.

Dans ce talk, nous vous emmènerons dans les coulisses de notre chaine de production logicielle et vous donnerons notre retour d'expérience sur :

• comment nous cartographions les dépendances logicielles à l’aide de SBOM.
• comment nous détectons les vulnérabilités et les traquons à l’aide de fichiers VEX , ou pas !
• comment nous centralisons les informations d’une cinquantaine de produits avec l’outil Dependency Track.
  
  Si vous aussi vous êtes impactés par le Cyber Resilience Act et que vous ne savez pas par où commencer, ce talk est fait pour vous.

On entend souvent : « Plus on a de développeurs, plus on livrera vite ». Pourtant, dans la réalité, les équipes gonflent, les livraisons ralentissent et tout le monde s’épuise. Et si le problème venait du travail que personne ne voit ? Le support, les interruptions, les réunions incongrues, la dette technique qui revient comme un boomerang… Tout ce qui remplit nos journées sans exister nulle part dans un backlog.

Dans cette conférence, je partagerai des exemples concrets et des outils pratiques issus du terrain pour rendre ce travail invisible mesurable, pour piloter notre capacité réelle et pour redonner de l’air aux équipes. Moins on navigue à vue, mieux on code. Moins on est (dans le flux), plus on code. Et si la performance n’était pas une histoire de ressources… mais de visibilité et de focus ?

Un problème qu'on connaît tous : des PRs approuvées, testées, mais qui traînent pendant des semaines pour des raisons aussi justifiées que variées (validation produit, attente d'une autre PR…). À première vue, cette stratégie "on merge quand tout est prêt" semble prudente et réduit le risque…

Spoiler : elle ne fait que le déplacer. Branches longues, conflits en cascade, refactoring entre-temps, et, au final, des rebases coûteux. Le release day? Un vrai stress day.

Et si on arrêtait de confondre « merge » et « release » ?

Dans ce talk, on explore les feature flags dans un contexte de production à grande échelle, avec des clients multiples où zéro interruption de service est un must. L'objectif : sortir du mode "tout ou rien". Comment ? En découpant une livraison en étapes sûres : on merge tôt, on déploie souvent, et on choisit quand et pour qui activer une fonctionnalité.

On verra ensemble les différents types de feature flags et surtout dans quel contexte les utiliser pour livrer en continu. Vous repartirez avec des patterns concrets et des règles d'équipe pour que les feature flags améliorent réellement votre DevEx et ne transforment pas votre codebase en cimetière de `if (featureEnabled)`.

L’accessibilité est souvent le parent pauvre de nos projets. C’est perçu comme la chose que l’on fera plus tard, qu’on “réparera”. Il en résulte des produits quasi voire totalement inaccessibles pour des utilisatrices et utilisateurs.


Les raisons sont multiples : manque de formation, manque de temps, manque de connaissance du cadre légal, manque volonté de la part des décideurs…


Et si la documentation de vos composants devenait votre alliée accessibilité ? Nous verrons comment documenter des composants en prenant en compte l’accessibilité au sein de vos design system. Que ce soit au travers des différents niveaux de documentation ou des mises en relation avec les critères du RGAA (Référentiel Général d’Amélioration de l’Accessibilité), les possibilités pour vous aider à améliorer l’accessibilité de vos composants sont multiples et adaptées quelque soit l’échelle de votre produit !

L'IA va-t-elle nous rendre stupides ?

Êtes-vous noyé sous les onglets ouverts, les articles en favoris et les vidéos « pour plus tard » ? Le flot ne s'arrête jamais et nos techniques classiques pour apprendre sont dépassées.

Rejoignez cet atelier pratique pour maîtriser l'apprentissage actif augmenté par l'IA.

Il ne s'agit pas de demander à ChatGPT de « résumer ceci ». Vous apprendrez un workflow structuré, fondé sur des pédagogies éprouvées (questionnement socratique, "Training from the Back of the Room"), pour transformer la lecture passive en interrogation active. Vous dialoguerez avec un tuteur IA sur mesure, loin des vidéos soporifiques.

Découvrez comment synthétiser des dizaines de sources web simultanément. Utilisez l'IA pour repérer les contradictions et les consensus entre experts, tout en appliquant des techniques cruciales "anti-hallucination".

Venez avec un sujet à maîtriser dès maintenant.
Vous repartirez avec deux compétences :

1. Une connaissance approfondie de votre sujet.
2. Une bibliothèque de prompts et un framework pour apprendre deux fois plus vite.
   
   Prérequis : un ordinateur et l'accès à un LLM avec une grande fenêtre de contexte.

L’art du feedback n’est pas chose aisée surtout lorsque nous avons en face de nous... un drôle d’animal !
Avez-vous déjà craint la réaction de la personne en face de vous, la peur de lui faire un retour sur sa manière de s’être comportée avec vous ? Ou d'avoir mal vécu l'échange qui en a découlé ?

“Feedback en milieu sauvage” est le jeu de rôle et d’entraînement au feedback en situation (presque) réelle.

A partir d’un événement problématique proposé, formulez un feedback. A qui ? Peut-être au suricate surpris qui ne comprends pas ce que vous lui reprochez, le renard qui tentera de vous séduire, le koala et tous ses problèmes personnels ou encore le chien qui passe son temps à se dénigrer.

Savoir donner du feedback est une chose, savoir gérer quand le retour n’est pas celui escompté en est une autre.

“Feedback en milieu sauvage” vous permet de vivre cette expérience de manière sécurisée afin d’être prêt•e à gérer ces situations et savoir y répondre.

Toute la Gaule est occupée par la complexité logicielle… Toute ? Non ! Un petit village peuplé d’irréductibles développeurs et développeuses résiste encore et toujours à l’envahisseur.

Suite à un fâcheux incident ayant privé temporairement le village de potion magique, une décision est prise : construire une application pour conserver à jamais les meilleures recettes gauloises.

Deux artisans logiciels sont alors désignés pour cette mission critique : Ordralfabétix, proposant le Java le plus frais du marché, et Cétautomatix, martelant au quotidien sa passion pour le Go. Mais leur éternel conflit les amène à vouloir développer chacun leur propre version de l’application…
Les deux rivaux explorent les concepts fondamentaux de l'architecture hexagonale et mettent en lumière, à travers des implémentations concrètes en Java et en Go, les différences d'approche selon les écosystèmes !

Une conférence épique, pragmatique et pleine d’humour, pour découvrir (ou redécouvrir) l’architecture hexagonale par la pratique, et où les bonnes astuces joueront le rôle de potion magique !

Passez-vous votre journée en réunion ? Est-il possible de bâtir une entreprise à succès, réglementée et en croissance rapide, en remettant en question la hiérarchie et les rituels de gestion traditionnels ?

Alan est une compagnie d'assurance maladie qui sert plus de 30 000 entreprises et 1 million de membres en France, en Espagne, en Belgique et au Canada.

Ce qui nous rend vraiment uniques, c'est que nous avons atteint plus de 700 employés sans managers traditionnels et avec pratiquement aucune réunion récurrente. Ce modèle, notre avantage concurrentiel, est ainsi que nous gérons une compagnie d'assurance réglementée à grande échelle, tous les jours.

Dans cette présentation, je vous emmènerai au cœur de ce modèle radical et partagerai :

L'organisation sans hiérarchie classique : Comment nous avons remplacé les managers par des coachs et séparé le leadership opérationnel du développement individuel.

La culture de l'écrit et asynchrone : Comment les décisions sont prises de manière transparente dans Slack, GitHub et Notion, et non dans des salles de conférence.

L'appropriation (ownership) distribuée : Comment 700 personnes fixent leurs propres objectifs et se tiennent responsables sans contrôle descendant (top-down).

Les systèmes qui permettent l'échelle : Les rituels et les mécanismes qui font fonctionner ce modèle au quotidien.

Nos leçons apprises : Ce que nous avons mal fait, ce que nous sommes encore en train de perfectionner, et pourquoi ce modèle n'est pas pour tout le monde.

Cette présentation partagera la vérité honnête – ce qui fonctionne, ce qui ne fonctionne pas – et offrira des principes concrets que vous pourrez appliquer à votre propre organisation pour gagner en rapidité et en transparence.

Les logiciels et outils libres sont à l’opposé des logiciels dits propriétaires. On peut les utiliser librement et gratuitement, leur code source est disponible pour tout le monde et on peut les modifier à notre guise.

Les logiciels et outils libres sont aussi partout. Il y a fort à parier que dans votre vie, vous ayez déjà utilisé un outil libre comme Python, Linux, Blender, OpenStreetMap…

Participer à un projet libre est un excellent moyen de progresser, d’apprendre, de rencontrer des gens et de prendre part à quelque chose de plus grand que soi.

Mais se lancer peut être déroutant et intimidant.

À quel projet participer ? Je ne sais pas coder, je ne peux pas participer. Mon code est trop nul, je vais sûrement casser un truc. Tout est en anglais et je ne parle pas anglais.

Soyez rassuré·e, il existe plein de projets, plein de communautés et on n’est même pas obligé de faire du code !

Au cours de cette présentation, nous verrons ce que participer à un projet libre peut nous apporter, ce que nous pouvons apporter aux autres et comment faire pour se lancer.

161 scripts et 154 998 caractères composent le standard Unicode. Il permet aux systèmes informatiques de communiquer les mêmes éléments typographiques grâce à un adressage unique. Unicode est devenu depuis 1991 un outil culturel et politique aux capacités encore peu connues. Vous découvrirez l’histoire du standard utilisé par tous et toutes à travers le globe dans nos communications numériques quotidiennes, comment sont spécifiés et sélectionnés les caractères et systèmes d’écritures encodables, les enjeux et les limites de leurs intégrations, ainsi que les caractères les plus incongrus ou problématiques. Vieille mascotte de la poste japonaise, écriture en Mongolie, chiffres en forme de coquillage ou encore minitel, chaque caractère contenu dans Unicode a une histoire à raconter.

Angular évolue à toute vitesse, et l’une des transformations majeures en cours s’appelle le mode "Zoneless". Depuis quelques versions, Angular permet de se passer de `Zone.js`, ce qui change en profondeur le fonctionnement du change detection… et potentiellement votre manière de coder.

Dans ce talk, je vous embarque pour un tour rapide du mode Zoneless :

• un peu d’histoire (très rapide, promis)
• une démo live avec/sans Zone.js
• et surtout : ce que ça change dans votre code, votre perf et votre quotidien
  
  Vous repartirez avec un peu de recul, et peut-être même l’envie de retirer Zone.js vous aussi !

Venez découvrir comment, au détour d'une vidéo YouTube sur l'émulation et d'un « mais ça, je peux le faire » , j'ai embarqué dans un voyage au croisement de l'informatique, de l'électronique, du gaming, de l'audio et même du droit.

On se dirige tout droit vers la nostalgie et pas n'importe laquelle : celle des gros pixels, des sons 8 bits, des cartouches de jeux, des piles AA chipées dans la télécommande du salon, des tétrominos, des 151 premiers Pokémon : de la Nintendo Game Boy !

Ce talk, c’est le récit d’un side project très nerdy : développer un émulateur Game Boy. Du premier pixel affiché aux premières notes entendues, vous découvrirez une multitude de défis techniques : compréhension du matériel, reverse engineering, audio/video processing, optimisation des performances, qualité logicielle et techniques de déboggage. Au-delà du fun et de la nostalgie, ce projet montre à quel point l’émulation est un formidable terrain d’apprentissage pour tout développeur.

Voici quelques-unes des questions auxquelles on va répondre :

• Par où commence-t-on un projet pareil ?
• Quelles sont les différentes techniques modernes d’émulation ?
• Comment architecturer un émulateur ?
• Ça prend combien de temps d’émuler une console ?
• Comment fait-on pour émuler le son ?
• Comment sait-on qu'un émulateur est fiable ?
• Comment débogguer un programme qui ne renvoie pas d'erreur ?
• Et surtout : c’est légal tout ça ?

Ce talk explore le timing audio en JavaScript : pourquoi setTimeout() et setInterval() ne suffisent pas pour jouer juste dans le temps, comment créer une clock fiable et tirer parti de la Web Audio API pour planifier des sons avec précision.


À travers définitions musicales, exemples de code et anecdotes d’horloges, repartez avec des clés concrètes pour vos projets audio interactifs et une meilleure compréhension du timing en JS.

Des vieux PC inutilisés à la maison?
Envie de découvrir Kubernetes, mais votre poste de travail est ras-la-gueule?
Venez voir comment se créer un petit cluster Kubernetes multi-node chez soi, pas à pas, en partant de zéro.
C'est idéal pour apprendre, et tester. Sans rien débourser, et avec un impact environnemental minimal.
Ca permet de voir comment ça marche (côté dev ET côté ops), après une installation simplifiée.

• Quelle distribution Kubernetes choisir?
• Quels avantages/inconvénients par rapport à Docker Desktop ou Minikube?
• Quels pré-requis techniques pour les machines du cluster?
• Comment y accéder à distance? Avec quel(s) outil(s)?
• Dans quel ordre apprendre les différentes technologies?

Je suis une « aberration statistique » : trop grosse, trop diplomée, trop hors-norme pour entrer dans les cases des IA grand public.


En remixant les codes (et les algorithmes), j’ai généré 150 images : moi, incarnée là où je n’étais pas prévue, de Gatsby à Body Watch.


Ce projet artistique et politique questionne :

Qui a le droit d’exister dans la machine algorithmique actuelle ?

Ma volonté: Détourner les biais, réinventer les rôle-modèles, hacker la représentation à travers une exposition et un livre. Les biais ne sont pas une fatalité, l'alliance de l'art et de la tech, nous offrent des leviers de représentations insoupçonnées !


Dans ce talk, je vous embarque : dans l'histoire des biais au cinéma, les images réinventées, anecdotes et pistes concrètes pour bâtir des IA inclusives.