Les Cast Codeurs Podcast

Emmanuel Bernard, Guillaume Laforge, Vincent Massol, Antonio Goncalves, Aud

Restez informes sur les sujets brulants de l industrie Java.

  • 1 hour 32 minutes
    LCC 332 - Groquik revient, Emmanuel s'en va

    Dans cet épisode, Emmanuel, Katia et Guillaume discutent de Spring 7, Quarkus, d'Infinispan et Keycloak. On discute aussi de projets sympas comme Javelit, de comment démarre une JVM, du besoin d'argent de NTP. Et puis on discute du changement de carrière d'Emmanuel.

    Enregistré le 14 novembre 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-332.mp3 ou en vidéo sur YouTube.

    News

    Emmanuel quitte Red Hat après 20 ans https://emmanuelbernard.com/blog/2025/11/13/leaving-redhat/

    Langages

    Support HTTP/3 dans le HttpClient de JDK 26 - https://inside.java/2025/10/22/http3-support/

    • JDK 26 introduit le support de HTTP/3 dans l'API HttpClient existante depuis Java 11
    • HTTP/3 utilise le protocole QUIC sur UDP au lieu de TCP utilisé par HTTP/2
    • Par défaut HttpClient préfère HTTP/2, il faut explicitement configurer HTTP/3 avec Version.HTTP_3
    • Le client effectue automatiquement un downgrade vers HTTP/2 puis HTTP/1.1 si le serveur ne supporte pas HTTP/3
    • On peut forcer l'utilisation exclusive de HTTP/3 avec l'option H3_DISCOVERY en mode HTTP_3_URI_ONLY
    • HttpClient apprend qu'un serveur supporte HTTP/3 via le header alt-svc (RFC 7838) et utilise cette info pour les requêtes suivantes
    • La première requête peut utiliser HTTP/2 même avec HTTP/3 préféré, mais la seconde utilisera HTTP/3 si le serveur l'annonce
    • L'équipe OpenJDK encourage les tests et retours d'expérience sur les builds early access de JDK 26
    Librairies

    Eclispe Jetty et CometD changent leurs stratégie de support https://webtide.com/end-of-life-changes-to-eclipse-jetty-and-cometd/

    • À partir du 1er janvier 2026, Webtide ne publiera plus Jetty 9/10/11 et CometD 5/6/7 sur Maven Central
    • Pendant 20 ans, Webtide a financé les projets Jetty et CometD via services et support, publiant gratuitement les mises à jour EOL
    • Le comportement des entreprises a changé : beaucoup cherchent juste du gratuit plutôt que du véritable support
    • Des sociétés utilisent des versions de plus de 10 ans sans migrer tant que les correctifs CVE sont gratuits
    • Cette politique gratuite a involontairement encouragé la complaisance et retardé les migrations vers versions récentes
    • MITRE développe des changements au système CVE pour mieux gérer les concepts d'EOL
    • Webtide lance un programme de partenariat avec TuxCare et HeroDevs pour distribuer les résolutions CVE des versions EOL
    • Les binaires EOL seront désormais distribués uniquement aux clients commerciaux et via le réseau de partenaires
    • Webtide continue le support standard open-source : quand Jetty 13 sortira, Jetty 12.1 recevra des mises à jour pendant 6 mois à un an
    • Ce changement vise à clarifier la politique EOL avec une terminologie industrielle établie

    Améliorations cloud du SDK A2A Java https://quarkus.io/blog/quarkus-a2a-cloud-enhancements/

    • Version 0.3.0.Final du SDK A2A Java apporte des améliorations pour les environnements cloud et distribués
    • Composants en mémoire remplacés par des implémentations persistantes et répliquées pour environnements multi-instances
    • JpaDatabaseTaskStore et JpaDatabasePushNotificationConfigStore permettent la persistance des tâches et configurations en base PostgreSQL
    • ReplicatedQueueManager assure la réplication des événements entre instances A2A Agent via Kafka et MicroProfile Reactive Messaging
    • Exemple complet de déploiement Kubernetes avec Kind incluant PostgreSQL, Kafka via Strimzi, et load balancing entre pods
    • Démonstration pratique montrant que les messages peuvent être traités par différents pods tout en maintenant la cohérence des tâches
    • Architecture inspirée du SDK Python A2A, permettant la gestion de tâches asynchrones longues durée en environnement distribué

    Quarkus 3.29 sort avec des backends de cache multiples et support du débogueur Qute https://quarkus.io/blog/quarkus-3-29-released/

    • Possibilité d'utiliser plusieurs backends de cache simultanément dans une même application
    • Chaque cache peut être associé à un backend spécifique (par exemple Caffeine et Redis ou Infinispan)
    • Support du Debug Adapter Protocol (DAP) pour déboguer les templates Qute directement dans l'IDE
    • et dans la version 3.28
    • Configuration programmatique de la protection CSRF via une API fluent
    • Possibilité de restreindre les filtres OIDC à des flux d'authentification spécifiques avec annotations
    • Support des dashboards Grafana personnalisés via fichiers JSON dans META-INF/grafana/
    • Extension Liquibase MongoDB supporte désormais plusieurs clients simultanés
    • Amélioration significative des performances de build avec réduction des allocations mémoire
    • Parallélisation de tâches comme la génération de proxies Hibernate ORM et la construction des Jar

    Et l'utilisation des fichiers .proto est plus simple dans Quarkus avbec Quarkus gRPC Zero https://quarkus.io/blog/grpc-zero/

    • c'est toujours galere des fichiers .proto car les generateurs demandent des executables natifs
    • maintenant ils sont bundlés dans la JVM et vous n'avez rien a configurer
    • cela utilise Caffeine pour faire tourner cela en WASM dans la JVM

    Spring AI 1.1 est presque là https://spring.io/blog/2025/11/08/spring-ai-1-1-0-RC1-available-now

    • support des MCP tool caching pour les callback qui reduit les iooerations redondantes
    • Access au contenu de raisonnement OpenAI
    • Un modele de Chat MongoDB
    • Support du modele de penser Ollama
    • Reessaye sur les echec de reseau
    • OpenAI speech to text

    Spring gRPC Les prochaines étapes pour la 1.0.0 https://spring.io/blog/2025/11/05/spring-grpc-next-steps

    • Spring gRPC 1.0 arrive prochainement avec support de Spring Boot 4
    • L'intégration dans Spring Boot 4.0 est reportée, prévue pour Spring Boot 4.1
    • Les coordonnées Maven restent sous org.springframework.grpc pour la version 1.0
    • Le jar spring-grpc-test est renommé en spring-grpc-test-spring-boot-autoconfigure
    • Les packages d'autoconfiguration changent de nom nécessitant de modifier les imports
    • Les dépendances d'autoconfiguration seront immédiatement dépréciées après la release 1.0
    • Migration minimale attendue pour les projets utilisant déjà la version 0.x
    • La version 1.0.0-RC1 sera publiée dès que possible avant la version finale

    Spring arrete le support reactif d'Apache Pulsar https://spring.io/blog/2025/10/29/spring-pulsar-reactive-discontinued

    • logique d'évaluer le temps passé vs le nombre d'utilisateurs
    • c'est cependant une tendance qu'on a vu s'accélerer

    Spring 7 est sorti https://spring.io/blog/2025/11/13/spring-framework-7-0-general-availability

    Infrastructure

    Infinispan 16.0 https://infinispan.org/blog/2025/11/10/infinispan-16-0

    • Ajout majeur : migration en ligne sans interruption pour les nœuds d'un cluster (rolling upgrades) (infinispan.org)
    • Messages de clustering refaits avec Protocol Buffers + ProtoStream : meilleure compatibilité, schéma évolutif garanti (infinispan.org)
    • Console Web améliorée
    • API dédiée de gestion des schémas (SchemasAdmin) pour gérer les schémas ProtoStream à distance (infinispan.org)
    • Module de requête (query) optimisé :
      • support complet des agrégations (sum, avg …) dans les requêtes indexées en cluster grâce à l'intégration de Hibernate Search 8.1 (infinispan.org)
    • Serveur :
      • image conteneur minimalisée pour réduire la surface d'attaque (infinispan.org)
      • démarrage plus rapide grâce à séparation du démarrage cache/serveur (infinispan.org)
      • caches pour connecteurs (Memcached, RESP) créés à la demande (on-demand) et non à l'initiaton automatique (infinispan.org)
      • moteur Lua 5.1 mis à jour avec corrections de vulnérabilités et opérations dangereuses désactivées (infinispan.org)
    • Support JDK :
      • version minimale toujours JDK 17 (infinispan.org)
      • prise en charge des threads virtuels (virtual threads) et des fonctionnalités AOT (Ahead-of-Time) de JDK plus récentes (infinispan.org)
    Web

    Javelit, une nouvelle librairie Java inspirée de Streamlit pour faire facilement et rapidement des petites interfaces web https://glaforge.dev/posts/2025/10/24/javelit-to-create-quick-interactive-app-frontends-in-java/

    • Site web du projet : https://javelit.io/
    • Javelit : outil pour créer rapidement des applications de données (mais pas que) en Java.
    • Simplifie le développement : élimine les tracas du frontend et de la gestion des événements.
    • Transforme une classe Java en application web en quelques minutes.
    • Inspiré par la simplicité de Streamlit de l'écosystème Python (ou Gradio et Mesop), mais pour Java.
    • Développement axé sur la logique : pas de code standard répétitif (boilerplate), rechargement à chaud.
    • Interactions faciles : les widgets retournent directement leur valeur, sans besoin de HTML/CSS/JS ou gestion d'événements.
    • Déploiement flexible : applications autonomes ou intégrables dans des frameworks Java (Spring, Quarkus, etc.).
    • L'article de Guillaume montre comment créer une petite interface pour créer et modifier des images avec le modèle génératif Nano Banana
    • Un deuxième article montre comment utiliser Javelit pour créer une interface de chat avec LangChain4j https://glaforge.dev/posts/2025/10/25/creating-a-javelit-chat-interface-for-langchain4j/

    Améliorer l'accessibilité avec les applis JetPack Compose https://blog.ippon.fr/2025/10/29/rendre-son-application-accessible-avec-jetpack-compose/

    • TalkBack est le lecteur d'écran Android qui vocalise les éléments sélectionnés pour les personnes malvoyantes
    • Accessibility Scanner et les outils Android Studio détectent automatiquement les problèmes d'accessibilité statiques
    • Les images fonctionnelles doivent avoir un contentDescription, les images décoratives contentDescription null
    • Le contraste minimum requis est de 4.5:1 pour le texte normal et 3:1 pour le texte large ou les icônes
    • Les zones cliquables doivent mesurer au minimum 48dp x 48dp pour faciliter l'interaction
    • Les formulaires nécessitent des labels visibles permanents et non de simples placeholders qui disparaissent
    • Modifier.semantics permet de définir l'arbre sémantique lu par les lecteurs d'écran
    • Les propriétés mergeDescendants et traversalIndex contrôlent l'ordre et le regroupement de la lecture

    Diriger le navigateur Chrome avec le modèle Gemini Computer Use https://glaforge.dev/posts/2025/11/03/driving-a-web-browser-with-gemini-computer-use-model-in-java/

    • Objectif : Automatiser la navigation web en Java avec le modèle "Computer Use" de Gemini 2.5 Pro.
    • Modèle "Computer Use" : Gemini analyse des captures d'écran et génère des actions d'interface (clic, saisie, etc.).
    • Outils : Gemini API, Java, Playwright (pour l'interaction navigateur).
    • Fonctionnement : Boucle agent où Gemini reçoit une capture, propose une action, Playwright l'exécute, puis une nouvelle capture est envoyée à Gemini.
    • Implémentation clé : Toujours envoyer une capture d'écran à Gemini après chaque action pour qu'il comprenne l'état actuel.
    • Défis : Lenteur, gestion des CAPTCHA et pop-ups (gérables).
    • Potentiel : Automatisation des tâches web répétitives, création d'agents autonomes.
    Data et Intelligence Artificielle

    Apicurio ajoute le support de nouveaux schema sans reconstruire Apicurio https://www.apicur.io/blog/2025/10/27/custom-artifact-types

    • Apicurio Registry 3.1.0 permet d'ajouter des types d'artefacts personnalisés au moment du déploiement sans recompiler le projet
    • Supporte nativement OpenAPI, AsyncAPI, Avro, JSON Schema, Protobuf, GraphQL, WSDL et XSD
    • Trois approches d'implémentation disponibles : classes Java pour la performance maximale, JavaScript/TypeScript pour la facilité de développement, ou webhooks pour une flexibilité totale
    • Configuration via un simple fichier JSON pointant vers les implémentations des composants personnalisés
    • Les scripts JavaScript sont exécutés via QuickJS dans un environnement sandboxé sécurisé
    • Un package npm TypeScript fournit l'autocomplétion et la sécurité de type pour le développement
    • Six composants optionnels configurables : détection automatique de type, validation, vérification de compatibilité, canonicalisation, déréférencement et recherche de références
    • Cas d'usage typiques : formats propriétaires internes, support RAML, formats legacy comme WADL, schémas spécifiques à un domaine métier
    • Déploiement simple via Docker en montant les fichiers de configuration et scripts comme volumes
    • Les performances varient selon l'approche : Java offre les meilleures performances, JavaScript un bon équilibre, webhooks la flexibilité maximale
    • Le truc interessant c'est que c'est Quarkus based et donc demandait le rebuilt
    • donc pour eviter cela, ils ont ajouter QuickJS via Chicorey un moteur WebAssembly

    GPT 5.1 pour les développeurs est sorti. https://openai.com/index/gpt-5-1-for-developers/

    • C'est le meilleur puisque c'est le dernier :slightly_smiling_face:
    • Raisonnement Adaptatif et Efficace : GPT-5.1 ajuste dynamiquement son temps de réflexion en fonction de la complexité de la tâche, le rendant nettement plus rapide et plus économique en jetons pour les tâches simples, tout en maintenant des performances de pointe sur les tâches difficiles.
    • Nouveau Mode « Sans Raisonnement » : Un mode (reasoning_effort='none') a été introduit pour les cas d'utilisation sensibles à la latence, permettant une réponse plus rapide avec une intelligence élevée et une meilleure exécution des outils.
    • Cache de Prompt Étendu : La mise en cache des invites est étendue jusqu'à 24 heures (contre quelques minutes auparavant), ce qui réduit la latence et le coût pour les interactions de longue durée (chats multi-tours, sessions de codage). Les jetons mis en cache sont 90 % moins chers.
    • Améliorations en Codage : Le modèle offre une meilleure personnalité de codage, une qualité de code améliorée et de meilleures performances sur les tâches d'agenticité de code, atteignant 76,3 % sur SWE-bench Verified.
    • Nouveaux Outils pour les Développeurs : Deux nouveaux outils sont introduits ( https://cookbook.openai.com/examples/build_a_coding_agent_with_gpt-5.1 ) :
      • L'outil apply_patch pour des modifications de code plus fiables via des diffs structurés.
      • L'outil shell qui permet au modèle de proposer et d'exécuter des commandes shell sur une machine locale, facilitant les boucles d'inspection et d'exécution.
    • Disponibilité : GPT-5.1 (ainsi que les modèles gpt-5.1-codex) est disponible pour les développeurs sur toutes les plateformes API payantes, avec les mêmes tarifs et limites de débit que GPT-5.

    Comparaison de similarité d'articles et de documents avec les embedding models https://glaforge.dev/posts/2025/11/12/finding-related-articles-with-vector-embedding-models/

    • Principe : Convertir les articles en vecteurs numériques ; la similarité sémantique est mesurée par la proximité de ces vecteurs.
    • Démarche :
      • Résumé des articles via Gemini-2.5-flash.
      • Conversion des résumés en vecteurs (embeddings) par Gemini-embedding-001.
      • Calcul de la similarité entre vecteurs par similarité cosinus.
      • Affichage des 3 articles les plus pertinents (>0.75) dans le frontmatter Hugo.
    • Bilan : Approche "résumé et embedding" efficace, pragmatique et améliorant l'engagement des lecteurs.
    Outillage

    Composer : Nouveau modèle d'agent rapide pour l'ingénierie logicielle - https://cursor.com/blog/composer

    • Composer est un modèle d'agent conçu pour l'ingénierie logicielle qui génère du code quatre fois plus rapidement que les modèles similaires
    • Le modèle est entraîné sur de vrais défis d'ingénierie logicielle dans de grandes bases de code avec accès à des outils de recherche et d'édition
    • Il s'agit d'un modèle de type mixture-of-experts optimisé pour des réponses interactives et rapides afin de maintenir le flux de développement
    • L'entraînement utilise l'apprentissage par renforcement dans divers environnements de développement avec des outils comme la lecture de fichiers, l'édition, les commandes terminal et la recherche sémantique
    • Cursor Bench est un benchmark d'évaluation basé sur de vraies demandes d'ingénieurs qui mesure la correction et le respect des abstractions du code existant
    • Le modèle apprend automatiquement des comportements utiles comme effectuer des recherches complexes, corriger les erreurs de linter et écrire des tests unitaires
    • L'infrastructure d'entraînement utilise PyTorch et Ray avec des kernels MXFP8 pour entraîner sur des milliers de GPUs NVIDIA
    • Le système exécute des centaines de milliers d'environnements de codage sandboxés concurrents dans le cloud pour l'entraînement
    • Composer est déjà utilisé quotidiennement par les développeurs de Cursor pour leur propre travail
    • Le modèle se positionne juste derrière GPT-5 et Sonnet 4.5 en termes de performance sur les benchmarks internes

    Rex sur l'utilisation de l'IA pour les développeurs, un gain de productivité réel et des contextes adaptés https://mcorbin.fr/posts/2025-10-17-genai-dev/

    • Un développeur avec 18 ans d'expérience partage son retour sur l'IA générative après avoir changé d'avis
    • Utilise exclusivement Claude Code dans le terminal pour coder en langage naturel
    • Le "vibe coding" permet de générer des scripts et interfaces sans regarder le code généré
    • Génération rapide de scripts Python pour traiter des CSV, JSON ou créer des interfaces HTML
    • Le mode chirurgien résout des bugs complexes en one-shot, exemple avec un plugin Grafana fixé en une minute
    • Pour le code de production, l'IA génère les couches repository, service et API de manière itérative, mais le dev controle le modele de données
    • Le développeur relit toujours le code et ajuste manuellement ou via l'IA selon le besoin
    • L'IA ne remplacera pas les développeurs car la réflexion, conception et expertise technique restent essentielles
    • La construction de produits robustes, scalables et maintenables nécessite une expérience humaine
    • L'IA libère du temps sur les tâches répétitives et permet de se concentrer sur les aspects complexes
    • ce que je trouve interessant c'est la partie sur le code de prod
    • effectivement, je corrige aussi beaucoup les propositions de l'IA en lui demandant de faire mieux dans tel ou tel domaine
    • Sans guide, tout cela serait perdu
    • Affaire a suivre
    • un article en parallele sur le métier de designer https://blog.ippon.fr/2025/11/03/lia-ne-remplace-pas-un-designer-elle-amplifie-la-difference-entre-faire-et-bien-faire/

    Plus besoin de se rappeler les racourcis dans IntelliJ idea avec l'universal entry point https://blog.jetbrains.com/idea/2025/11/universal-entry-point-a-single-entry-point-for-context-aware-coding-assistance/

    • IntelliJ IDEA introduit Command Completion, une nouvelle façon d'accéder aux actions de l'IDE directement depuis l'éditeur
    • Fonctionne comme la complétion de code : tapez point (.) pour voir les actions contextuelles disponibles
    • Tapez double point (..) pour filtrer et n'afficher que les actions disponibles
    • Propose des corrections, refactorings, génération de code et navigation selon le contexte
    • Complète les fonctionnalités existantes sans les remplacer : raccourcis, Alt+Enter, Search Everywhere
    • Facilite la découverte des fonctionnalités de l'IDE sans interrompre le flux de développement
    • En Beta dans la version 2025.2, sera activé par défaut dans 2025.3
    • Support actuel pour Java et Kotlin, avec actions spécifiques aux frameworks comme Spring et Hibernate

    Homebrew, package manage pour macOS et Linux passe en version 5 https://brew.sh/2025/11/12/homebrew-5.0.0/

    • Téléchargements Parallèles par Défaut : Le paramètre HOMEBREW_DOWNLOAD_CONCURRENCY=auto est activé par défaut, permettant des téléchargements concurrents pour tous les utilisateurs, avec un rapport de progression.
    • Support Linux ARM64/AArch64 en Tier 1 : Le support pour Linux ARM64/AArch64 a été promu au niveau "Tier 1" (support officiel de premier plan).
    • Feuille de Route pour les Dépréciations macOS :
      • Septembre 2026 (ou plus tard) : Homebrew ne fonctionnera plus sur macOS Catalina (10.15) et versions antérieures. macOS Intel (x86_64) passera en "Tier 3" (fin du support CI et des binaires précompilés/bottles).
      • Septembre 2027 (ou plus tard) : Homebrew ne fonctionnera plus sur macOS Big Sur (11) sur Apple Silicon ni du tout sur Intel (x86_64).
    • Sécurité et Casks :
      • Dépréciation des Casks sans signature de code.
      • Désactivation des Casks échouant aux vérifications Gatekeeper en septembre 2026.
      • Les options --no-quarantine et --quarantine sont dépréciés pour ne plus faciliter le contournement des fonctionnalités de sécurité de macOS.
    • Nouvelles Fonctionnalités & Améliorations :
      • Support officiel pour macOS 26 (Tahoe).
      • brew bundle supporte désormais l'installation de packages Go via un Brewfile.
      • Ajout de la commande brew info --sizes pour afficher la taille des formulae et casks.
      • La commande brew search --alpine permet de chercher des packages Alpine Linux.
    Architecture

    Selon l'analyste RedMonk, Java reste très pertinent dans l'aire de l'IA et des agents https://redmonk.com/jgovernor/java-relevance-in-the-ai-era-agent-frameworks-emerge/

    • Java reste pertinent à l'ère de l'IA, pas besoin d'apprendre une pile technique entièrement nouvelle.
    • Capacité d'adaptation de Java ("anticorps") aux innovations (Big Data, cloud, IA), le rendant idéal pour les contextes d'entreprise.
    • L'écosystème JVM offre des avantages sur Python pour la logique métier et les applications sophistiquées, notamment en termes de sécurité et d'évolutivité.
    • Embabel (par Rod Johnson, créateur de Spring) : un framework d'agents fortement typé pour JVM, visant le déterminisme des projets avant la génération de code par LLM.
    • LangChain4J : facilite l'accès aux capacités d'IA pour les développeurs Java, s'aligne sur les modèles d'entreprise établis et permet aux LLM d'appeler des méthodes Java.
    • Koog (Jetbrains) : framework d'agents basé sur Kotlin, typé et spécifique aux développeurs JVM/Kotlin.
    • Akka : a pivoté pour se concentrer sur les flux de travail d'agents IA, abordant la complexité, la confiance et les coûts des agents dans les systèmes distribués.
    • Le Model Context Protocol (MCP) est jugé insuffisant, manquant d'explicabilité, de découvrabilité, de capacité à mélanger les modèles, de garde-fous, de gestion de flux, de composabilité et d'intégration sécurisée.
    • Les développeurs Java sont bien placés pour construire des applications compatibles IA et intégrer des agents.
    • Des acteurs majeurs comme IBM, Red Hat et Oracle continuent d'investir massivement dans Java et son intégration avec l'IA.
    Sécurité

    AI Deepfake, Hiring … A danger réel https://www.eu-startups.com/2025/10/european-startups-get-serious-about-deepfakes-as-ai-fraud-losses-surpass-e1-3-billion/

    Loi, société et organisation

    Amazon - prévoit supprimer 30.000 postes https://www.20minutes.fr/economie/4181936-20251028-amazon-prevoit-supprimer-30-000-emplois-bureau-selon-plusieurs-medias

    • Postes supprimés : 30 000 bureaux
    • Part des effectifs : ~10 % des employés corporatifs
    • Tranche confirmée : 14 000 postes
    • Divisions touchées : RH, Opérations, Devices & Services, Cloud
    • Motifs : sur-recrutement, bureaucratie, automatisation/IA
    • Accompagnement : 90 jours pour poste interne + aides
    • Non concernés : entrepôts/logistique
    • Objectif : concentrer sur priorités stratégiques

    NTP a besoin d'argent https://www.ntp.org/

    • Il n'est que le protocole qui synchronise toutes les machines du monde
    • La fondation https://www.nwtime.org/ recherche 11000$ pour maintenir son activité
    Rubrique débutant

    Une plongée approfondie dans le démarrage de la JVM https://inside.java/2025/01/28/jvm-start-up

    • La JVM effectue une initialisation complexe avant d'exécuter le code : validation des arguments, détection des ressources système et sélection du garbage collector approprié
    • Le chargement de classes suit une stratégie lazy où chaque classe charge d'abord ses dépendances dans l'ordre de déclaration, créant une chaîne d'environ 450 classes même pour un simple Hello World
    • La liaison de classes comprend trois sous-processus : vérification de la structure, préparation avec initialisation des champs statiques à leurs valeurs par défaut, et résolution des références symboliques du Constant Pool
    • Le CDS améliore les performances au démarrage en fournissant des classes pré-vérifiées, réduisant le travail de la JVM
    • L'initialisation de classe exécute les initialiseurs statiques via la méthode spéciale clinit générée automatiquement par javac
    • Le Project Leyden introduit la compilation AOT dans JDK 24 pour réduire le temps de démarrage en effectuant le chargement et la liaison de classes en avance de phase
    • Pas si débutant finalement
    Conférences

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    18 November 2025, 10:18 am
  • 1 hour 13 minutes
    LCC 331 - Le retour des jackson 5

    Dans cet épisode, Arnaud et Guillaume discutent des dernières évolutions dans le monde de la programmation, notamment les nouveautés de Java 25, JUnit 6, et Jackson 3. Ils abordent également les récents développements en IA, les problèmes rencontrés dans le cloud, et l'état actuel de React et du web. Dans cette conversation, les intervenants abordent divers sujets liés à la technologie, notamment les spécifications de Wasteme, l'utilisation des UUID dans les bases de données, l'approche RAG en intelligence artificielle, les outils MCP, et la création d'images avec Nano Banana. Ils discutent également des complexités du format YAML, des récents dramas dans la communauté Ruby, de l'importance d'une bonne documentation, des politiques de retour au bureau, et des avancées de Cloud Code. Enfin, ils évoquent l'initiative de cafés IA pour démystifier l'intelligence artificielle.

    Enregistré le 24 octobre 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-331.mp3 ou en vidéo sur YouTube.

    News Langages

    GraalVM se détache du release train de Java https://blogs.oracle.com/java/post/detaching-graalvm-from-the-java-ecosystem-train

    Un article de Loic Mathieu sur Java 25 et ses nouvelles fonctionalités https://www.loicmathieu.fr/wordpress/informatique/java-25-whats-new/

    Sortie de Groovy 5.0 ! https://groovy-lang.org/releasenotes/groovy-5.0.html

    • Groovy 5: Évolution des versions précédentes, nouvelles fonctionnalités et simplification du code.
    • Compatibilité JDK étendue: Full support JDK 11-25, fonctionnalités JDK 17-25 disponibles sur les JDK plus anciens.
    • Extension majeure des méthodes: Plus de 350 méthodes améliorées, opérations sur tableaux jusqu'à 10x plus rapides, itérateurs paresseux.
    • Améliorations des transformations AST: Nouveau @OperatorRename, génération automatique de @NamedParam pour @MapConstructor et copyWith.
    • REPL (groovysh) modernisé: Basé sur JLine 3, support multi-plateforme, coloration syntaxique, historique et complétion.
    • Meilleure interopérabilité Java: Pattern Matching pour instanceof, support JEP-512 (fichiers source compacts et méthodes main d'instance).
    • Standards web modernes: Support Jakarta EE (par défaut) et Javax EE (héritage) pour la création de contenu web.
    • Vérification de type améliorée: Contrôle des chaînes de format plus robuste que Java.
    • Additions au langage: Génération d'itérateurs infinis, variables d'index dans les boucles, opérateur d'implication logique ==>.
    • Améliorations diverses: Import automatique de java.time.**, var avec multi-assignation, groupes de capture nommés pour regex (=~), méthodes utilitaires de graphiques à barres ASCII.
    • Changements impactants: Plusieurs modifications peuvent nécessiter une adaptation du code existant (visibilité, gestion des imports, comportement de certaines méthodes).
    • **Exigences JDK*: Construction avec JDK17+, exécution avec JDK11+.
    Librairies

    Intégration de LangChain4j dans ADK pour Java, permettant aux développeurs d'utiliser n'importe quel LLM avec leurs agents ADK https://developers.googleblog.com/en/adk-for-java-opening-up-to-third-party-language-models-via-langchain4j-integration/

    • ADK pour Java 0.2.0 : Nouvelle version du kit de développement d'agents de Google.
    • Intégration LangChain4j : Ouvre ADK à des modèles de langage tiers.
    • Plus de choix de LLM : En plus de Gemini et Claude, accès aux modèles d'OpenAI, Anthropic, Mistral, etc.
    • Modèles locaux supportés : Utilisation possible de modèles via Ollama ou Docker Model Runner.
    • Améliorations des outils : Création d'outils à partir d'instances d'objets, meilleur support asynchrone et contrôle des boucles d'exécution.
    • Logique et mémoire avancées : Ajout de callbacks en chaîne et de nouvelles options pour la gestion de la mémoire et le RAG (Retrieval-Augmented Generation).
    • Build simplifié : Introduction d'un POM parent et du Maven Wrapper pour un processus de construction cohérent.

    JUnit 6 est sorti https://docs.junit.org/6.0.0/release-notes/

    • :sparkles: Java 17 and Kotlin 2.2 baseline
    • :sunrise_over_mountains: JSpecify nullability annotations
    • :airplane_departure: Integrated JFR support
    • :suspension_railway: Kotlin suspend function support
    • :octagonal_sign: Support for cancelling test execution
    • :broom: Removal of deprecated APIs

    JGraphlet, une librairie Java sans dépendances pour créer des graphes de tâches à exécuter https://shaaf.dev/post/2025-08-25-think-in-graphs-not-just-chains-jgraphlet-for-taskpipelines/

    • JGraphlet: Bibliothèque Java légère (zéro-dépendance) pour construire des pipelines de tâches.
    • Principes clés: Simplicité, basée sur un modèle d'exécution de graphe.
    • Tâches: Chaque tâche a une entrée/sortie, peut être asynchrone (Task) ou synchrone (SyncTask).
    • Pipeline: Un TaskPipeline construit et exécute le graphe, gère les I/O.
    • Modèle Graph-First: Le flux de travail est un Graphe Orienté Acyclique (DAG).
      • Définition des tâches comme des nœuds, des connexions comme des arêtes.
      • Support naturel des motifs fan-out et fan-in.
    • API simple: addTask("id", task), connect("fromId", "toId").
    • Fan-in: Une tâche recevant plusieurs entrées reçoit une Map (clés = IDs des tâches parentes).
    • Exécution: pipeline.run(input) retourne un CompletableFuture (peut être bloquant via .join() ou asynchrone).
    • Cycle de vie: TaskPipeline est AutoCloseable, garantissant la libération des ressources (try-with-resources).
    • Contexte: PipelineContext pour partager des données/métadonnées thread-safe entre les tâches au sein d'une exécution.
    • Mise en cache: Option de mise en cache pour les tâches afin d'éviter les re-calculs.

    Au tour de Microsoft de lancer son (Microsoft) Agent Framework, qui semble être une fusion / réécriture de AutoGen et de Semnatic Kernel https://x.com/pyautogen/status/1974148055701028930

    • Plus de détails dans le blog post : https://devblogs.microsoft.com/foundry/introducing-microsoft-agent-framework-the-open-source-engine-for-agentic-ai-apps/
    • SDK & runtime open-source pour systèmes multi-agents sophistiqués. Unifie Semantic Kernel et AutoGen.
    • Piliers :
      • Standards ouverts (MCP, A2A, OpenAPI) et interopérabilité.
      • Passerelle recherche-production (patterns AutoGen pour l'entreprise).
      • Extensible, modulaire, open-source, connecteurs intégrés.
      • Prêt pour la production (observabilité, sécurité, durabilité, "human in the loop").
    • Relation SK/AutoGen : S'appuie sur eux, ne les remplace pas, simplifie la migration.
    • Intégrations futures : Alignement avec Microsoft 365 Agents SDK et Azure AI Foundry Agent Service.

    Sortie de Jackson 3.0 (bientôt les Jackson Five !!!) https://cowtowncoder.medium.com/jackson-3-0-0-ga-released-1f669cda529a

    • Jackson 3.0.0 a été publié le 3 octobre 2025.
    • Objectif : base propre pour le développement à long terme, suppression de la dette technique, architecture simplifiée, amélioration de l'ergonomie.
    • Principaux changements :
      • Baseline Java 17 requise (vs Java 8 pour 2.x).
      • Group ID Maven et package Java renommés en tools.jackson pour la coexistence avec Jackson 2.x. (Exception: jackson-annotations ne change pas).
      • Suppression de toutes les fonctionnalités @Deprecated de Jackson 2.x et renommage de plusieurs entités/méthodes clés.
      • Modification des paramètres de configuration par défaut (ex: FAIL_ON_UNKNOWN_PROPERTIES désactivé).
      • ObjectMapper et TokenStreamFactory sont désormais immutables, la configuration se fait via des builders.
      • Passage à des exceptions de base non vérifiées (JacksonException) pour plus de commodité.
      • Intégration des "modules Java 8" (pour les noms de paramètres, Optional, java.time) directement dans l'ObjectMapper par défaut.
      • Amélioration du modèle d'arbre JsonNode (plus de configurabilité, meilleure gestion des erreurs).

    Testcontainers Java 2.0 est sorti https://github.com/testcontainers/testcontainers-java/releases/tag/2.0.0

    • Removed JUnit 4 support -> ups

    Grails 7.0 est sortie, avec son arrivée à la fondation Apache https://grails.apache.org/blog/2025-10-18-introducing-grails-7.html

    • Sortie d'Apache Grails 7.0.0 annoncée le 18 octobre 2025.
    • Grails est devenu un projet de premier niveau (TLP) de l'Apache Software Foundation (ASF), graduant d'incubation.
    • Mise à jour des dépendances vers Groovy 4.0.28, Spring Boot 3.5.6, Jakarta EE.

    Tout pour bien démarrer et développer des agents IA avec ADK pour Java https://glaforge.dev/talks/2025/10/22/building-ai-agents-with-adk-for-java/

    • Guillaume a partagé plein de resources sur le développement d'agents IA avec ADK pour Java
    • Un article avec tous les pointeurs
    • Un slide deck et l'enregistrement vidéo de la présentation faite lors de Devoxx Belgique
    • Un codelab avec des instructions pour démarrer et créer ses premiers agents
    • Plein d'autres samples pour s'inspirer et voir les possibilités offertes par le framework
    • Et aussi un template de projet sur GitHub, avec un build Maven et un premier agent d'exemple
    Cloud

    Internet cassé, du moins la partie hébergée par AWS #hugops https://www.theregister.com/2025/10/20/aws_outage_amazon_brain_drain_corey_quinn/

    • Panne majeure d'AWS (région US-EAST-1) : problème DNS affectant DynamoDB, service fondamental, causant des défaillances en cascade de nombreux services internet.
    • Réponse lente : 75 minutes pour identifier la cause profonde; la page de statut affichait initialement "tout va bien".
    • Cause sous-jacente principale : "fuite des cerveaux" (départ d'ingénieurs AWS seniors).
    • Perte de connaissances institutionnelles : des décennies d'expertise critique sur les systèmes AWS et les modes de défaillance historiques parties avec ces départs.
    • Prédictions confirmées : un ancien d'AWS avait anticipé une augmentation des pannes majeures en 2024.
    • Preuves de la perte de talents :
      • Plus de 27 000 licenciements chez Amazon (2022-2025).
      • Taux élevé de "départs regrettés" (69-81%).
      • Mécontentement lié à la politique de "Return to Office" et au manque de reconnaissance de l'expertise.
    • Conséquences : les nouvelles équipes, plus réduites, manquent de l'expérience nécessaire pour prévenir les pannes ou réduire les temps de récupération.
    • Perspective : Le marché pourrait pardonner cette fois, mais le problème persistera, rendant les futurs incidents plus probables.
    Web

    React a gagné "par défaut" https://www.lorenstew.art/blog/react-won-by-default/

    • React domine par défaut, non par mérite technique, étouffant ainsi l'innovation front-end.
    • Choix par réflexe ("tout le monde connaît React"), freinant l'évaluation d'alternatives potentiellement supérieures.
    • Fondations techniques de React (V-DOM, complexité des Hooks, Server Components) vues comme des contraintes actuelles.
    • Des frameworks innovants (Svelte pour la compilation, Solid pour la réactivité fine, Qwik pour la "resumability") offrent des modèles plus performants mais sont sous-adoptés.
    • La monoculture de React génère une dette technique (runtime, réconciliation) et centre les compétences sur le framework plutôt que sur les fondamentaux web.
    • L'API React est complexe, augmentant la charge cognitive et les risques de bugs, contrairement aux alternatives plus simples.
    • L'effet de réseau crée une "prison": offres d'emploi spécifiques, inertie institutionnelle, leaders choisissant l'option "sûre".
    • Nécessité de choisir les frameworks selon les contraintes du projet et le mérite technique, non par inertie.
    • Les arguments courants (maturité de l'écosystème, recrutement, bibliothèques, stabilité) sont remis en question; une dépendance excessive peut devenir un fardeau.
    • La monoculture ralentit l'évolution du web et détourne les talents, nuisant à la diversité essentielle pour un écosystème sain et innovant.
    • Promouvoir la diversité des frameworks pour un écosystème plus résilient et innovant.

    WebAssembly 3 est sortie https://webassembly.org/news/2025-09-17-wasm-3.0/

    Data et Intelligence Artificielle

    UUIDv4 ou UUIDv7 pour vos clés primaires ? Ça dépend… surtout pour les bases de données super distribuées ! https://medium.com/google-cloud/understanding-uuidv7-and-its-impact-on-cloud-spanner-b8d1a776b9f7

    • UUIDv4 : identifiants entièrement aléatoires.
      • Cause des problèmes de performance dans les bases de données relationnelles (ex: PostgreSQL, MySQL, SQL Server) utilisant des index B-Tree.
      • Inserts aléatoires réduisent l'efficacité du cache, entraînent des divisions de pages et la fragmentation.
    • UUIDv7 : nouveau standard conçu pour résoudre ces problèmes.
      • Intègre un horodatage (48 bits) en préfixe de l'identifiant, le rendant ordonné temporellement et "k-sortable".
      • Améliore la performance dans les bases B-Tree en favorisant les inserts séquentiels, la localité du cache et réduisant la fragmentation.
    • Problème de UUIDv7 pour certaines bases de données distribuées et scalables horizontalement comme Spanner :
      • La nature séquentielle d'UUIDv7 (via l'horodatage) crée des "hotspots d'écriture" (points chauds) dans Spanner.
      • Spanner distribue les données en "splits" (partitions) basées sur les plages de clés. Les clés séquentielles concentrent les écritures sur un seul "split".
      • Ceci empêche Spanner de distribuer la charge et de scaler les écritures, créant un goulot d'étranglement ("anti-pattern").
    • Quand ce n'est PAS un problème pour Spanner :
      • Si le taux d'écriture total est inférieur à environ 3 500 écritures/seconde pour un seul "split".
      • Le hotspot est "bénin" à cette échelle et n'entraîne pas de dégradation de performance.
    • Solutions pour Spanner :
      • Principe clé : S'assurer que la première partie de la clé primaire est NON séquentielle pour distribuer les écritures. UUIDv7 peut être utilisé, mais pas comme préfixe.
    • Nouvelle conception ("greenfield") :
    • ▪︎ Utiliser une clé primaire non-séquentielle (ex: UUIDv4 simple).
      • Pour les requêtes basées sur le temps, créer un index secondaire sur la colonne d'horodatage, mais le SHARDER (ex: shardId) pour éviter les hotspots sur l'index lui-même.
    • Migration (garder UUIDv7) :
    • ▪︎ Ajouter un préfixe de sharding : Introduire une colonne `shard` calculée (ex: `MOD(ABS(FARM_FINGERPRINT(order_id_v7)), N)`) et l'utiliser comme PREMIER élément d'une clé primaire composite (`PRIMARY KEY (shard, order_id_v7)`).
      • Réordonner les colonnes (si clé primaire composite existante) : Si la clé primaire est déjà composite (ex: (order_id_v7, tenant_id)), réordonner en (tenant_id, order_id_v7). Cela aide si tenant_id a une cardinalité élevée et distribue bien. (Un tenant_id très actif pourrait toujours nécessiter un préfixe de sharding supplémentaire).

    RAG en prod, comment améliorer la pertinence des résultats https://blog.abdellatif.io/production-rag-processing-5m-documents

    • Démarrage rapide avec Langchain + Llamaindex: prototype fonctionnel, mais résultats de production jugés "subpar" par les utilisateurs.
    • Ce qui a amélioré la performance (par ROI):
      • Génération de requêtes: LLM crée des requêtes sémantiques et mots-clés multiples basées sur le fil de discussion pour une meilleure couverture.
      • Reranking: La technique la plus efficace, modifie grandement le classement des fragments (chunks).
      • Stratégie de découpage (Chunking): Nécessite beaucoup d'efforts, compréhension des données, création de fragments logiques sans coupures.
      • Métadonnées à l'LLM: L'injection de métadonnées (titre, auteur) améliore le contexte et les réponses.
      • Routage de requêtes: Détecte et traite les questions non-RAG (ex: résumer, qui a écrit) via API/LLM distinct.
    Outillage

    Créer un serveur MCP (mode HTTP Streamable) avec Micronaut et quelques éléments de comparaison avec Quarkus https://glaforge.dev/posts/2025/09/16/creating-a-streamable-http-mcp-server-with-micronaut/

    • Micronaut propose désormais un support officiel pour le protocole MCP.
    • Exemple : un serveur MCP pour les phases lunaires (similaire à une version Quarkus pour la comparaison).
    • Définition des outils MCP via les annotations @Tool et @ToolArg.
    • Point fort : Micronaut gère automatiquement la validation des entrées (ex: @NotBlank, @Pattern), éliminant la gestion manuelle des erreurs.
    • Génération automatique de schémas JSON détaillés pour les structures d'entrée/sortie grâce à @JsonSchema.
    • Nécessite une configuration pour exposer les schémas JSON générés comme ressources statiques.
    • Dépendances clés : micronaut-mcp-server-java-sdk et les modules json-schema.
    • Testé avec l'inspecteur MCP et intégration avec l'outil Gemini CLI.
    • Micronaut offre une gestion élégante des entrées/sorties structurées grâce à son support JSON Schema riche.

    Un agent IA créatif : comment utiliser le modèle Nano Banana pour générer et éditer des images (en Java, avec ADK) https://glaforge.dev/posts/2025/09/22/creative-ai-agents-with-adk-and-nano-banana/

    • Modèles de langage (LLM) deviennent multimodaux : traitent diverses entrées (texte, images, vidéo, audio).
    • Nano Banana (gemini-2.5-flash-image-preview) : modèle Gemini, génère et édite des images, pas seulement du texte.
    • ADK (Agent Development Kit pour Java) : pour configurer des agents IA créatifs utilisant ce type de modèle.
    • Application : Base pour des workflows créatifs complexes (ex: agent de marketing, enchaînement d'agents pour génération d'assets).

    Un vieil article (6 mois) qui illustre les problèmes du format de fichier YAML https://ruudvanasseldonk.com/2023/01/11/the-yaml-document-from-hell

    • YAML est extrêmement complexe malgré son objectif de convivialité humaine.
    • Spécification volumineuse et versionnée (YAML 1.1, 1.2 diffèrent significativement).
    • Comportements imprévisibles et "pièges" (footguns) courants :
      • Nombres sexagésimaux (ex: 22:22 parsé comme 1342 en YAML 1.1).
      • Tags (!.git) pouvant mener à des erreurs ou à l'exécution de code arbitraire.
      • "Problème de la Norvège" : no interprété comme false en YAML 1.1.
      • Clés non-chaînes de caractères (on peut devenir une clé booléenne True).
      • Nombres accidentels si non-guillemets (ex: 10.23 comme flottant).
    • La coloration syntaxique n'est pas fiable pour détecter ces subtilités.
    • Le templating de documents YAML est une mauvaise idée, source d'erreurs et complexe à gérer.
    • Alternatives suggérées :
      • TOML : Similaire à YAML mais plus sûr (chaînes toujours entre guillemets), permet les commentaires.
      • JSON avec commentaires (utilisé par VS Code), mais moins répandu.
      • Utiliser un sous-ensemble simple de YAML (difficile à faire respecter).
    • Générer du JSON à partir de langages de programmation plus puissants :
    • ▪︎ Nix : Excellent pour l'abstraction et la réutilisation de configuration.
      • Python : Facilite la création de JSON avec commentaires et logique.

    Gros binz dans la communauté Ruby, avec l'influence de grosses boîtes, et des pratiques un peu douteuses https://joel.drapper.me/p/rubygems-takeover/

    Méthodologies

    Les qualités d'une bonne documentation https://leerob.com/docs

    • Rapidité
      • Chargement très rapide des pages (préférer statique).
      • Optimisation des images, polices et scripts.
      • Recherche ultra-rapide (chargement et affichage des résultats).
    • Lisibilité
      • Concise, éviter le jargon technique.
      • Optimisée pour le survol (gras, italique, listes, titres, images).
      • Expérience utilisateur simple au départ, complexité progressive.
      • Multiples exemples de code (copier/coller).
    • Utilité
      • Documenter les solutions de contournement (workarounds).
      • Faciliter le feedback des lecteurs.
      • Vérification automatisée des liens morts.
      • Matériel d'apprentissage avec un curriculum structuré.
      • Guides de migration pour les changements majeurs.
    • Compatible IA
      • Trafic majoritairement via les crawlers IA.
      • Préférer cURL aux "clics", les prompts aux tutoriels.
      • Barre latérale "Demander à l'IA" référençant la documentation.
    • Prêt pour les agents
      • Faciliter le copier/coller de contenu en Markdown pour les chatbots.
      • Possibilité de visualiser les pages en Markdown (ex: via l'URL).
      • Fichier llms.txt comme répertoire de fichiers Markdown.
    • Finition soignée
      • Zones de clic généreuses (boutons, barres latérales).
      • Barres latérales conservant leur position de défilement et état déplié.
      • Bons états actifs/survol.
      • Images OG dynamiques.
      • Titres/sections lienables avec ancres stables.
      • Références et liens croisés entre guides, API, exemples.
      • Balises méta/canoniques pour un affichage propre dans les moteurs de recherche.
    • Localisée
      • Pas de /en par défaut dans l'URL.
      • Routage côté serveur pour la langue.
      • Localisation des chaînes statiques et du contenu.
    • Responsive
      • Excellents menus mobiles / support Safari iOS.
      • Info-bulles sur desktop, popovers sur mobile.
    • Accessible
      • Lien "ignorer la navigation" vers le contenu principal.
      • Toutes les images avec des balises alt.
      • Respect des paramètres système de mouvement réduit.
    • Universelle
      • Livrer la documentation "en tant que code" (JSDoc, package).
      • Livrer via des plateformes comme Context7, ou dans node_modules.
      • Fichiers de règles (ex: AGENTS.md) avec le produit.
      • Évaluations et modèles spécifiques recommandés pour le produit.
    Loi, société et organisation

    Microsoft va imposer une politique de Return To Office https://www.businessinsider.com/microsoft-execs-explain-rto-mandate-in-internal-meeting-2025-9

    • Microsoft impose 3 jours de présence au bureau par semaine à partir de février 2026, débutant par la région de Seattle
    • Le CEO Satya Nadella explique que le télétravail a affaibli les liens sociaux nécessaires à l'innovation
    • Les dirigeants citent des données internes montrant que les employés présents au bureau "prospèrent" davantage
    • L'équipe IA de Microsoft doit être présente 4 jours par semaine, règles plus strictes pour cette division stratégique
    • Les employés peuvent demander des exceptions jusqu'au 19 septembre 2025 pour trajets complexes ou absence d'équipe locale
    • Amy Coleman (RH) affirme que la collaboration en personne améliore l'énergie et les résultats, surtout à l'ère de l'IA
    • La politique s'appliquera progressivement aux 228 000 employés dans le monde après les États-Unis
    • Les réactions sont mitigées, certains employés critiquent la perte d'autonomie et les bureaux inadéquats
    • Microsoft rattrape ses concurrents tech qui ont déjà imposé des retours au bureau plus stricts
    • Cette décision intervient après 15 000 licenciements en 2025, créant des tensions avec les employés

    Comment Claude Code est né ? (l'histoire de sa création) https://newsletter.pragmaticengineer.com/p/how-claude-code-is-built

    • Claude Code : outil de développement "AI-first" créé par Boris Cherny, Sid Bidasaria et Cat Wu.
    • Performance impressionnante : 500M$ de revenus annuels, utilisation multipliée par 10 en 3 mois.
    • Adoption interne massive : Plus de 80% des ingénieurs d'Anthropic l'utilisent quotidiennement, y compris les data scientists.
    • Augmentation de productivité : 67% d'augmentation des Pull Requests (PR) par ingénieur malgré le doublement de l'équipe.
    • Origine : Commande CLI simple évoluant vers un outil accédant au système de fichiers, exploitant le "product overhang" du modèle Claude.
    • Raison du lancement public : Apprendre sur la sécurité et les capacités des modèles d'IA.
    • Pile technologique "on distribution" : TypeScript, React (avec Ink), Yoga, Bun. Choisie car le modèle Claude est déjà très performant avec ces technologies.
    • "Claude Code écrit 90% de son propre code" : Le modèle prend en charge la majeure partie du développement.
    • Architecture légère : Simple "shell" autour du modèle Claude, minimisant la logique métier et le code (suppression constante de code superflu).
    • Exécution locale : Privilégiée pour sa simplicité, sans virtualisation.
    • Sécurité : Système de permissions granulaire demandant confirmation avant chaque action potentiellement dangereuse (ex: suppression de fichiers).
    • Développement rapide :
      • Jusqu'à 100 releases internes/jour, 1 release externe/jour.
      • 5 Pull Requests/ingénieur/jour.
      • Prototypage ultra-rapide (ex: 20+ prototypes d'une fonctionnalité en quelques heures) grâce aux agents IA.
    • Innovation UI/UX : Redéfinit l'expérience du terminal grâce à l'interaction LLM, avec des fonctionnalités comme les sous-agents, les styles de sortie configurables, et un mode "Learning".

    Le 1er Café IA publique a Paris

    https://www.linkedin.com/pulse/my-first-caf%25C3%25A9-ia-paris-room-full-curiosity-an[…]o-goncalves-r9ble/?trackingId=%2FPHKdAimR4ah6Ep0Qbg94w%3D%3D

    Conférences

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    6 November 2025, 2:34 pm
  • 1 hour 48 minutes
    LCC 330 - Nano banana l'AI de Julia

    Katia, Emmanuel et Guillaume discutent Java, Kotlin, Quarkus, Hibernate, Spring Boot 4, intelligence artificielle (modèles Nano Banana, VO3, frameworks agentiques, embedding). On discute les vulnerabilités OWASP pour les LLMs, les personalités de codage des différents modèles, Podman vs Docker, comment moderniser des projets legacy. Mais surtout on a passé du temps sur les présentations de Luc Julia et les différents contre points qui ont fait le buzz sur les réseaux.

    Enregistré le 12 septembre 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-330.mp3 ou en vidéo sur YouTube.

    News Langages

    Dans cette vidéo, José détaille les nouveautés de Java entre Java 21 et 25 https://inside.java/2025/08/31/roadto25-java-language/

    • Aperçu des nouveautés du JDK 25 : Introduction des nouvelles fonctionnalités du langage Java et des changements à venir [00:02].
    • Programmation orientée données et Pattern Matching [00:43] :
      • Évolution du "pattern matching" pour la déconstruction des "records" [01:22].
      • Utilisation des "sealed types" dans les expressions switch pour améliorer la lisibilité et la robustesse du code [01:47].
      • Introduction des "unnamed patterns" (_) pour indiquer qu'une variable n'est pas utilisée [04:47].
      • Support des types primitifs dans instanceof et switch (en preview) [14:02].
    • Conception d'applications Java [00:52] :
      • Simplification de la méthode main [21:31].
      • Exécution directe des fichiers .java sans compilation explicite [22:46].
      • Amélioration des mécanismes d'importation [23:41].
      • Utilisation de la syntaxe Markdown dans la Javadoc [27:46].
    • Immuabilité et valeurs nulles [01:08] :
      • Problème d'observation de champs final à null pendant la construction d'un objet [28:44].
      • JEP 513 pour contrôler l'appel à super() et restreindre l'usage de this dans les constructeurs [33:29].

    JDK 25 sort le 16 septembre https://openjdk.org/projects/jdk/25/

    • Scoped Values (JEP 505) - alternative plus efficace aux ThreadLocal pour partager des données immutables entre threads
    • Structured Concurrency (JEP 506) - traiter des groupes de tâches concurrentes comme une seule unité de travail, simplifiant la gestion des threads
    • Compact Object Headers (JEP 519) - Fonctionnalité finale qui réduit de 50% la taille des en-têtes d'objets (de 128 à 64 bits), économisant jusqu'à 22% de mémoire heap
    • Flexible Constructor Bodies (JEP 513) - Relaxation des restrictions sur les constructeurs, permettant du code avant l'appel super() ou this()
    • Module Import Declarations (JEP 511) - Import simplifié permettant d'importer tous les éléments publics d'un module en une seule déclaration
    • Compact Source Files (JEP 512) - Simplification des programmes Java basiques avec des méthodes main d'instance sans classe wrapper obligatoire
    • Primitive Types in Patterns (JEP 455) - Troisième preview étendant le pattern matching et instanceof aux types primitifs dans switch et instanceof
    • Generational Shenandoah (JEP 521) - Le garbage collector Shenandoah passe en mode générationnel pour de meilleures performances
    • JFR Method Timing & Tracing (JEP 520) - Nouvel outillage de profilage pour mesurer le temps d'exécution et tracer les appels de méthodes
    • Key Derivation API (JEP 510) - API finale pour les fonctions de dérivation de clés cryptographiques, remplaçant les implémentations tierces

    Améliorations du traitement des annotations dans Kotlin 2.2 https://blog.jetbrains.com/idea/2025/09/improved-annotation-handling-in-kotlin-2-2-less-boilerplate-fewer-surprises/

    • Avant Kotlin 2.2, les annotations sur les paramètres de constructeur n'étaient appliquées qu'au paramètre, pas à la propriété ou au champ
    • Cela causait des bugs subtils avec Spring et JPA où la validation ne fonctionnait qu'à la création d'objet, pas lors des mises à jour
    • La solution précédente nécessitait d'utiliser explicitement @field: pour chaque annotation, créant du code verbeux
    • Kotlin 2.2 introduit un nouveau comportement par défaut qui applique les annotations aux paramètres ET aux propriétés/champs automatiquement
    • Le code devient plus propre sans avoir besoin de syntaxe @field: répétitive
    • Pour l'activer, ajouter -Xannotation-default-target=param-property dans les options du compilateur Gradle
    • IntelliJ IDEA propose un quick-fix pour activer ce comportement à l'échelle du projet
    • Cette amélioration rend l'intégration Kotlin plus fluide avec les frameworks majeurs comme Spring et JPA
    • Le comportement peut être configuré pour garder l'ancien mode ou activer un mode transitoire avec avertissements
    • Cette mise à jour fait partie d'une initiative plus large pour améliorer l'expérience Kotlin + Spring
    Librairies

    Sortie de Quarkus 3.26 avec mises à jour d'Hibernate et autres fonctionnalités - https://quarkus.io/blog/quarkus-3-26-released/

    • mettez à jour vers la 3.26.x car il y a eu une regression vert.x
    • Jalon important vers la version LTS 3.27 prévue fin septembre, basée sur cette version
    • Mise à jour vers Hibernate ORM 7.1, Hibernate Search 8.1 et Hibernate Reactive 3.1
    • Support des unités de persistance nommées et sources de données dans Hibernate Reactive
    • Démarrage hors ligne et configuration de dialecte pour Hibernate ORM même si la base n'est pas accessible
    • Refonte de la console HQL dans Dev UI avec fonctionnalité Hibernate Assistant intégrée
    • Exposition des capacités Dev UI comme fonctions MCP pour pilotage via outils IA
    • Rafraîchissement automatique des tokens OIDC en cas de réponse 401 des clients REST
    • Extension JFR pour capturer les données runtime (nom app, version, extensions actives)
    • Bump de Gradle vers la version 9.0 par défaut, suppression du support des classes config legacy

    Guide de démarrage avec Quarkus et A2A Java SDK 0.3.0 (pour faire discuter des agents IA avec la dernière version du protocole A2A) https://quarkus.io/blog/quarkus-a2a-java-0-3-0-alpha-release/

    • Sortie de l'A2A Java SDK 0.3.0.Alpha1, aligné avec la spécification A2A v0.3.0.
    • Protocole A2A : standard ouvert (Linux Foundation), permet la communication inter-agents IA polyglottes. Version 0.3.0 plus stable, introduit le support gRPC.
    • Mises à jour générales : changements significatifs, expérience utilisateur améliorée (côté client et serveur).
    • Agents serveur A2A :
      • Support gRPC ajouté (en plus de JSON-RPC). HTTP+JSON/REST à venir.
      • Implémentations basées sur Quarkus (alternatives Jakarta existent).
      • Dépendances spécifiques pour chaque transport (ex: a2a-java-sdk-reference-jsonrpc, a2a-java-sdk-reference-grpc).
      • AgentCard : décrit les capacités de l'agent. Doit spécifier le point d'accès primaire et tous les transports supportés (additionalInterfaces).
    • Clients A2A :
      • Dépendance principale : a2a-java-sdk-client.
      • Support gRPC ajouté (en plus de JSON-RPC). HTTP+JSON/REST à venir.
      • Dépendance spécifique pour gRPC : a2a-java-sdk-client-transport-grpc.
      • Création de client : via ClientBuilder. Sélectionne automatiquement le transport selon l'AgentCard et la configuration client. Permet de spécifier les transports supportés par le client (withTransport).

    Comment générer et éditer des images en Java avec Nano Banana, le "photoshop killer" de Google https://glaforge.dev/posts/2025/09/09/calling-nano-banana-from-java/

    • Objectif : Intégrer le modèle Nano Banana (Gemini 2.5 Flash Image preview) dans des applications Java.
    • SDK utilisé : GenAI Java SDK de Google.
    • Compatibilité : Supporté par ADK for Java ; pas encore par LangChain4j (limitation de multimodalité de sortie).
    • Capacités de Nano Banana :
      • Créer de nouvelles images.
      • Modifier des images existantes.
      • Assembler plusieurs images.
    • Mise en œuvre Java :
      • Quelle dépendance utiliser
      • Comment s'authentifier
      • Comment configurer le modèle
    • Nature du modèle : Nano Banana est un modèle de chat qui peut retourner du texte et une image (pas simplement juste un modèle générateur d'image)
    • Exemples d'utilisation :
      • Création : Via un simple prompt textuel.
      • Modification : En passant l'image existante (tableau de bytes) et les instructions de modification (prompt).
      • Assemblage : En passant plusieurs images (en bytes) et les instructions d'intégration (prompt).
    • Message clé : Toutes ces fonctionnalités sont accessibles en Java, sans nécessiter Python.

    Générer des vidéos IA avec le modèle Veo 3, mais en Java ! https://glaforge.dev/posts/2025/09/10/generating-videos-in-java-with-veo3/

    • Génération de vidéos en Java avec Veo 3 (via le GenAI Java SDK de Google).
    • Veo 3: Annoncé comme GA, prix réduits, support du format 9:16, résolution jusqu'à 1080p.
    • Création de vidéos :
      • À partir d'une invite textuelle (prompt).
      • À partir d'une image existante.
    • Deux versions différentes du modèle :
      • veo-3.0-generate-001 (qualité supérieure, plus coûteux, plus lent).
      • veo-3.0-fast-generate-001 (qualité inférieure, moins coûteux, mais plus rapide).

    Rod Johnson sur ecrire des aplication agentic en Java plus facilement qu'en python avec Embabel https://medium.com/@springrod/you-can-build-better-ai-agents-in-java-than-python-868eaf008493

    • Rod the papa de Spring réécrit un exemple CrewAI (Python) qui génère un livre en utilisant Embabel (Java) pour démontrer la supériorité de Java
    • L'application utilise plusieurs agents AI spécialisés : un chercheur, un planificateur de livre et des rédacteurs de chapitres
    • Le processus suit trois étapes : recherche du sujet, création du plan, rédaction parallèle des chapitres puis assemblage
    • CrewAI souffre de plusieurs problèmes : configuration lourde, manque de type safety, utilisation de clés magiques dans les prompts
    • La version Embabel nécessite moins de code Java que l'original Python et moins de fichiers de configuration YAML
    • Embabel apporte la type safety complète, éliminant les erreurs de frappe dans les prompts et améliorant l'outillage IDE
    • La gestion de la concurrence est mieux contrôlée en Java pour éviter les limites de débit des APIs LLM
    • L'intégration avec Spring permet une configuration externe simple des modèles LLM et hyperparamètres
    • Le planificateur Embabel détermine automatiquement l'ordre d'exécution des actions basé sur leurs types requis
    • L'argument principal : l'écosystème JVM offre un meilleur modèle de programmation et accès à la logique métier existante que Python
    • Il y a pas mal de nouveaux framework agentic en Java, notamment le dernier LAngchain4j Agentic

    Spring lance un serie de blog posts sur les nouveautés de Spring Boot 4 https://spring.io/blog/2025/09/02/road_to_ga_introduction

    • baseline JDK 17
    • mais rebase sur Jakarta 11
    • Kotlin 2, Jackson 3 et JUnit 6
    • Fonctionnalités de résilience principales de Spring : @ConcurrencyLimit, @Retryable, RetryTemplate
    • Versioning d'API dans Spring
    • Améliorations du client de service HTTP
    • L'état des clients HTTP dans Spring
    • Introduction du support Jackson 3 dans Spring
    • Consommateur partagé - les queues Kafka dans Spring Kafka
    • Modularisation de Spring Boot
    • Autorisation progressive dans Spring Security
    • Spring gRPC - un nouveau module Spring Boot
    • Applications null-safe avec Spring Boot 4
    • OpenTelemetry avec Spring Boot
    • Repos Ahead of Time (Partie 2)
    Web

    Faire de la recherche sémantique directement dans le navigateur en local, avec EmbeddingGemma et Transformers.js https://glaforge.dev/posts/2025/09/08/in-browser-semantic-search-with-embeddinggemma/

    • EmbeddingGemma: Nouveau modèle d'embedding (308M paramètres) de Google DeepMind.
    • Objectif: Permettre la recherche sémantique directement dans le navigateur.
    • Avantages clés de l'IA côté client:
      • Confidentialité: Aucune donnée envoyée à un serveur.
      • Coûts réduits: Pas besoin de serveurs coûteux (GPU), hébergement statique.
      • Faible latence: Traitement instantané sans allers-retours réseau.
      • Fonctionnement hors ligne: Possible après le chargement initial du modèle.
    • Technologie principale:
      • Modèle: EmbeddingGemma (petit, performant, multilingue, support MRL pour réduire la taille des vecteurs).
      • Moteur d'inférence: Transformers.js de HuggingFace (exécute les modèles AI en JavaScript dans le navigateur).
    • Déploiement: Site statique avec Vite/React/Tailwind CSS, déployé sur Firebase Hosting via GitHub Actions.
    • Gestion du modèle: Fichiers du modèle trop lourds pour Git; téléchargés depuis HuggingFace Hub pendant le CI/CD.
    • Fonctionnement de l'app: Charge le modèle, génère des embeddings pour requêtes/documents, calcule la similarité sémantique.
    • Conclusion: Démonstration d'une recherche sémantique privée, économique et sans serveur, soulignant le potentiel de l'IA embarquée dans le navigateur.
    Data et Intelligence Artificielle

    Docker lance Cagent, une sorte de framework multi-agent IA utilisant des LLMs externes, des modèles de Docker Model Runner, avec le Docker MCP Tookit. Il propose un format YAML pour décrire les agents d'un système multi-agents. https://github.com/docker/cagent

    • des agents "prompt driven" (pas de code)
    • et une structure pour decrire comment ils sont deployés
    • pas clair comment ils sont appelés a part dans la ligne de commande de cagent
    • fait par david gageot

    L'owasp décrit l'independance excessive des LLM comme une vulnerabilité https://genai.owasp.org/llmrisk2023-24/llm08-excessive-agency/

    • L'agence excessive désigne la vulnérabilité qui permet aux systèmes LLM d'effectuer des actions dommageables via des sorties inattendues ou ambiguës.
    • Elle résulte de trois causes principales : fonctionnalités excessives, permissions excessives ou autonomie excessive des agents LLM.
    • Les fonctionnalités excessives incluent l'accès à des plugins qui offrent plus de capacités que nécessaire, comme un plugin de lecture qui peut aussi modifier ou supprimer.
    • Les permissions excessives se manifestent quand un plugin accède aux systèmes avec des droits trop élevés, par exemple un accès en lecture qui inclut aussi l'écriture.
    • L'autonomie excessive survient quand le système effectue des actions critiques sans validation humaine préalable.
    • Un scénario d'attaque typique : un assistant personnel avec accès email peut être manipulé par injection de prompt pour envoyer du spam via la boîte de l'utilisateur.
    • La prévention implique de limiter strictement les plugins aux fonctions minimales nécessaires pour l'opération prévue.
    • Il faut éviter les fonctions ouvertes comme "exécuter une commande shell" au profit d'outils plus granulaires et spécifiques.
    • L'application du principe de moindre privilège est cruciale : chaque plugin doit avoir uniquement les permissions minimales requises.
    • Le contrôle humain dans la boucle reste essentiel pour valider les actions à fort impact avant leur exécution.

    Lancement du MCP registry, une sorte de méta-annuaire officiel pour référencer les serveurs MCP https://www.marktechpost.com/2025/09/09/mcp-team-launches-the-preview-version-of-the-mcp-registry-a-federated-discovery-layer-for-enterprise-ai/

    • MCP Registry : Couche de découverte fédérée pour l'IA d'entreprise.
    • Fonctionne comme le DNS pour le contexte de l'IA, permettant la découverte de serveurs MCP publics ou privés.
    • Modèle fédéré : Évite les risques de sécurité et de conformité d'un registre monolithique.
    • Permet des sous-registres privés tout en conservant une source de vérité "upstream".
    • Avantages entreprises :
      • Découverte interne sécurisée.
      • Gouvernance centralisée des serveurs externes.
      • Réduction de la prolifération des contextes.
      • Support pour les agents IA hybrides (données privées/publiques).
    • Projet open source, actuellement en version preview.
    • Blog post officiel : https://blog.modelcontextprotocol.io/posts/2025-09-08-mcp-registry-preview/

    Exploration des internals du transaction log SQL Server https://debezium.io/blog/2025/09/08/sqlserver-tx-log/

    • C'est un article pour les rugeux qui veulent savoir comment SQLServer marche à l'interieur
    • Debezium utilise actuellement les change tables de SQL Server CDC en polling périodique
    • L'article explore la possibilité de parser directement le transaction log pour améliorer les performances
    • Le transaction log est divisé en Virtual Log Files (VLFs) utilisés de manière circulaire
    • Chaque VLF contient des blocs (512B à 60KB) qui contiennent les records de transactions
    • Chaque record a un Log Sequence Number (LSN) unique pour l'identifier précisément
    • Les données sont stockées dans des pages de 8KB avec header de 96 bytes et offset array
    • Les tables sont organisées en partitions et allocation units pour gérer l'espace disque
    • L'utilitaire DBCC permet d'explorer la structure interne des pages et leur contenu
    • Cette compréhension pose les bases pour parser programmatiquement le transaction log dans un prochain article
    Outillage

    Les personalités des codeurs des différents LLMs https://www.sonarsource.com/blog/the-coding-personalities-of-leading-llms-gpt-5-update/

    • GPT-5 minimal ne détrône pas Claude Sonnet 4 comme leader en performance fonctionnelle malgré ses 75% de réussite
    • GPT-5 génère un code extrêmement verbeux avec 490 000 lignes contre 370 000 pour Claude Sonnet 4 sur les mêmes tâches
    • La complexité cyclomatique et cognitive du code GPT-5 est dramatiquement plus élevée que tous les autres modèles
    • GPT-5 introduit 3,90 problèmes par tâche réussie contre seulement 2,11 pour Claude Sonnet 4
    • Point fort de GPT-5 : sécurité exceptionnelle avec seulement 0,12 vulnérabilité par 1000 lignes de code
    • Faiblesse majeure : densité très élevée de "code smells" (25,28 par 1000 lignes) nuisant à la maintenabilité
    • GPT-5 produit 12% de problèmes liés à la complexité cognitive, le taux le plus élevé de tous les modèles
    • Tendance aux erreurs logiques fondamentales avec 24% de bugs de type "Control-flow mistake"
    • Réapparition de vulnérabilités classiques comme les failles d'injection et de traversée de chemin
    • Nécessité d'une gouvernance renforcée avec analyse statique obligatoire pour gérer la complexité du code généré

    Pourquoi j'ai abandonné Docker pour Podman https://codesmash.dev/why-i-ditched-docker-for-podman-and-you-should-too

    • Problème Docker : Le daemon dockerd persistant s'exécute avec des privilèges root, posant des risques de sécurité (nombreuses CVEs citées) et consommant des ressources inutilement.
    • Solution Podman :
      • Sans Daemon : Pas de processus d'arrière-plan persistant. Les conteneurs s'exécutent comme des processus enfants de la commande Podman, sous les privilèges de l'utilisateur.
      • Sécurité Renforcée : Réduction de la surface d'attaque. Une évasion de conteneur compromet un utilisateur non privilégié sur l'hôte, pas le système entier. Mode rootless.
      • Fiabilité Accrue : Pas de point de défaillance unique ; le crash d'un conteneur n'affecte pas les autres.
      • Moins de Ressources : Pas de daemon constamment actif, donc moins de mémoire et de CPU.
    • Fonctionnalités Clés de Podman :
      • Intégration Systemd : Génération automatique de fichiers d'unité systemd pour gérer les conteneurs comme des services Linux standards.
      • Alignement Kubernetes : Support natif des pods et capacité à générer des fichiers Kubernetes YAML directement (podman generate kube), facilitant le développement local pour K8s.
      • Philosophie Unix : Se concentre sur l'exécution des conteneurs, délègue les tâches spécialisées à des outils dédiés (ex: Buildah pour la construction d'images, Skopeo pour leur gestion).
    • Migration Facile :
      • CLI compatible Docker : podman utilise les mêmes commandes que docker (alias docker=podman fonctionne).
      • Les Dockerfiles existants sont directement utilisables.
      • Améliorations incluses : Sécurité par défaut (ports privilégiés en mode rootless), meilleure gestion des permissions de volume, API Docker compatible optionnelle.
      • Option de convertir Docker Compose en Kubernetes YAML.
    • Bénéfices en Production : Sécurité améliorée, utilisation plus propre des ressources. Podman représente une évolution plus sécurisée et mieux alignée avec les pratiques modernes de gestion Linux et de déploiement de conteneurs.
    • Guide Pratique (Exemple FastAPI) :
      • Le Dockerfile ne change pas.
      • podman build et podman run remplacent directement les commandes Docker.
      • Déploiement en production via Systemd.
      • Gestion d'applications multi-services avec les "pods" Podman.
      • Compatibilité Docker Compose via podman-compose ou kompose.

    Détection améliorée des APIs vulnérables dans les IDEs JetBrains et Qodana - https://blog.jetbrains.com/idea/2025/09/enhanced-vulnerable-api-detection-in-jetbrains-ides-and-qodana/

    • JetBrains s'associe avec Mend.io pour renforcer la sécurité du code dans leurs outils
    • Le plugin Package Checker bénéficie de nouvelles données enrichies sur les APIs vulnérables
    • Analyse des graphes d'appels pour couvrir plus de méthodes publiques des bibliothèques open-source
    • Support de Java, Kotlin, C#, JavaScript, TypeScript et Python pour la détection de vulnérabilités
    • Activation des inspections via Paramètres > Editor > Inspections en recherchant "Vulnerable API"
    • Surlignage automatique des méthodes vulnérables avec détails des failles au survol
    • Action contextuelle pour naviguer directement vers la déclaration de dépendance problématique
    • Mise à jour automatique vers une version non affectée via Alt+Enter sur la dépendance
    • Fenêtre dédiée "Vulnerable Dependencies" pour voir l'état global des vulnérabilités du projet
    Méthodologies

    Le retour de du sondage de Stack Overflow sur l'usage de l'IA dans le code https://medium.com/@amareshadak/stack-overflow-just-exposed-the-ugly-truth-about-ai-coding-tools-b4f7b5992191

    • 84% des développeurs utilisent l'IA quotidiennement, mais 46% ne font pas confiance aux résultats. Seulement 3,1% font "hautement confiance" au code généré.
    • 66% sont frustrés par les solutions IA "presque correctes". 45% disent que déboguer le code IA prend plus de temps que l'écrire soi-même.
    • Les développeurs seniors (10+ ans) font moins confiance à l'IA (2,6%) que les débutants (6,1%), créant un écart de connaissances dangereux.
    • Les pays occidentaux montrent moins de confiance - Allemagne (22%), UK (23%), USA (28%) - que l'Inde (56%). Les créateurs d'outils IA leur font moins confiance.
    • 77% des développeurs professionnels rejettent la programmation en langage naturel, seuls 12% l'utilisent réellement.
    • Quand l'IA échoue, 75% se tournent vers les humains. 35% des visites Stack Overflow concernent maintenant des problèmes liés à l'IA.
    • 69% rapportent des gains de productivité personnels, mais seulement 17% voient une amélioration de la collaboration d'équipe.
    • Coûts cachés : temps de vérification, explication du code IA aux équipes, refactorisation et charge cognitive constante.
    • Les plateformes humaines dominent encore : Stack Overflow (84%), GitHub (67%), YouTube (61%) pour résoudre les problèmes IA.
    • L'avenir suggère un "développement augmenté" où l'IA devient un outil parmi d'autres, nécessitant transparence et gestion de l'incertitude.

    Mentorat open source et défis communautaires par les gens de Microcks https://microcks.io/blog/beyond-code-open-source-mentorship/

    • Microcks souffre du syndrome des "utilisateurs silencieux" qui bénéficient du projet sans contribuer
    • Malgré des milliers de téléchargements et une adoption croissante, l'engagement communautaire reste faible
    • Ce manque d'interaction crée des défis de durabilité et limite l'innovation du projet
    • Les mainteneurs développent dans le vide sans feedback des vrais utilisateurs
    • Contribuer ne nécessite pas de coder : documentation, partage d'expérience, signalement de bugs suffisent
    • Parler du project qu'on aime autour de soi est aussi super utile
    • Microcks a aussi des questions specifiques qu'ils ont posé dans le blog, donc si vous l'utilisez, aller voir
    • Le succès de l'open source dépend de la transformation des utilisateurs en véritables partenaires communautaires
    • c'est un point assez commun je trouve, le ratio parlant / silencieux est tres petit et cela encourage les quelques grandes gueules

    La modernisation du systemes legacy, c'est pas que de la tech https://blog.scottlogic.com/2025/08/27/holistic-approach-successful-legacy-modernisation.html

    • Un artcile qui prend du recul sur la modernisation de systemes legacy
    • Les projets de modernisation legacy nécessitent une vision holistique au-delà du simple focus technologique
    • Les drivers business diffèrent des projets greenfield : réduction des coûts et mitigation des risques plutôt que génération de revenus
    • L'état actuel est plus complexe à cartographier avec de nombreuses dépendances et risques de rupture
    • Collaboration essentielle entre Architectes, Analystes Business et Designers UX dès la phase de découverte
    • Approche tridimensionnelle obligatoire : Personnes, Processus et Technologie (comme un jeu d'échecs 3D)
    • Le leadership doit créer l'espace nécessaire pour la découverte et la planification plutôt que presser l'équipe
    • Communication en termes business plutôt que techniques vers tous les niveaux de l'organisation
    • Planification préalable essentielle contrairement aux idées reçues sur l'agilité
    • Séquencement optimal souvent non-évident et nécessitant une analyse approfondie des interdépendances
    • Phases projet alignées sur les résultats business permettent l'agilité au sein de chaque phase
    Sécurité

    Cyber Attaque su Musée Histoire Naturelle https://www.franceinfo.fr/internet/securite-sur-internet/cyberattaques/le-museum-nati[…]e-d-une-cyberattaque-severe-une-plainte-deposee_7430356.html

    Compromission massive de packages npm populaires par un malware crypto https://www.aikido.dev/blog/npm-debug-and-chalk-packages-compromised

    • 18 packages npm très populaires compromis le 8 septembre 2025, incluant chalk, debug, ansi-styles avec plus de 2 milliards de téléchargements hebdomadaires combinés
    • duckdb s'est rajouté à la liste
    • Code malveillant injecté qui intercepte silencieusement l'activité crypto et web3 dans les navigateurs des utilisateurs
    • Le malware manipule les interactions de wallet et redirige les paiements vers des comptes contrôlés par l'attaquant sans signes évidents
    • Injection dans les fonctions critiques comme fetch, XMLHttpRequest et APIs de wallets (window.ethereum, Solana) pour intercepter le trafic
    • Détection et remplacement automatique des adresses crypto sur multiple blockchains (Ethereum, Bitcoin, Solana, Tron, Litecoin, Bitcoin Cash)
    • Les transactions sont modifiées en arrière-plan même si l'interface utilisateur semble correcte et légitime
    • Utilise des adresses "sosies" via correspondance de chaînes pour rendre les échanges moins évidents à détecter
    • Le mainteneur compromis par email de phishing provenant du faux domaine "mailto:[email protected]|[email protected]" enregistré 3 jours avant l'attaque
    • sur une demande de mise a jour de son autheotnfication a deux facteurs après un an
    • Aikido a alerté le mainteneur via Bluesky qui a confirmé la compromission et commencé le nettoyage des packages
    • Attaque sophistiquée opérant à plusieurs niveaux: contenu web, appels API et manipulation des signatures de transactions

    Les anti-cheats de jeux vidéo : une faille de sécurité majeure ? - https://tferdinand.net/jeux-video-et-si-votre-anti-cheat-etait-la-plus-grosse-faille/

    • Les anti-cheats modernes s'installent au Ring 0 (noyau système) avec privilèges maximaux
    • Ils obtiennent le même niveau d'accès que les antivirus professionnels mais sans audit ni certification
    • Certains exploitent Secure Boot pour se charger avant le système d'exploitation
    • Risque de supply chain : le groupe APT41 a déjà compromis des jeux comme League of Legends
    • Un attaquant infiltré pourrait désactiver les solutions de sécurité et rester invisible
    • Menace de stabilité : une erreur peut empêcher le démarrage du système (référence CrowdStrike)
    • Conflits possibles entre différents anti-cheats qui se bloquent mutuellement
    • Surveillance en temps réel des données d'utilisation sous prétexte anti-triche
    • Dérive dangereuse selon l'auteur : des entreprises de jeux accèdent au niveau EDR
    • Alternatives limitées : cloud gaming ou sandboxing avec impact sur performances
    • donc faites gaffe aux jeux que vos gamins installent !
    Loi, société et organisation

    Luc Julia au Sénat - Monsieur Phi réagi et publie la vidéo Luc Julia au Sénat : autopsie d'un grand N'IMPORTE QUOI https://www.youtube.com/watch?v=e5kDHL-nnh4

    Conférences

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    15 September 2025, 9:24 am
  • 2 hours 24 seconds
    LCC 329 - L'IA, ce super stagiaire qui nous fait travailler plus

    Arnaud et Guillaume explore l'évolution de l'écosystème Java avec Java 25, Spring Boot et Quarkus, ainsi que les dernières tendances en intelligence artificielle avec les nouveaux modèles comme Grok 4 et Claude Code. Les animateurs font également le point sur l'infrastructure cloud, les défis MCP et CLI, tout en discutant de l'impact de l'IA sur la productivité des développeurs et la gestion de la dette technique.

    Enregistré le 8 août 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode–329.mp3 ou en vidéo sur YouTube.

    News Langages

    Java 25: JEP 515 : Profilage de méthode en avance (Ahead-of-Time) https://openjdk.org/jeps/515

    • Le JEP 515 a pour but d'améliorer le temps de démarrage et de chauffe des applications Java.
    • L'idée est de collecter les profils d'exécution des méthodes lors d'une exécution antérieure, puis de les rendre immédiatement disponibles au démarrage de la machine virtuelle.
    • Cela permet au compilateur JIT de générer du code natif dès le début, sans avoir à attendre que l'application soit en cours d'exécution.
    • Ce changement ne nécessite aucune modification du code des applications, des bibliothèques ou des frameworks.
    • L'intégration se fait via les commandes de création de cache AOT existantes.
    • Voir aussi https://openjdk.org/jeps/483 et https://openjdk.org/jeps/514

    Java 25: JEP 518 : Échantillonnage coopératif JFR https://openjdk.org/jeps/518

    • Le JEP 518 a pour objectif d'améliorer la stabilité et l'évolutivité de la fonction JDK Flight Recorder (JFR) pour le profilage d'exécution.
    • Le mécanisme d'échantillonnage des piles d'appels de threads Java est retravaillé pour s'exécuter uniquement à des safepoints, ce qui réduit les risques d'instabilité.
    • Le nouveau modèle permet un parcours de pile plus sûr, notamment avec le garbage collector ZGC, et un échantillonnage plus efficace qui prend en charge le parcours de pile concurrent.
    • Le JEP ajoute un nouvel événement, SafepointLatency, qui enregistre le temps nécessaire à un thread pour atteindre un safepoint.
    • L'approche rend le processus d'échantillonnage plus léger et plus rapide, car le travail de création de traces de pile est délégué au thread cible lui-même.
    Librairies

    Spring Boot 4 M1 https://spring.io/blog/2025/07/24/spring-boot–4–0–0-M1-available-now

    • Spring Boot 4.0.0-M1 met à jour de nombreuses dépendances internes et externes pour améliorer la stabilité et la compatibilité.
    • Les types annotés avec @ConfigurationProperties peuvent maintenant référencer des types situés dans des modules externes grâce à @ConfigurationPropertiesSource.
    • Le support de l'information sur la validité des certificats SSL a été simplifié, supprimant l'état WILL_EXPIRE_SOON au profit de VALID.
    • L'auto-configuration des métriques Micrometer supporte désormais l'annotation @MeterTag sur les méthodes annotées @Counted et @Timed, avec évaluation via SpEL.
    • Le support de @ServiceConnection pour MongoDB inclut désormais l'intégration avec MongoDBAtlasLocalContainer de Testcontainers.
    • Certaines fonctionnalités et API ont été dépréciées, avec des recommandations pour migrer les points de terminaison personnalisés vers les versions Spring Boot 2.
    • Les versions milestones et release candidates sont maintenant publiées sur Maven Central, en plus du repository Spring traditionnel.
    • Un guide de migration a été publié pour faciliter la transition depuis Spring Boot 3.5 vers la version 4.0.0-M1.

    Passage de Spring Boot à Quarkus : retour d'expérience https://blog.stackademic.com/we-switched-from-spring-boot-to-quarkus-heres-the-ugly-truth-c8a91c2b8c53

    • Une équipe a migré une application Java de Spring Boot vers Quarkus pour gagner en performances et réduire la consommation mémoire.
    • L'objectif était aussi d'optimiser l'application pour le cloud natif.
    • La migration a été plus complexe que prévu, notamment à cause de l'incompatibilité avec certaines bibliothèques et d'un écosystème Quarkus moins mature.
    • Il a fallu revoir du code et abandonner certaines fonctionnalités spécifiques à Spring Boot.
    • Les gains en performances et en mémoire sont réels, mais la migration demande un vrai effort d'adaptation.
    • La communauté Quarkus progresse, mais le support reste limité comparé à Spring Boot.
    • Conclusion : Quarkus est intéressant pour les nouveaux projets ou ceux prêts à être réécrits, mais la migration d'un projet existant est un vrai défi.

    LangChain4j 1.2.0 : Nouvelles fonctionnalités et améliorations https://github.com/langchain4j/langchain4j/releases/tag/1.2.0

    • Modules stables : Les modules langchain4j-anthropic, langchain4j-azure-open-ai, langchain4j-bedrock, langchain4j-google-ai-gemini, langchain4j-mistral-ai et langchain4j-ollama sont désormais en version stable 1.2.0.
    • Modules expérimentaux : La plupart des autres modules de LangChain4j sont en version 1.2.0-beta8 et restent expérimentaux/instables.
    • BOM mis à jour : Le langchain4j-bom a été mis à jour en version 1.2.0, incluant les dernières versions de tous les modules.
    • Principales améliorations :
    • Support du raisonnement/pensée dans les modèles.
    • Appels d'outils partiels en streaming.
    • Option MCP pour exposer automatiquement les ressources en tant qu'outils.
    • OpenAI : possibilité de définir des paramètres de requête personnalisés et d'accéder aux réponses HTTP brutes et aux événements SSE.
    • Améliorations de la gestion des erreurs et de la documentation.
    • Filtering Metadata Infinispan ! (cc Katia(
    • Et 1.3.0 est déjà disponible https://github.com/langchain4j/langchain4j/releases/tag/1.3.0
    • 2 nouveaux modules expérimentaux, langchain4j-agentic et langchain4j-agentic-a2a qui introduisent un ensemble d'abstractions et d'utilitaires pour construire des applications agentiques
    Infrastructure

    Cette fois c'est vraiment l'année de Linux sur le desktop ! https://www.lesnumeriques.com/informatique/c-est-enfin-arrive-linux-depasse-un-seuil-historique-que-microsoft-pensait-intouchable-n239977.html

    • Linux a franchi la barre des 5% aux USA
    • Cette progression s'explique en grande partie par l'essor des systèmes basés sur Linux dans les environnements professionnels, les serveurs, et certains usages grand public.
    • Microsoft, longtemps dominant avec Windows, voyait ce seuil comme difficilement atteignable à court terme.
    • Le succès de Linux est également alimenté par la popularité croissante des distributions open source, plus légères, personnalisables et adaptées à des usages variés.
    • Le cloud, l'IoT, et les infrastructures de serveurs utilisent massivement Linux, ce qui contribue à cette augmentation globale.
    • Ce basculement symbolique marque un changement d'équilibre dans l'écosystème des systèmes d'exploitation.
    • Toutefois, Windows conserve encore une forte présence dans certains segments, notamment chez les particuliers et dans les entreprises classiques.
    • Cette évolution témoigne du dynamisme et de la maturité croissante des solutions Linux, devenues des alternatives crédibles et robustes face aux offres propriétaires.
    Cloud

    Cloudflare 1.1.1.1 s'en va pendant une heure d'internet https://blog.cloudflare.com/cloudflare–1–1–1–1-incident-on-july–14–2025/

    • Le 14 juillet 2025, le service DNS public Cloudflare 1.1.1.1 a subi une panne majeure de 62 minutes, rendant le service indisponible pour la majorité des utilisateurs mondiaux.
    • Cette panne a aussi causé une dégradation intermittente du service Gateway DNS.
    • L'incident est survenu suite à une mise à jour de la topologie des services Cloudflare qui a activé une erreur de configuration introduite en juin 2025.
    • Cette erreur faisait que les préfixes destinés au service 1.1.1.1 ont été accidentellement inclus dans un nouveau service de localisation des données (Data Localization Suite), ce qui a perturbé le routage anycast.
    • Le résultat a été une incapacité pour les utilisateurs à résoudre les noms de domaine via 1.1.1.1, rendant la plupart des services Internet inaccessibles pour eux.
    • Ce n'était pas le résultat d'une attaque ou d'un problème BGP, mais une erreur interne de configuration.
    • Cloudflare a rapidement identifié la cause, corrigé la configuration et mis en place des mesures pour prévenir ce type d'incident à l'avenir.
    • Le service est revenu à la normale après environ une heure d'indisponibilité.
    • L'incident souligne la complexité et la sensibilité des infrastructures anycast et la nécessité d'une gestion rigoureuse des configurations réseau.
    Web

    L'évolution des bonnes pratiques de Node.js https://kashw1n.com/blog/nodejs–2025/

    • Évolution de Node.js en 2025 : Le développement se tourne vers les standards du web, avec moins de dépendances externes et une meilleure expérience pour les développeurs.
    • ES Modules (ESM) par défaut : Remplacement de CommonJS pour un meilleur outillage et une standardisation avec le web. Utilisation du préfixe node: pour les modules natifs afin d'éviter les conflits.
    • API web intégrées : fetch, AbortController, et AbortSignal sont maintenant natifs, réduisant le besoin de librairies comme axios.
    • Runner de test intégré : Plus besoin de Jest ou Mocha pour la plupart des cas. Inclut un mode "watch" et des rapports de couverture.
    • Patterns asynchrones avancés : Utilisation plus poussée de async/await avec Promise.all() pour le parallélisme et les AsyncIterators pour les flux d'événements.
    • Worker Threads pour le parallélisme : Pour les tâches lourdes en CPU, évitant de bloquer l'event loop principal.
    • Expérience de développement améliorée : Intégration du mode --watch (remplace nodemon) et du support --env-file (remplace dotenv).
    • Sécurité et performance : Modèle de permission expérimental pour restreindre l'accès et des hooks de performance natifs pour le monitoring.
    • Distribution simplifiée : Création d'exécutables uniques pour faciliter le déploiement d'applications ou d'outils en ligne de commande.

    Sortie de Apache EChart 6 après 12 ans ! https://echarts.apache.org/handbook/en/basics/release-note/v6-feature/

    • Apache ECharts 6.0 : Sortie officielle après 12 ans d'évolution.
    • 12 mises à niveau majeures pour la visualisation de données.
    • Trois dimensions clés d'amélioration :
    • Présentation visuelle plus professionnelle :
    • Nouveau thème par défaut (design moderne).
    • Changement dynamique de thème.
    • Prise en charge du mode sombre.
    • Extension des limites de l'expression des données :
    • Nouveaux types de graphiques : Diagramme de cordes (Chord Chart), Nuage de points en essaim (Beeswarm Chart).
    • Nouvelles fonctionnalités : Jittering pour nuages de points denses, Axes coupés (Broken Axis).
    • Graphiques boursiers améliorés
    • Liberté de composition :
    • Nouveau système de coordonnées matriciel.
    • Séries personnalisées améliorées (réutilisation du code, publication npm).
    • Nouveaux graphiques personnalisés inclus (violon, contour, etc.).
    • Optimisation de l'agencement des étiquettes d'axe.
    Data et Intelligence Artificielle

    Grok 4 s'est pris pour un nazi à cause des tools https://techcrunch.com/2025/07/15/xai-says-it-has-fixed-grok–4s-problematic-responses/

    • À son lancement, Grok 4 a généré des réponses offensantes, notamment en se surnommant « MechaHitler » et en adoptant des propos antisémites.
    • Ce comportement provenait d'une recherche automatique sur le web qui a mal interprété un mème viral comme une vérité.
    • Grok alignait aussi ses réponses controversées sur les opinions d'Elon Musk et de xAI, ce qui a amplifié les biais.
    • xAI a identifié que ces dérapages étaient dus à une mise à jour interne intégrant des instructions encourageant un humour offensant et un alignement avec Musk.
    • Pour corriger cela, xAI a supprimé le code fautif, remanié les prompts système, et imposé des directives demandant à Grok d'effectuer une analyse indépendante, en utilisant des sources diverses.
    • Grok doit désormais éviter tout biais, ne plus adopter un humour politiquement incorrect, et analyser objectivement les sujets sensibles.
    • xAI a présenté ses excuses, précisant que ces dérapages étaient dus à un problème de prompt et non au modèle lui-même.
    • Cet incident met en lumière les défis persistants d'alignement et de sécurité des modèles d'IA face aux injections indirectes issues du contenu en ligne.
    • La correction n'est pas qu'un simple patch technique, mais un exemple des enjeux éthiques et de responsabilité majeurs dans le déploiement d'IA à grande échelle.

    Guillaume a sorti toute une série d'article sur les patterns agentiques avec le framework ADK pour Java https://glaforge.dev/posts/2025/07/29/mastering-agentic-workflows-with-adk-the-recap/

    6 semaines de code avec Claude https://blog.puzzmo.com/posts/2025/07/30/six-weeks-of-claude-code/

    • Orta partage son retour après 6 semaines d'utilisation quotidienne de Claude Code, qui a profondément changé sa manière de coder.
    • Il ne « code » plus vraiment ligne par ligne, mais décrit ce qu'il veut, laisse Claude proposer une solution, puis corrige ou ajuste.
    • Cela permet de se concentrer sur le résultat plutôt que sur l'implémentation, comme passer de la peinture au polaroid.
    • Claude s'avère particulièrement utile pour les tâches de maintenance : migrations, refactors, nettoyage de code.
    • Il reste toujours en contrôle, révise chaque diff généré, et guide l'IA via des prompts bien cadrés.
    • Il note qu'il faut quelques semaines pour prendre le bon pli : apprendre à découper les tâches et formuler clairement les attentes.
    • Les tâches simples deviennent quasi instantanées, mais les tâches complexes nécessitent encore de l'expérience et du discernement.
    • Claude Code est vu comme un très bon copilote, mais ne remplace pas le rôle du développeur qui comprend l'ensemble du système.
    • Le gain principal est une vitesse de feedback plus rapide et une boucle d'itération beaucoup plus courte.
    • Ce type d'outil pourrait bien redéfinir la manière dont on pense et structure le développement logiciel à moyen terme.

    Claude Code et les serveurs MCP : ou comment transformer ton terminal en assistant surpuissant https://touilleur-express.fr/2025/07/27/claude-code-et-les-serveurs-mcp-ou-comment-transformer-ton-terminal-en-assistant-surpuissant/

    • Nicolas continue ses études sur Claude Code et explique comment utiliser les serveurs MCP pour rendre Claude bien plus efficace.
    • Le MCP Context7 montre comment fournir à l'IA la doc technique à jour (par exemple, Next.js 15) pour éviter les hallucinations ou les erreurs.
    • Le MCP Task Master, autre serveur MCP, transforme un cahier des charges (PRD) en tâches atomiques, estimées, et organisées sous forme de plan de travail.
    • Le MCP Playwright permet de manipuler des navigateurs et d'executer des tests E2E
    • Le MCP Digital Ocean permet de déployer facilement l'application en production
    • Tout n'est pas si ideal, les quotas sont atteints en quelques heures sur une petite application et il y a des cas où il reste bien plus efficace de le faire soit-même (pour un codeur expérimenté)
    • Nicolas complète cet article avec l'écriture d'un MVP en 20 heures: https://touilleur-express.fr/2025/07/30/comment-jai-code-un-mvp-en-une-vingtaine-dheures-avec-claude-code/

    Le développement augmenté, un avis politiquement correct, mais bon… https://touilleur-express.fr/2025/07/31/le-developpement-augmente-un-avis-politiquement-correct-mais-bon/

    • Nicolas partage un avis nuancé (et un peu provoquant) sur le développement augmenté, où l'IA comme Claude Code assiste le développeur sans le remplacer.
    • Il rejette l'idée que cela serait « trop magique » ou « trop facile » : c'est une évolution logique de notre métier, pas un raccourci pour les paresseux.
    • Pour lui, un bon dev reste celui qui structure bien sa pensée, sait poser un problème, découper, valider — même si l'IA aide à coder plus vite.
    • Il raconte avoir codé une app OAuth, testée, stylisée et déployée en quelques heures, sans jamais quitter le terminal grâce à Claude.
    • Ce genre d'outillage change le rapport au temps : on passe de « je vais y réfléchir » à « je tente tout de suite une version qui marche à peu près ».
    • Il assume aimer cette approche rapide et imparfaite : mieux vaut une version brute livrée vite qu'un projet bloqué par le perfectionnisme.
    • L'IA est selon lui un super stagiaire : jamais fatigué, parfois à côté de la plaque, mais diablement productif quand bien briefé.
    • Il conclut que le « dev augmenté » ne remplace pas les bons développeurs… mais les développeurs moyens doivent s'y mettre, sous peine d'être dépassés.

    ChatGPT lance le mode d'étude : un apprentissage interactif pas à pas https://openai.com/index/chatgpt-study-mode/

    • OpenAI propose un mode d'étude dans ChatGPT qui guide les utilisateurs pas à pas plutôt que de donner directement la réponse.
    • Ce mode vise à encourager la réflexion active et l'apprentissage en profondeur.
    • Il utilise des instructions personnalisées pour poser des questions et fournir des explications adaptées au niveau de l'utilisateur.
    • Le mode d'étude favorise la gestion de la charge cognitive et stimule la métacognition.
    • Il propose des réponses structurées pour faciliter la compréhension progressive des sujets.
    • Disponible dès maintenant pour les utilisateurs connectés, ce mode sera intégré dans ChatGPT Edu.
    • L'objectif est de transformer ChatGPT en un véritable tuteur numérique, aidant les étudiants à mieux assimiler les connaissances.
    • A priori Gemini viendrait de sortir un fonctionnalité similaire

    Lancement de GPT-OSS par OpenAI https://openai.com/index/introducing-gpt-oss/ https://openai.com/index/gpt-oss-model-card/

    • OpenAI a lancé GPT-OSS, sa première famille de modèles open-weight depuis GPT–2.
    • Deux modèles sont disponibles : gpt-oss–120b et gpt-oss–20b, qui sont des modèles mixtes d'experts conçus pour le raisonnement et les tâches d'agent.
    • Les modèles sont distribués sous licence Apache 2.0, permettant leur utilisation et leur personnalisation gratuites, y compris pour des applications commerciales.
    • Le modèle gpt-oss–120b est capable de performances proches du modèle OpenAI o4-mini, tandis que le gpt-oss–20b est comparable au o3-mini.
    • OpenAI a également open-sourcé un outil de rendu appelé Harmony en Python et Rust pour en faciliter l'adoption.
    • Les modèles sont optimisés pour fonctionner localement et sont pris en charge par des plateformes comme Hugging Face et Ollama.
    • OpenAI a mené des recherches sur la sécurité pour s'assurer que les modèles ne pouvaient pas être affinés pour des utilisations malveillantes dans les domaines biologique, chimique ou cybernétique.

    Anthropic lance Opus 4.1 https://www.anthropic.com/news/claude-opus–4–1

    • Anthropic a publié Claude Opus 4.1, une mise à jour de son modèle de langage.
    • Cette nouvelle version met l'accent sur l'amélioration des performances en codage, en raisonnement et sur les tâches de recherche et d'analyse de données.
    • Le modèle a obtenu un score de 74,5 % sur le benchmark SWE-bench Verified, ce qui représente une amélioration par rapport à la version précédente.
    • Il excelle notamment dans la refactorisation de code multifichier et est capable d'effectuer des recherches approfondies.
    • Claude Opus 4.1 est disponible pour les utilisateurs payants de Claude, ainsi que via l'API, Amazon Bedrock et Vertex AI de Google Cloud, avec des tarifs identiques à ceux d'Opus 4.
    • Il est présenté comme un remplacement direct de Claude Opus 4, avec des performances et une précision supérieures pour les tâches de programmation réelles.

    OpenAI Summer Update. GPT–5 is out https://openai.com/index/introducing-gpt–5/

    • Détails
    • https://openai.com/index/gpt–5-new-era-of-work/
    • https://openai.com/index/introducing-gpt–5-for-developers/
    • https://openai.com/index/gpt–5-safe-completions/
    • https://openai.com/index/gpt–5-system-card/
    • Amélioration majeure des capacités cognitives - GPT‑5 montre un niveau de raisonnement, d'abstraction et de compréhension nettement supérieur aux modèles précédents.
    • Deux variantes principales - gpt-5-main : rapide, efficace pour les tâches générales. gpt-5-thinking : plus lent mais spécialisé dans les tâches complexes, nécessitant réflexion profonde.
    • Routeur intelligent intégré - Le système sélectionne automatiquement la version la plus adaptée à la tâche (rapide ou réfléchie), sans intervention de l'utilisateur.
    • Fenêtre de contexte encore étendue - GPT‑5 peut traiter des volumes de texte plus longs (jusqu'à 1 million de tokens dans certaines versions), utile pour des documents ou projets entiers.
    • Réduction significative des hallucinations - GPT‑5 donne des réponses plus fiables, avec moins d'erreurs inventées ou de fausses affirmations.
    • Comportement plus neutre et moins sycophant - Il a été entraîné pour mieux résister à l'alignement excessif avec les opinions de l'utilisateur.
    • Capacité accrue à suivre des instructions complexes - GPT‑5 comprend mieux les consignes longues, implicites ou nuancées.
    • Approche "Safe completions" - Remplacement des "refus d'exécution" par des réponses utiles mais sûres — le modèle essaie de répondre avec prudence plutôt que bloquer.
    • Prêt pour un usage professionnel à grande échelle - Optimisé pour le travail en entreprise : rédaction, programmation, synthèse, automatisation, gestion de tâches, etc.
    • Améliorations spécifiques pour le codage - GPT‑5 est plus performant pour l'écriture de code, la compréhension de contextes logiciels complexes, et l'usage d'outils de développement.
    • Expérience utilisateur plus rapide et fluide- Le système réagit plus vite grâce à une orchestration optimisée entre les différents sous-modèles.
    • Capacités agentiques renforcées - GPT‑5 peut être utilisé comme base pour des agents autonomes capables d'accomplir des objectifs avec peu d'interventions humaines.
    • Multimodalité maîtrisée (texte, image, audio) - GPT‑5 intègre de façon plus fluide la compréhension de formats multiples, dans un seul modèle.
    • Fonctionnalités pensées pour les développeurs - Documentation plus claire, API unifiée, modèles plus transparents et personnalisables.
    • Personnalisation contextuelle accrue - Le système s'adapte mieux au style, ton ou préférences de l'utilisateur, sans instructions répétées.
    • Utilisation énergétique et matérielle optimisée - Grâce au routeur interne, les ressources sont utilisées plus efficacement selon la complexité des tâches.
    • Intégration sécurisée dans les produits ChatGPT - Déjà déployé dans ChatGPT avec des bénéfices immédiats pour les utilisateurs Pro et entreprises.
    • Modèle unifié pour tous les usages - Un seul système capable de passer de la conversation légère à des analyses scientifiques ou du code complexe.
    • Priorité à la sécurité et à l'alignement - GPT‑5 a été conçu dès le départ pour minimiser les abus, biais ou comportements indésirables.
    • Pas encore une AGI - OpenAI insiste : malgré ses capacités impressionnantes, GPT‑5 n'est pas une intelligence artificielle générale.

    Non, non, les juniors ne sont pas obsolètes malgré l'IA ! (dixit GitHub) https://github.blog/ai-and-ml/generative-ai/junior-developers-arent-obsolete-heres-how-to-thrive-in-the-age-of-ai/

    • L'IA transforme le développement logiciel, mais les développeurs juniors ne sont pas obsolètes.
    • Les nouveaux apprenants sont bien positionnés, car déjà familiers avec les outils IA.
    • L'objectif est de développer des compétences pour travailler avec l'IA, pas d'être remplacé.
    • La créativité et la curiosité sont des qualités humaines clés.
    • Cinq façons de se démarquer :
    • Utiliser l'IA (ex: GitHub Copilot) pour apprendre plus vite, pas seulement coder plus vite (ex: mode tuteur, désactiver l'autocomplétion temporairement).
    • Construire des projets publics démontrant ses compétences (y compris en IA).
    • Maîtriser les workflows GitHub essentiels (GitHub Actions, contribution open source, pull requests).
    • Affûter son expertise en révisant du code (poser des questions, chercher des patterns, prendre des notes).
    • Déboguer plus intelligemment et rapidement avec l'IA (ex: Copilot Chat pour explications, corrections, tests).

    Ecrire son premier agent IA avec A2A avec WildFly par Emmanuel Hugonnet https://www.wildfly.org/news/2025/08/07/Building-your-First-A2A-Agent/

    • Protocole Agent2Agent (A2A) : Standard ouvert pour l'interopérabilité universelle des agents IA.
    • Permet communication et collaboration efficaces entre agents de différents fournisseurs/frameworks.
    • Crée des écosystèmes multi-agents unifiés, automatisant les workflows complexes.
    • Objet de l'article : Guide pour construire un premier agent A2A (agent météo) dans WildFly.
    • Utilise A2A Java SDK pour Jakarta Servers, WildFly AI Feature Pack, un LLM (Gemini) et un outil Python (MCP).
    • Agent conforme A2A v0.2.5.
    • Prérequis : JDK 17+, Apache Maven 3.8+, IDE Java, Google AI Studio API Key, Python 3.10+, uv.
    • Étapes de construction de l'agent météo :
    • Création du service LLM : Interface Java (WeatherAgent) utilisant LangChain4J pour interagir avec un LLM et un outil Python MCP (fonctions get_alerts, get_forecast).
    • Définition de l'agent A2A (via CDI) :
    • ▪︎ Agent Card : Fournit les métadonnées de l'agent (nom, description, URL, capacités, compétences comme "weather_search").
    • Agent Executor : Gère les requêtes A2A entrantes, extrait le message utilisateur, appelle le service LLM et formate la réponse.
    • Exposition de l'agent : Enregistrement d'une application JAX-RS pour les endpoints.
    • Déploiement et test :
    • Configuration de l'outil A2A-inspector de Google (via un conteneur Podman).
    • Construction du projet Maven, configuration des variables d'environnement (ex: GEMINI_API_KEY).
    • Lancement du serveur WildFly.
    • Conclusion : Transformation minimale d'une application IA en agent A2A.
    • Permet la collaboration et le partage d'informations entre agents IA, indépendamment de leur infrastructure sous-jacente.
    Outillage

    IntelliJ IDEa bouge vers une distribution unifiée https://blog.jetbrains.com/idea/2025/07/intellij-idea-unified-distribution-plan/

    • À partir de la version 2025.3, IntelliJ IDEA Community Edition ne sera plus distribuée séparément.
    • Une seule version unifiée d'IntelliJ IDEA regroupera les fonctionnalités des éditions Community et Ultimate.
    • Les fonctionnalités avancées de l'édition Ultimate seront accessibles via abonnement.
    • Les utilisateurs sans abonnement auront accès à une version gratuite enrichie par rapport à l'édition Community actuelle.
    • Cette unification vise à simplifier l'expérience utilisateur et réduire les différences entre les éditions.
    • Les utilisateurs Community seront automatiquement migrés vers cette nouvelle version unifiée.
    • Il sera possible d'activer les fonctionnalités Ultimate temporairement d'un simple clic.
    • En cas d'expiration d'abonnement Ultimate, l'utilisateur pourra continuer à utiliser la version installée avec un jeu limité de fonctionnalités gratuites, sans interruption.
    • Ce changement reflète l'engagement de JetBrains envers l'open source et l'adaptation aux besoins de la communauté.

    Prise en charge des Ancres YAML dans GitHub Actions https://github.com/actions/runner/issues/1182#issuecomment–3150797791

    • Afin d'éviter de dupliquer du contenu dans un workflow les Ancres permettent d'insérer des morceaux réutilisables de YAML
    • Fonctionnalité attendue depuis des années et disponible chez GitLab depuis bien longtemps. Elle a été déployée le 4 aout.
    • Attention à ne pas en abuser car la lisibilité de tels documents n'est pas si facile

    Gemini CLI rajoute les custom commands comme Claude https://cloud.google.com/blog/topics/developers-practitioners/gemini-cli-custom-slash-commands

    • Mais elles sont au format TOML, on ne peut donc pas les partager avec Claude :disappointed:

    Automatiser ses workflows IA avec les hooks de Claude Code https://blog.gitbutler.com/automate-your-ai-workflows-with-claude-code-hooks/

    • Claude Code propose des hooks qui permettent d'exécuter des scripts à différents moments d'une session, par exemple au début, lors de l'utilisation d'outils, ou à la fin.
    • Ces hooks facilitent l'automatisation de tâches comme la gestion de branches Git, l'envoi de notifications, ou l'intégration avec d'autres outils.
    • Un exemple simple est l'envoi d'une notification sur le bureau à la fin d'une session.
    • Les hooks se configurent via trois fichiers JSON distincts selon le scope : utilisateur, projet ou local.
    • Sur macOS, l'envoi de notifications nécessite une permission spécifique via l'application "Script Editor".
    • Il est important d'avoir une version à jour de Claude Code pour utiliser ces hooks.
    • GitButler permet desormais de s'intégrer à Claude Code via ces hooks: https://blog.gitbutler.com/parallel-claude-code/

    Le client Git de Jetbrains bientot en standalone https://lp.jetbrains.com/closed-preview-for-jetbrains-git-client/

    • Demandé par certains utilisateurs depuis longtemps
    • Ca serait un client graphique du même style qu'un GitButler, SourceTree, etc

    Apache Maven 4 …. arrive …. l'utilitaire mvnupva vous aider à upgrader https://maven.apache.org/tools/mvnup.html

    • Fixe les incompatibilités connues
    • Nettoie les redondances et valeurs par defaut (versions par ex) non utiles pour Maven 4
    • Reformattage selon les conventions maven
    • …

    Une GitHub Action pour Gemini CLI https://blog.google/technology/developers/introducing-gemini-cli-github-actions/

    • Google a lancé Gemini CLI GitHub Actions, un agent d'IA qui fonctionne comme un "coéquipier de code" pour les dépôts GitHub.
    • L'outil est gratuit et est conçu pour automatiser des tâches de routine telles que le triage des problèmes (issues), l'examen des demandes de tirage (pull requests) et d'autres tâches de développement.
    • Il agit à la fois comme un agent autonome et un collaborateur que les développeurs peuvent solliciter à la demande, notamment en le mentionnant dans une issue ou une pull request.
    • L'outil est basé sur la CLI Gemini, un agent d'IA open-source qui amène le modèle Gemini directement dans le terminal.
    • Il utilise l'infrastructure GitHub Actions, ce qui permet d'isoler les processus dans des conteneurs séparés pour des raisons de sécurité.
    • Trois flux de travail (workflows) open-source sont disponibles au lancement : le triage intelligent des issues, l'examen des pull requests et la collaboration à la demande.

    Pas besoin de MCP, le code est tout ce dont vous avez besoin https://lucumr.pocoo.org/2025/7/3/tools/

    • Armin souligne qu'il n'est pas fan du protocole MCP (Model Context Protocol) dans sa forme actuelle : il manque de composabilité et exige trop de contexte.
    • Il remarque que pour une même tâche (ex. GitHub), utiliser le CLI est souvent plus rapide et plus efficace en termes de contexte que passer par un serveur MCP.
    • Selon lui, le code reste la solution la plus simple et fiable, surtout pour automatiser des tâches répétitives.
    • Il préfère créer des scripts clairs plutôt que se reposer sur l'inférence LLM : cela facilite la vérification, la maintenance et évite les erreurs subtiles.
    • Pour les tâches récurrentes, si on les automatise, mieux vaut le faire avec du code reusable, plutôt que de laisser l'IA deviner à chaque fois.
    • Il illustre cela en convertissant son blog entier de reStructuredText à Markdown : plutôt qu'un usage direct d'IA, il a demandé à Claude de générer un script complet, avec parsing AST, comparaison des fichiers, validation et itération.
    • Ce workflow LLM→code→LLM (analyse et validation) lui a donné confiance dans le résultat final, tout en conservant un contrôle humain sur le processus.
    • Il juge que MCP ne permet pas ce type de pipeline automatisé fiable, car il introduit trop d'inférence et trop de variations par appel.
    • Pour lui, coder reste le meilleur moyen de garder le contrôle, la reproductibilité et la clarté dans les workflows automatisés.

    MCP vs CLI … https://www.async-let.com/blog/my-take-on-the-mcp-verses-cli-debate/

    • Cameron raconte son expérience de création du serveur XcodeBuildMCP, qui lui a permis de mieux comprendre le débat entre servir l'IA via MCP ou laisser l'IA utiliser directement les CLI du système.
    • Selon lui, les CLIs restent préférables pour les développeurs experts recherchant contrôle, transparence, performance et simplicité.
    • Mais les serveurs MCP excellent sur les workflows complexes, les contextes persistants, les contraintes de sécurité, et facilitent l'accès pour les utilisateurs moins expérimentés.
    • Il reconnaît la critique selon laquelle MCP consomme trop de contexte (« context bloat ») et que les appels CLI peuvent être plus rapides et compréhensibles.
    • Toutefois, il souligne que beaucoup de problèmes proviennent de la qualité des implémentations clients, pas du protocole MCP en lui‑même.
    • Pour lui, un bon serveur MCP peut proposer des outils soigneusement définis qui simplifient la vie de l'IA (par exemple, renvoyer des données structurées plutôt que du texte brut à parser).
    • Il apprécie la capacité des MCP à offrir des opérations état‑durables (sessions, mémoire, logs capturés), ce que les CLI ne gèrent pas naturellement.
    • Certains scénarios ne peuvent pas fonctionner via CLI (pas de shell accessible) alors que MCP, en tant que protocole indépendant, reste utilisable par n'importe quel client.
    • Son verdict : pas de solution universelle — chaque contexte mérite d'être évalué, et on ne devrait pas imposer MCP ou CLI à tout prix.

    Jules, l'agent de code asynchrone gratuit de Google, est sorti de beta et est disponible pour tout le monde https://blog.google/technology/google-labs/jules-now-available/

    • Jules, agent de codage asynchrone, est maintenant publiquement disponible.
    • Propulsé par Gemini 2.5 Pro.
    • Phase bêta : 140 000+ améliorations de code et retours de milliers de développeurs.
    • Améliorations : interface utilisateur, corrections de bugs, réutilisation des configurations, intégration GitHub Issues, support multimodal.
    • Gemini 2.5 Pro améliore les plans de codage et la qualité du code.
    • Nouveaux paliers structurés : Introductif, Google AI Pro (limites 5x supérieures), Google AI Ultra (limites 20x supérieures).
    • Déploiement immédiat pour les abonnés Google AI Pro et Ultra, incluant les étudiants éligibles (un an gratuit de AI Pro).
    Architecture

    Valoriser la réduction de la dette technique : un vrai défi https://www.lemondeinformatique.fr/actualites/lire-valoriser-la-reduction-de-la-dette-technique-mission-impossible–97483.html

    • La dette technique est un concept mal compris et difficile à valoriser financièrement auprès des directions générales.
    • Les DSI ont du mal à mesurer précisément cette dette, à allouer des budgets spécifiques, et à prouver un retour sur investissement clair.
    • Cette difficulté limite la priorisation des projets de réduction de dette technique face à d'autres initiatives jugées plus urgentes ou stratégiques.
    • Certaines entreprises intègrent progressivement la gestion de la dette technique dans leurs processus de développement.
    • Des approches comme le Software Crafting visent à améliorer la qualité du code pour limiter l'accumulation de cette dette.
    • L'absence d'outils adaptés pour mesurer les progrès rend la démarche encore plus complexe.
    • En résumé, réduire la dette technique reste une mission délicate qui nécessite innovation, méthode et sensibilisation en interne.

    Il ne faut pas se Mocker … https://martinelli.ch/why-i-dont-use-mocking-frameworks-and-why-you-might-not-need-them-either/ https://blog.tremblay.pro/2025/08/not-using-mocking-frmk.html

    • L'auteur préfère utiliser des fakes ou stubs faits à la main plutôt que des frameworks de mocking comme Mockito ou EasyMock.
    • Les frameworks de mocking isolent le code, mais entraînent souvent :
    • Un fort couplage entre les tests et les détails d'implémentation.
    • Des tests qui valident le mock plutôt que le comportement réel.
    • Deux principes fondamentaux guident son approche :
    • Favoriser un design fonctionnel, avec logique métier pure (fonctions sans effets de bord).
    • Contrôler les données de test : par exemple en utilisant des bases réelles (via Testcontainers) plutôt que de simuler.
    • Dans sa pratique, les seuls cas où un mock externe est utilisé concernent les services HTTP externes, et encore il préfère en simuler seulement le transport plutôt que le comportement métier.
    • Résultat : les tests deviennent plus simples, plus rapides à écrire, plus fiables, et moins fragiles aux évolutions du code.
    • L'article conclut que si tu conçois correctement ton code, tu pourrais très bien ne pas avoir besoin de frameworks de mocking du tout.
    • Le blog en réponse d'Henri Tremblay nuance un peu ces retours
    Méthodologies

    C'est quoi être un bon PM ? (Product Manager) Article de Chris Perry, un PM chez Google : https://thechrisperry.substack.com/p/being-a-good-pm-at-google

    • Le rôle de PM est difficile : Un travail exigeant, où il faut être le plus impliqué de l'équipe pour assurer le succès.
    • 1. Livrer (shipper) est tout ce qui compte : La priorité absolue. Mieux vaut livrer et itérer rapidement que de chercher la perfection en théorie. Un produit livré permet d'apprendre de la réalité.
    • 2. Donner l'envie du grand large : La meilleure façon de faire avancer un projet est d'inspirer l'équipe avec une vision forte et désirable. Montrer le "pourquoi".
    • 3. Utiliser son produit tous les jours : Non négociable pour réussir. Permet de développer une intuition et de repérer les vrais problèmes que la recherche utilisateur ne montre pas toujours.
    • 4. Être un bon ami : Créer des relations authentiques et aider les autres est un facteur clé de succès à long terme. La confiance est la base d'une exécution rapide.
    • 5. Donner plus qu'on ne reçoit : Toujours chercher à aider et à collaborer. La stratégie optimale sur la durée est la coopération. Ne pas être possessif avec ses idées.
    • 6. Utiliser le bon levier : Pour obtenir une décision, il faut identifier la bonne personne qui a le pouvoir de dire "oui", et ne pas se laisser bloquer par des avis non décisionnaires.
    • 7. N'aller que là où on apporte de la valeur : Combler les manques, faire le travail ingrat que personne ne veut faire. Savoir aussi s'écarter (réunions, projets) quand on n'est pas utile.
    • 8. Le succès a plusieurs parents, l'échec est orphelin : Si le produit réussit, c'est un succès d'équipe. S'il échoue, c'est la faute du PM. Il faut assumer la responsabilité finale.
    • Conclusion : Le PM est un chef d'orchestre. Il ne peut pas jouer de tous les instruments, mais son rôle est d'orchestrer avec humilité le travail de tous pour créer quelque chose d'harmonieux.

    Tester des applications Spring Boot prêtes pour la production : points clés https://www.wimdeblauwe.com/blog/2025/07/30/how-i-test-production-ready-spring-boot-applications/

    • L'auteur (Wim Deblauwe) détaille comment il structure ses tests dans une application Spring Boot destinée à la production.
    • Le projet inclut automatiquement la dépendance spring-boot-starter-test, qui regroupe JUnit 5, AssertJ, Mockito, Awaitility, JsonAssert, XmlUnit et les outils de testing Spring.
    • Tests unitaires : ciblent les fonctions pures (record, utilitaire), testés simplement avec JUnit et AssertJ sans démarrage du contexte Spring.
    • Tests de cas d'usage (use case) : orchestrent la logique métier, généralement via des use cases qui utilisent un ou plusieurs dépôts de données.
    • Tests JPA/repository : vérifient les interactions avec la base via des tests realisant des opérations CRUD (avec un contexte Spring pour la couche persistance).
    • Tests de contrôleur : permettent de tester les endpoints web (ex. @WebMvcTest), souvent avec MockBean pour simuler les dépendances.
    • Tests d'intégration complets : ils démarrent tout le contexte Spring (@SpringBootTest) pour tester l'application dans son ensemble.
    • L'auteur évoque également des tests d'architecture, mais sans entrer dans le détail dans cet article.
    • Résultat : une pyramide de tests allant des plus rapides (unitaires) aux plus complets (intégration), garantissant fiabilité, vitesse et couverture sans surcharge inutile.
    Sécurité

    Bitwarden offre un serveur MCP pour que les agents puissent accéder aux mots de passe https://nerds.xyz/2025/07/bitwarden-mcp-server-secure-ai/

    • Bitwarden introduit un serveur MCP (Model Context Protocol) destiné à intégrer de manière sécurisée les agents IA dans les workflows de gestion de mots de passe.
    • Ce serveur fonctionne en architecture locale (local-first) : toutes les interactions et les données sensibles restent sur la machine de l'utilisateur, garantissant l'application du principe de chiffrement zero‑knowledge.
    • L'intégration se fait via l'interface CLI de Bitwarden, permettant aux agents IA de générer, récupérer, modifier et verrouiller les identifiants via des commandes sécurisées. Le serveur peut être auto‑hébergé pour un contrôle maximal des données.
    • Le protocole MCP est un standard ouvert qui permet de connecter de façon uniforme des agents IA à des sources de données et outils tiers, simplifiant les intégrations entre LLM et applications.
    • Une démo avec Claude (agent IA d'Anthropic) montre que l'IA peut interagir avec le coffre Bitwarden : vérifier l'état, déverrouiller le vault, générer ou modifier des identifiants, le tout sans intervention humaine directe.
    • Bitwarden affiche une approche priorisant la sécurité, mais reconnaît les risques liés à l'utilisation d'IA autonome. L'usage d'un LLM local privé est fortement recommandé pour limiter les vulnérabilités.
    • Si tu veux, je peux aussi te résumer les enjeux principaux (interopérabilité, sécurité, cas d'usage) ou un extrait spécifique !

    NVIDIA a une faille de securite critique https://www.wiz.io/blog/nvidia-ai-vulnerability-cve–2025–23266-nvidiascape

    • Il s'agit d'une faille d'évasion de conteneur dans le NVIDIA Container Toolkit.
    • La gravité est jugée critique avec un score CVSS de 9.0.
    • Cette vulnérabilité permet à un conteneur malveillant d'obtenir un accès root complet sur l'hôte.
    • L'origine du problème vient d'une mauvaise configuration des hooks OCI dans le toolkit.
    • L'exploitation peut se faire très facilement, par exemple avec un Dockerfile de seulement trois lignes.
    • Le risque principal concerne la compromission de l'isolation entre différents clients sur des infrastructures cloud GPU partagées.
    • Les versions affectées incluent toutes les versions du NVIDIA Container Toolkit jusqu'à la 1.17.7 et du NVIDIA GPU Operator jusqu'à la version 25.3.1.
    • Pour atténuer le risque, il est recommandé de mettre à jour vers les dernières versions corrigées.
    • En attendant, il est possible de désactiver certains hooks problématiques dans la configuration pour limiter l'exposition.
    • Cette faille met en lumière l'importance de renforcer la sécurité des environnements GPU partagés et la gestion des conteneurs AI.

    Fuite de données de l'application Tea : points essentiels https://knowyourmeme.com/memes/events/the-tea-app-data-leak

    • Tea est une application lancée en 2023 qui permet aux femmes de laisser des avis anonymes sur des hommes rencontrés.
    • En juillet 2025, une importante fuite a exposé environ 72 000 images sensibles (selfies, pièces d'identité) et plus d'1,1 million de messages privés.
    • La fuite a été révélée après qu'un utilisateur ait partagé un lien pour télécharger la base de données compromise.
    • Les données touchées concernaient majoritairement des utilisateurs inscrits avant février 2024, date à laquelle l'application a migré vers une infrastructure plus sécurisée.
    • En réponse, Tea prévoit de proposer des services de protection d'identité aux utilisateurs impactés.

    Faille dans le paquet npm is : attaque en chaîne d'approvisionnement https://socket.dev/blog/npm-is-package-hijacked-in-expanding-supply-chain-attack

    • Une campagne de phishing ciblant les mainteneurs npm a compromis plusieurs comptes, incluant celui du paquet is.
    • Des versions compromises du paquet is (notamment les versions 3.3.1 et 5.0.0) contenaient un chargeur de malware JavaScript destiné aux systèmes Windows.
    • Ce malware a offert aux attaquants un accès à distance via WebSocket, permettant potentiellement l'exécution de code arbitraire.
    • L'attaque fait suite à d'autres compromissions de paquets populaires comme eslint-config-prettier, eslint-plugin-prettier, synckit, @pkgr/core, napi-postinstall, et got-fetch.
    • Tous ces paquets ont été publiés sans aucun commit ou PR sur leurs dépôts GitHub respectifs, signalant un accès non autorisé aux tokens mainteneurs.
    • Le domaine usurpé [npnjs.com](http://npnjs.com) a été utilisé pour collecter les jetons d'accès via des emails de phishing trompeurs.
    • L'épisode met en lumière la fragilité des chaînes d'approvisionnement logicielle dans l'écosystème npm et la nécessité d'adopter des pratiques renforcées de sécurité autour des dépendances.

    Revues de sécurité automatisées avec Claude Code https://www.anthropic.com/news/automate-security-reviews-with-claude-code

    • Anthropic a lancé des fonctionnalités de sécurité automatisées pour Claude Code, un assistant de codage d'IA en ligne de commande. Ces fonctionnalités ont été introduites en réponse au besoin croissant de maintenir la sécurité du code alors que les outils d'IA accélèrent considérablement le développement de logiciels.
    • Commande /security-review : les développeurs peuvent exécuter cette commande dans leur terminal pour demander à Claude d'identifier les vulnérabilités de sécurité, notamment les risques d'injection SQL, les vulnérabilités de script intersite (XSS), les failles d'authentification et d'autorisation, ainsi que la gestion non sécurisée des données. Claude peut également suggérer et implémenter des correctifs.
    • Intégration GitHub Actions : une nouvelle action GitHub permet à Claude Code d'analyser automatiquement chaque nouvelle demande d'extraction (pull request). L'outil examine les modifications de code pour y trouver des vulnérabilités, applique des règles personnalisables pour filtrer les faux positifs et commente directement la demande d'extraction avec les problèmes détectés et les correctifs recommandés.
    • Ces fonctionnalités sont conçues pour créer un processus d'examen de sécurité cohérent et s'intégrer aux pipelines CI/CD existants, ce qui permet de s'assurer qu'aucun code n'atteint la production sans un examen de sécurité de base.
    Loi, société et organisation

    Google embauche les personnes clés de Windsurf https://www.blog-nouvelles-technologies.fr/333959/openai-windsurf-google-deepmind-codage-agentique/

    • windsurf devait être racheté par OpenAI
    • Google ne fait pas d'offre de rachat mais débauche quelques personnes clés de Windsurf
    • Windsurf reste donc indépendante mais sans certains cerveaux y compris son PDG.
    • Les nouveaux dirigeants sont les ex leaders des force de vente
    • Donc plus une boîte tech
    • Pourquoi le deal a 3 milliard est tombé à l'eau ?
    • On ne sait pas mais la divergence et l'indépendance technologique est possiblement en cause.
    • Les transfuge vont bosser chez Deepmind dans le code argentique

    Opinion Article: https://www.linkedin.com/pulse/dear-people-who-think-ai-low-skilled-code-monkeys-future-jan-moser-svade/

    • Jan Moser critique ceux qui pensent que l'IA et les développeurs peu qualifiés peuvent remplacer les ingénieurs logiciels compétents.
    • Il cite l'exemple de l'application Tea, une plateforme de sécurité pour femmes, qui a exposé 72 000 images d'utilisateurs en raison d'une mauvaise configuration de Firebase et d'un manque de pratiques de développement sécurisées.
    • Il souligne que l'absence de contrôles automatisés et de bonnes pratiques de sécurité a permis cette fuite de données.
    • Moser avertit que des outils comme l'IA ne peuvent pas compenser l'absence de compétences en génie logiciel, notamment en matière de sécurité, de gestion des erreurs et de qualité du code.
    • Il appelle à une reconnaissance de la valeur des ingénieurs logiciels qualifiés et à une approche plus rigoureuse dans le développement logiciel.

    YouTube déploie une technologie d'estimation d'âge pour identifier les adolescents aux États-Unis https://techcrunch.com/2025/07/29/youtube-rolls-out-age-estimatation-tech-to-identify-u-s-teens-and-apply-additional-protections/

    • Sujet très à la mode, surtout au UK mais pas que…
    • YouTube commence à déployer une technologie d'estimation d'âge basée sur l'IA pour identifier les utilisateurs adolescents aux États-Unis, indépendamment de l'âge déclaré lors de l'inscription.
    • Cette technologie analyse divers signaux comportementaux, tels que l'historique de visionnage, les catégories de vidéos consultées et l'âge du compte.
    • Lorsqu'un utilisateur est identifié comme adolescent, YouTube applique des protections supplémentaires, notamment :
    • Désactivation des publicités personnalisées.
    • Activation des outils de bien-être numérique, tels que les rappels de temps d'écran et de coucher.
    • Limitation de la visualisation répétée de contenus sensibles, comme ceux liés à l'image corporelle.
    • Si un utilisateur est incorrectement identifié comme mineur, il peut vérifier son âge via une pièce d'identité gouvernementale, une carte de crédit ou un selfie.
    • Ce déploiement initial concerne un petit groupe d'utilisateurs aux États-Unis et sera étendu progressivement.
    • Cette initiative s'inscrit dans les efforts de YouTube pour renforcer la sécurité des jeunes utilisateurs en ligne.

    Mistral AI : contribution à un standard environnemental pour l'IA https://mistral.ai/news/our-contribution-to-a-global-environmental-standard-for-ai

    • Mistral AI a réalisé la première analyse de cycle de vie complète d'un modèle d'IA, en collaboration avec plusieurs partenaires.
    • L'étude quantifie l'impact environnemental du modèle Mistral Large 2 sur les émissions de gaz à effet de serre, la consommation d'eau, et l'épuisement des ressources.
    • La phase d'entraînement a généré 20,4 kilotonnes de CO₂ équivalent, consommé 281 000 m³ d'eau, et utilisé 660 kg SB-eq (mineral consumption).
    • Pour une réponse de 400 tokens, l'impact marginal est faible mais non négligeable : 1,14 gramme de CO₂, 45 mL d'eau, et 0,16 mg d'équivalent antimoine.
    • Mistral propose trois indicateurs pour évaluer cet impact : l'impact absolu de l'entraînement, l'impact marginal de l'inférence, et le ratio inference/impact total sur le cycle de vie.
    • L'entreprise souligne l'importance de choisir le modèle en fonction du cas d'usage pour limiter l'empreinte environnementale.
    • Mistral appelle à plus de transparence et à l'adoption de standards internationaux pour permettre une comparaison claire entre modèles.

    L'IA promettait plus d'efficacité… elle nous fait surtout travailler plus https://afterburnout.co/p/ai-promised-to-make-us-more-efficient

    • Les outils d'IA devaient automatiser les tâches pénibles et libérer du temps pour les activités stratégiques et créatives. En réalité, le temps gagné est souvent aussitôt réinvesti dans d'autres tâches, créant une surcharge.
    • Les utilisateurs croient être plus productifs avec l'IA, mais les données contredisent cette impression : une étude montre que les développeurs utilisant l'IA prennent 19 % de temps en plus pour accomplir leurs tâches.
    • Le rapport DORA 2024 observe une baisse de performance globale des équipes lorsque l'usage de l'IA augmente : –1,5 % de throughput et –7,2 % de stabilité de livraison pour +25 % d'adoption de l'IA.
    • L'IA ne réduit pas la charge mentale, elle la déplace : rédaction de prompts, vérification de résultats douteux, ajustements constants… Cela épuise et limite le temps de concentration réelle.
    • Cette surcharge cognitive entraîne une forme de dette mentale : on ne gagne pas vraiment du temps, on le paie autrement.
    • Le vrai problème vient de notre culture de la productivité, qui pousse à toujours vouloir optimiser, quitte à alimenter l'épuisement professionnel.
    • Trois pistes concrètes :
    • Repenser la productivité non en temps gagné, mais en énergie préservée.
    • Être sélectif dans l'usage des outils IA, en fonction de son ressenti et non du battage médiatique.
    • Accepter la courbe en J : l'IA peut être utile, mais nécessite des ajustements profonds pour produire des gains réels.
    • Le vrai hack de productivité ? Parfois, ralentir pour rester lucide et durable.
    Conférences

    MCP Submit Europe https://mcpdevsummit.ai/

    Retour de JavaOne en 2026 https://inside.java/2025/08/04/javaone-returns–2026/

    • JavaOne, la conférence dédiée à la communauté Java, fait son grand retour dans la Bay Area du 17 au 19 mars 2026.
    • Après le succès de l'édition 2025, ce retour s'inscrit dans la continuité de la mission initiale de la conférence : rassembler la communauté pour apprendre, collaborer et innover.

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    14 August 2025, 2:49 pm
  • 1 hour 30 minutes
    LCC 328 - Expert généraliste cherche Virtual Thread

    Dans cet épisode, Emmanuel et Antonio discutent de divers sujets liés au développement: Applets (et oui), app iOS développées sous Linux, le protocole A2A, l'accessibilité, les assistants de code AI en ligne de commande (vous n'y échapperez pas)… Mais aussi des approches méthodologiques et architecturales comme l'architecture hexagonale, les tech radars, l'expert généraliste et bien d'autres choses encore.

    Enregistré le 11 juillet 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-328.mp3 ou en vidéo sur YouTube.

    News Langages

    Les Applets Java c'est terminé pour de bon… enfin, bientot:

    https://openjdk.org/jeps/504

    • Les navigateurs web ne supportent plus les applets.
    • L'API Applet et l'outil appletviewer ont été dépréciés dans JDK 9 (2017).
    • L'outil appletviewer a été supprimé dans JDK 11 (2018). Depuis, impossible d'exécuter des applets avec le JDK.
    • L'API Applet a été marquée pour suppression dans JDK 17 (2021).
    • Le Security Manager, essentiel pour exécuter des applets de façon sécurisée, a été désactivé définitivement dans JDK 24 (2025).
    Librairies

    Quarkus 3.24 avec la notion d'extensions qui peuvent fournir des capacités à des assistants https://quarkus.io/blog/quarkus-3-24-released/

    • les assistants typiquement IA, ont accès a des capacités des extensions
    • Par exemple générer un client à partir d'openAPI
    • Offrir un accès à la,base de données en dev via le schéma.

    L'intégration d'Hibernate 7 dans Quarkus https://quarkus.io/blog/hibernate7-on-quarkus/

    • Jakarta data
    • api restriction nouvelle
    • Injection du SchemaManager

    Sortie de Micronaut 4.9 https://micronaut.io/2025/06/30/micronaut-framework-4-9-0-released/

    • Core :
      • Mise à jour vers Netty 4.2.2 (attention, peut affecter les perfs).
      • Nouveau mode expérimental "Event loop Carrier" pour exécuter des virtual threads sur l'event loop Netty.
      • Nouvelle annotation @ClassImport pour traiter des classes déjà compilées.
      • Arrivée des @Mixin (Java uniquement) pour modifier les métadonnées d'annotations Micronaut sans altérer les classes originales.
    • HTTP/3 : Changement de dépendance pour le support expérimental.
    • Graceful Shutdown : Nouvelle API pour un arrêt en douceur des applications.
    • Cache Control : API fluente pour construire facilement l'en-tête HTTP Cache-Control.
    • KSP 2 : Support de KSP 2 (à partir de 2.0.2) et testé avec Kotlin 2.
    • Jakarta Data : Implémentation de la spécification Jakarta Data 1.0.
    • gRPC : Support du JSON pour envoyer des messages sérialisés via un POST HTTP.
    • ProjectGen : Nouveau module expérimental pour générer des projets JVM (Gradle ou Maven) via une API.
    • Un super article sur experimenter avec les event loops reactives dans les virtualthreads https://micronaut.io/2025/06/30/transitioning-to-virtual-threads-using-the-micronaut-loom-carrier/
    • Malheureusement cela demander le hacker le JDK
    • C'est un article de micronaut mais le travail a ete collaboratif avec les equipes de Red Hat OpenJDK, Red Hat perf et de Quarkus et Vert.x
    • Pour les curieux c'est un bon article

    Ubuntu offre un outil de creation de container pour Spring notamment https://canonical.com/blog/spring-boot-containers-made-easy

    • creer des images OCI pour les applications Spring Boot
    • basées sur Ubuntu base images bien sur
    • utilise jlink pour reduire la taille
    • pas sur de voir le gros avantage vs d'autres solutions plus portables
    • d'ailleurs Canonical entre dans la danse des builds d'openjdk

    Le SDK Java de A2A contribué par Red Hat est sorti https://quarkus.io/blog/a2a-project-launches-java-sdk/

    • A2A est un protocole initié par Google et donne à la fondation Linux
    • Il permet à des agents de se décrire et d'interagir entre eux
    • Agent cards, skills, tâche, contexte
    • A2A complémente MCP
    • Red hat a implémenté le SDK Java avec le conseil des équipes Google
    • En quelques annotations et classes on a un agent card, un client A2A et un serveur avec l'échange de messages via le protocole A2A

    Comment configurer mockito sans warning après java 21 https://rieckpil.de/how-to-configure-mockito-agent-for-java-21-without-warning/

    • les agents chargés dynamiquement sont déconseillés et seront interdis bientôt
    • Un des usages est mockito via bytebuddy
    • L'avantage est que la,configuration était transparente
    • Mais bon sécurité oblige c'est fini.
    • Donc l'article décrit comment configurer maven gradle pour mettre l'agent au démarrage des tests
    • Et aussi comment configurer cela dans IntelliJ idea.
    • Moins simple malheureusement
    Web

    Des raisons "égoïstes" de rendre les UIs plus accessibles https://nolanlawson.com/2025/06/16/selfish-reasons-for-building-accessible-uis/

    • Raisons égoïstes : Des avantages personnels pour les développeurs de créer des interfaces utilisateurs (UI) accessibles, au-delà des arguments moraux.
    • Débogage facilité : Une interface accessible, avec une structure sémantique claire, est plus facile à déboguer qu'un code désordonné (la « soupe de div »).
    • Noms standardisés : L'accessibilité fournit un vocabulaire standard (par exemple, les directives WAI-ARIA) pour nommer les composants d'interface, ce qui aide à la clarté et à la structuration du code.
    • Tests simplifiés : Il est plus simple d'écrire des tests automatisés pour des éléments d'interface accessibles, car ils peuvent être ciblés de manière plus fiable et sémantique.

    Après 20 ans de stagnation, la spécification du format d'image PNG évolue enfin ! https://www.programmax.net/articles/png-is-back/

    • Objectif : Maintenir la pertinence et la compétitivité du format.
    • Recommandation : Soutenu par des institutions comme la Bibliothèque du Congrès américain.
    • Nouveautés Clés :Prise en charge du HDR (High Dynamic Range) pour une plus grande gamme de couleurs.
    • Reconnaissance officielle des PNG animés (APNG).
    • Support des métadonnées Exif (copyright, géolocalisation, etc.).
    • Support Actuel : Déjà intégré dans Chrome, Safari, Firefox, iOS, macOS et Photoshop.
    • Futur :Prochaine édition : focus sur l'interopérabilité entre HDR et SDR.
    • Édition suivante : améliorations de la compression.

    Avec le projet open source Xtool, on peut maintenant construire des applications iOS sur Linux ou Windows, sans avoir besoin d'avoir obligatoirement un Mac https://xtool.sh/tutorials/xtool/

    • Un tutoriel très bien fait explique comment faire :
    • Création d'un nouveau projet via la commande xtool new.
    • Génération d'un package Swift avec des fichiers clés comme Package.swift et xtool.yml.
    • Build et exécution de l'app sur un appareil iOS avec xtool dev.
    • Connexion de l'appareil en USB, gestion du jumelage et du Mode Développeur.
    • xtool gère automatiquement les certificats, profils de provisionnement et la signature de l'app.
    • Modification du code de l'interface utilisateur (ex: ContentView.swift).
    • Reconstruction et réinstallation rapide de l'app mise à jour avec xtool dev.
    • xtool est basé sur VSCode sur la partie IDE
    Data et Intelligence Artificielle

    Nouvelle edition du best seller mondial "Understanding LangChain4j" : https://www.linkedin.com/posts/agoncal_langchain4j-java-ai-activity-7342825482830200833-rtw8/

    • Mise a jour des APIs (de LC4j 0.35 a 1.1.0)
    • Nouveaux Chapitres sur MCP / Easy RAG / JSon Response
    • Nouveaux modeles (GitHub Model, DeepSeek, Foundry Local)
    • Mise a jour des modeles existants (GPT-4.1, Claude 3.7…)

    Google donne A2A a la Foundation Linux https://developers.googleblog.com/en/google-cloud-donates-a2a-to-linux-foundation/

    • Annonce du projet Agent2Agent (A2A) : Lors du sommet Open Source Summit North America, la Linux Foundation a annoncé la création du projet Agent2Agent, en partenariat avec Google, AWS, Microsoft, Cisco, Salesforce, SAP et ServiceNow.
    • Objectif du protocole A2A : Ce protocole vise à établir une norme ouverte pour permettre aux agents d'intelligence artificielle (IA) de communiquer, collaborer et coordonner des tâches complexes entre eux, indépendamment de leur fournisseur.
    • Transfert de Google à la communauté open source : Google a transféré la spécification du protocole A2A, les SDK associés et les outils de développement à la Linux Foundation pour garantir une gouvernance neutre et communautaire.
    • Soutien de l'industrie : Plus de 100 entreprises soutiennent déjà le protocole. AWS et Cisco sont les derniers à l'avoir validé. Chaque entreprise partenaire a souligné l'importance de l'interopérabilité et de la collaboration ouverte pour l'avenir de l'IA.
    • Objectifs de la fondation A2A :
      • Établir une norme universelle pour l'interopérabilité des agents IA.
      • Favoriser un écosystème mondial de développeurs et d'innovateurs.
      • Garantir une gouvernance neutre et ouverte.
      • Accélérer l'innovation sécurisée et collaborative.
    • parler de la spec et surement dire qu'on aura l'occasion d'y revenir

    Gemini CLI :https://blog.google/technology/developers/introducing-gemini-cli-open-source-ai-agent/

    1. Agent IA dans le terminal : Gemini CLI permet d'utiliser l'IA Gemini directement depuis le terminal.
    2. Gratuit avec compte Google : Accès à Gemini 2.5 Pro avec des limites généreuses.
    3. Fonctionnalités puissantes : Génère du code, exécute des commandes, automatise des tâches.
    4. Open source : Personnalisable et extensible par la communauté.
    5. Complément de Code Assist : Fonctionne aussi avec les IDE comme VS Code.

    Au lieu de blocker les IAs sur vos sites vous pouvez peut-être les guider avec les fichiers LLMs.txt https://llmstxt.org/

    Outillage

    Les commits dans Git sont immuables, mais saviez vous que vous pouviez rajouter / mettre à jour des "notes" sur les commits ? https://tylercipriani.com/blog/2022/11/19/git-notes-gits-coolest-most-unloved-feature/

    • Fonctionnalité méconnue : git notes est une fonctionnalité puissante mais peu utilisée de Git.
    • Ajout de métadonnées : Permet d'attacher des informations à des commits existants sans en modifier le hash.
    • Cas d'usage : Idéal pour ajouter des données issues de systèmes automatisés (builds, tickets, etc.).
    • Revue de code distribuée : Des outils comme git-appraise ont été construits sur git notes pour permettre une revue de code entièrement distribuée, indépendante des forges (GitHub, GitLab).
    • Peu populaire : Son interface complexe et le manque de support des plateformes de forge ont limité son adoption (GitHub n'affiche même pas/plus les notes).
    • Indépendance des forges : git notes offre une voie vers une plus grande indépendance vis-à-vis des plateformes centralisées, en distribuant l'historique du projet avec le code lui-même.

    Un aperçu dur Spring Boot debugger dans IntelliJ idea ultimate https://blog.jetbrains.com/idea/2025/06/demystifying-spring-boot-with-spring-debugger/

    • montre cet outil qui donne du contexte spécifique à Spring comme les beans non activés, ceux mockés, la valeur des configs, l'état des transactions
    • Il permet de visualiser tous les beans Spring directement dans la vue projet, avec les beans non instanciés grisés et les beans mockés marqués en orange pour les tests
    • Il résout le problème de résolution des propriétés en affichant la valeur effective en temps réel dans les fichiers properties et yaml, avec la source exacte des valeurs surchargées
    • Il affiche des indicateurs visuels pour les méthodes exécutées dans des transactions actives, avec les détails complets de la transaction et une hiérarchie visuelle pour les transactions imbriquées
    • Il détecte automatiquement toutes les connexions DataSource actives et les intègre avec la fenêtre d'outils Database d'IntelliJ IDEA pour l'inspection
    • Il permet l'auto-complétion et l'invocation de tous les beans chargés dans l'évaluateur d'expression, fonctionnant comme un REPL pour le contexte Spring
    • Il fonctionne sans agent runtime supplémentaire en utilisant des breakpoints non-suspendus dans les bibliothèques Spring Boot pour analyser les données localement

    Une liste communautaire sur les assistants IA pour le code, lancée par Lize Raes https://aitoolcomparator.com/

    • tableau comparatif qui permet de voir les différentes fonctionnalités supportées par ces outils
    Architecture

    Un article sur l'architecture hexagonale en Java https://foojay.io/today/clean-and-modular-java-a-hexagonal-architecture-approach/

    • article introductif mais avec exemple sur l'architecture hexagonale entre le domaine, l'application et l'infrastructure
    • Le domain est sans dépendance
    • L'appli spécifique à l'application mais sans dépendance technique explique le flow
    • L'infrastructure aura les dépendances à vos frameworks spring, Quarkus Micronaut, Kafka etc
    • Je suis naturellement pas fan de l'architecture hexagonale en terme de volume de code vs le gain surtout en microservices
    • mais c'est toujours intéressant de se challenger et de regarder le bénéfice coût.

    Gardez un œil sur les technologies avec les tech radar https://www.sfeir.dev/cloud/tech-radar-gardez-un-oeil-sur-le-paysage-technologique/

    • Le Tech Radar est crucial pour la veille technologique continue et la prise de décision éclairée.
    • Il catégorise les technologies en Adopt, Trial, Assess, Hold, selon leur maturité et pertinence.
    • Il est recommandé de créer son propre Tech Radar pour l'adapter aux besoins spécifiques, en s'inspirant des Radars publics.
    • Utilisez des outils de découverte (Alternativeto), de tendance (Google Trends), de gestion d'obsolescence (End-of-life.date) et d'apprentissage (roadmap.sh).
    • Restez informé via les blogs, podcasts, newsletters (TLDR), et les réseaux sociaux/communautés (X, Slack).
    • L'objectif est de rester compétitif et de faire des choix technologiques stratégiques.
    • Attention à ne pas sous-estimer son coût de maintenance
    Méthodologies

    Le concept d'expert generaliste https://martinfowler.com/articles/expert-generalist.html

    • L'industrie pousse vers une spécialisation étroite, mais les collègues les plus efficaces excellent dans plusieurs domaines à la fois
    • Un développeur Python expérimenté peut rapidement devenir productif dans une équipe Java grâce aux concepts fondamentaux partagés
    • L'expertise réelle comporte deux aspects : la profondeur dans un domaine et la capacité d'apprendre rapidement
    • Les Expert Generalists développent une maîtrise durable au niveau des principes fondamentaux plutôt que des outils spécifiques
    • La curiosité est essentielle : ils explorent les nouvelles technologies et s'assurent de comprendre les réponses au lieu de copier-coller du code
    • La collaboration est vitale car ils savent qu'ils ne peuvent pas tout maîtriser et travaillent efficacement avec des spécialistes
    • L'humilité les pousse à d'abord comprendre pourquoi les choses fonctionnent d'une certaine manière avant de les remettre en question
    • Le focus client canalise leur curiosité vers ce qui aide réellement les utilisateurs à exceller dans leur travail
    • L'industrie doit traiter "Expert Generalist" comme une compétence de première classe à nommer, évaluer et former
    • ca me rappelle le technical staff

    Un article sur les métriques métier et leurs valeurs https://blog.ippon.fr/2025/07/02/monitoring-metier-comment-va-vraiment-ton-service-2/

    • un article de rappel sur la valeur du monitoring métier et ses valeurs
    • Le monitoring technique traditionnel (CPU, serveurs, API) ne garantit pas que le service fonctionne correctement pour l'utilisateur final.
    • Le monitoring métier complète le monitoring technique en se concentrant sur l'expérience réelle des utilisateurs plutôt que sur les composants isolés.
    • Il surveille des parcours critiques concrets comme "un client peut-il finaliser sa commande ?" au lieu d'indicateurs abstraits.
    • Les métriques métier sont directement actionnables : taux de succès, délais moyens et volumes d'erreurs permettent de prioriser les actions.
    • C'est un outil de pilotage stratégique qui améliore la réactivité, la priorisation et le dialogue entre équipes techniques et métier.
    • La mise en place suit 5 étapes : dashboard technique fiable, identification des parcours critiques, traduction en indicateurs, centralisation et suivi dans la durée.
    • Une Definition of Done doit formaliser des critères objectifs avant d'instrumenter tout parcours métier.
    • Les indicateurs mesurables incluent les points de passage réussis/échoués, les temps entre actions et le respect des règles métier.
    • Les dashboards doivent être intégrés dans les rituels quotidiens avec un système d'alertes temps réel compréhensibles.
    • Le dispositif doit évoluer continuellement avec les transformations produit en questionnant chaque incident pour améliorer la détection.
    • La difficulté c'est effectivement l'évolution métier par exemple peu de commandes la nuit etc
    • ça fait partie de la boîte à outils SRE
    Sécurité

    Toujours à la recherche du S de Sécurité dans les MCP https://www.darkreading.com/cloud-security/hundreds-mcp-servers-ai-models-abuse-rce

    • analyse des serveurs mcp ouverts et accessibles
    • beaucoup ne font pas de sanity check des parametres
    • si vous les utilisez dans votre appel genAI vous vous exposer
    • ils ne sont pas mauvais fondamentalement mais n'ont pas encore de standardisation de securite
    • si usage local prefferer stdio ou restreindre SSE à 127.0.0.1
    Loi, société et organisation

    Nicolas Martignole, le même qui a créé le logo des Cast Codeurs, s'interroge sur les voies possibles des développeurs face à l'impact de l'IA sur notre métier https://touilleur-express.fr/2025/06/23/ni-manager-ni-contributeur-individuel/

    • Évolution des carrières de développeur : L'IA transforme les parcours traditionnels (manager ou expert technique).
    • Chef d'Orchestre d'IA : Ancien manager qui pilote des IA, définit les architectures et valide le code généré.
    • Artisan Augmenté : Développeur utilisant l'IA comme un outil pour coder plus vite et résoudre des problèmes complexes.
    • Philosophe du Code : Un nouveau rôle centré sur le "pourquoi" du code, la conceptualisation de systèmes et l'éthique de l'IA.
    • Charge cognitive de validation : Nouvelle charge mentale créée par la nécessité de vérifier le travail des IA.
    • Réflexion sur l'impact : L'article invite à choisir son impact : orchestrer, créer ou guider.

    Entraîner les IAs sur des livres protégés (copyright) est acceptable (fair use) mais les stocker ne l'est pas https://www.reuters.com/legal/litigation/anthropic-wins-key-ruling-ai-authors-copyright-lawsuit-2025-06-24/

    • Victoire pour Anthropic (jusqu'au prochain procès): L'entreprise a obtenu gain de cause dans un procès très suivi concernant l'entraînement de son IA, Claude, avec des œuvres protégées par le droit d'auteur.
    • "Fair Use" en force : Le juge a estimé que l'utilisation des livres pour entraîner l'IA relevait du "fair use" (usage équitable) car il s'agit d'une transformation du contenu, pas d'une simple reproduction.
    • Nuance importante : Cependant, le stockage de ces œuvres dans une "bibliothèque centrale" sans autorisation a été jugé illégal, ce qui souligne la complexité de la gestion des données pour les modèles d'IA.

    Luc Julia, son audition au sénat https://videos.senat.fr/video.5486945_685259f55eac4.ia–audition-de-luc-julia-concepteur-de-siri

    • On aime ou pas on aide pas Luc Julia et sa vision de l'IA . C'est un eversion encore plus longue mais dans le même thème que sa keynote à Devoxx France 2025 ( https://www.youtube.com/watch?v=JdxjGZBtp_k )
    • Nature et limites de l'IA : Luc Julia a insisté sur le fait que l'intelligence artificielle est une "évolution" plutôt qu'une "révolution". Il a rappelé qu'elle repose sur des mathématiques et n'est pas "magique". Il a également alerté sur le manque de fiabilité des informations fournies par les IA génératives comme ChatGPT, soulignant qu'« on ne peut pas leur faire confiance » car elles peuvent se tromper et que leur pertinence diminue avec le temps.
    • Régulation de l'IA : Il a plaidé pour une régulation "intelligente et éclairée", qui devrait se faire a posteriori afin de ne pas freiner l'innovation. Selon lui, cette régulation doit être basée sur les faits et non sur une analyse des risques a priori.
    • Place de la France : Luc Julia a affirmé que la France possédait des chercheurs de très haut niveau et faisait partie des meilleurs mondiaux dans le domaine de l'IA. Il a cependant soulevé le problème du financement de la recherche et de l'innovation en France.
    • IA et Société : L'audition a traité des impacts de l'IA sur la vie privée, le monde du travail et l'éducation. Luc Julia a souligné l'importance de développer l'esprit critique, notamment chez les jeunes, pour apprendre à vérifier les informations générées par les IA.
    • Applications concrètes et futures : Le cas de la voiture autonome a été discuté, Luc Julia expliquant les différents niveaux d'autonomie et les défis restants. Il a également affirmé que l'intelligence artificielle générale (AGI), une IA qui dépasserait l'homme dans tous les domaines, est "impossible" avec les technologies actuelles.
    Rubrique débutant

    Les weakreferences et le finalize https://dzone.com/articles/advanced-java-garbage-collection-concepts

    • un petit rappel utile sur les pièges de la méthode finalize qui peut ne jamais être invoquée
    • Les risques de bug si finalize ne fini jamais
    • Finalize rend le travail du garbage collector beaucoup plus complexe et inefficace
    • Weak references sont utiles mais leur libération n'est pas contrôlable. Donc à ne pas abuser.
    • Il y a aussi les soft et phantom references mais les usages ne sont assez subtils et complexe en fonction du GC.
    • Le sériel va traiter les weak avant les soft, parallel non
    • Le g1 ça dépend de la région
    • Z1 ça dépend car le traitement est asynchrone
    Conférences

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    16 July 2025, 1:40 pm
  • 1 hour 43 minutes
    LCC 327 - Mon ami de 30 ans

    Dans cet épisode, c'est le retour de Katia et d'Antonio. Les Cast Codeurs explorent WebAssembly 2.0, les 30 ans de Java, l'interopérabilité Swift-Java et les dernières nouveautés Kotlin. Ils plongent dans l'évolution de l'IA avec Claude 4 et GPT-4.1, débattent de la conscience artificielle et partagent leurs retours d'expérience sur l'intégration de l'IA dans le développement. Entre virtualisation, défis d'infrastructure et enjeux de sécurité open source, une discussion riche en insights techniques et pratiques.

    Enregistré le 13 juin 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-327.mp3 ou en vidéo sur YouTube.

    News Langages

    Wasm 2.0 enfin officialisé ! https://webassembly.org/news/2025-03-20-wasm-2.0/

    • La spécification Wasm 2.0 est officiellement sortie en décembre dernier.
    • Le consensus sur la spécification avait été atteint plus tôt, en 2022.
    • Les implémentations majeures supportent Wasm 2.0 depuis un certain temps.
    • Le processus W3C a pris du temps pour atteindre le statut de "Recommandation Candidate" pour des raisons non techniques.
    • Les futures versions de Wasm adopteront un modèle "evergreen" où la "Recommandation Candidate" sera mise à jour en place.
    • La dernière version de la spécification est considérée comme le standard actuel (Candidate Recommendation Draft).
    • La version la plus à jour est disponible sur la page GitHub (GitHub page).
    • Wasm 2.0 inclut les nouveautés suivantes :
    • Wasm 2.0 est entièrement rétrocompatible avec Wasm 1.0.

    Paul Sandoz annonce que le JDK intègrera bientôt une API minimaliste pour lire et écrire du JSON https://mail.openjdk.org/pipermail/core-libs-dev/2025-May/145905.html

    Java a 30 ans, c'était quoi les points bluffants au début ? https://blog.jetbrains.com/idea/2025/05/do-you-really-know-java/

    • nom de code Oak
    • Mais le trademark était pris
    • Write Once Run Anywhere
    • Garbage Collector Automatique
    • multi threading au coeur de la palteforme meme si Java est passé par les green threads pendant un temps
    • modèle de sécurité: sandbox applets, security manager, bytecode verifier, classloader

    Des progrès dans l'interopérabilité Swift / Java mentionnés à la conférence Apple WWDC 2025 https://www.youtube.com/watch?v=QSHO-GUGidA

    • Interopérabilité Swift-Java : Utiliser Swift dans des apps Java et vice-versa.
    • Historique : L'interopérabilité Swift existait déjà avec C et C++.
    • Méthodes : Deux directions d'interopérabilité : Java depuis Swift et Swift depuis Java.
    • JNI : JNI est l'API Java pour le code natif, mais elle est verbeuse.
    • Swift-Java : Un projet pour une interaction Swift-Java plus flexible, sûre et performante.
    • Exemples pratiques : Utiliser des bibliothèques Java depuis Swift et rendre des bibliothèques Swift disponibles pour Java.
    • Gestion mémoire : Swift-Java utilise la nouvelle API FFM de Java pour gérer la mémoire des objets Swift.
    • Open Source : Le projet Swift-Java est open source et invite aux contributions.

    KotlinConf le retour https://www.sfeir.dev/tendances/kotlinconf25-quelles-sont-les-annonces-a-retenir/ par Adelin de Sfeir

    • "1 developeur sur 10" utilise Kotlin
    • Kotlin 2.2 en RC
    • $$ multi dollar interpolation pour eviter les sur interpolations
    • non local break / continue (changement dans la conssitance de Kotlin
    • guards sur le pattern matching
    • D'autres features annoncées
    • alignement des versions de l'ecosysteme sur kotlin jvm par defaut
    • un nouvel outil de build Amper
    • beaucoup d'annonces autour de l'IA
    • Koog, framework agentique de maniere declarative
    • nouvelle version du LLM de JetBrains: Mellum (focalisé sur le code)
    • Kotlin et Compose multiplateforme (stable en iOS)
    • Hot Reload dans compose en alpha
    • partenariat strategque avec Spring pour bien integrer kotlin dans spring
    Librairies

    Sortie d'une version Java de ADK, le framework d'agents IA lancé par Google https://glaforge.dev/posts/2025/05/20/writing-java-ai-agents-with-adk-for-java-getting-started/

    • Guillaume a travaillé sur le lancement de ce framework ! (améliorations de l'API, code d'exemple, doc…)

    Comment déployer un serveur MCP en Java, grâce à Quarkus, et le déployer sur Google Cloud Run https://glaforge.dev/posts/2025/06/09/building-an-mcp-server-with-quarkus-and-deploying-on-google-cloud-run/

    • Même Guillaume se met à faire du Quarkus !
    • Utilisation du support MCP développé par l'équipe Quarkus. C'est facile, suffit d'annoter une méthode avec @Tool et ses arguments avec @ToolArg et c'est parti !
    • L'outil MCP inspector est très pratique pour inspecter manuellement le fonctionnement de ses serveurs MCP
    • Déployer sur Cloud Run est facile grâce aux Dockerfiles fournis par Quarkus
    • En bonus, Guillaume montre comment configuré un serveur MCP comme un outil dans le framework ADK pour Java, pour créer ses agents IA

    Jilt 1.8 est sorti, un annotation processor pour le pattern builder https://www.endoflineblog.com/jilt-1_8-and-1_8_1-released

    • processing incrémental pour Gradle
    • meilleure couverture de votre code (pour ne pas comptabiliser le code généré par l'annotation processeur)
    • une correction d'un problème lors de l'utilisation des types génériques récursifs (genre Node>

    Hibernate Search 8 est sorti https://in.relation.to/2025/06/06/hibernate-search-8-0-0-Final/

    • aggregation de metriques
    • compatibilité avec les dernieres OpenSearch et Elasticsearch
    • Lucene 10 en backend
    • Preview des requetes validées à la compilation

    Hibernate 7 est sorti https://in.relation.to/2025/05/20/hibernate-orm-seven/

    • ASL 2.0
    • Hibernate Validator 9
    • Jakarta Persistence 3.2 et Jakarta Validation 3.1
    • saveOrUpdate (reattachement d'entité) n'est plus supporté
    • session stateless plus capable: oeprations unitaires et pas seulement bach, acces au cache de second niveau, m,eilleure API pour les batchs (insertMultiple etc)
    • nouvelle API criteria simple et type-safe: et peut ajouter a une requete de base

    Un article qui décrit la Dev UI de Quarkus https://www.sfeir.dev/back/quarkus-dev-ui-linterface-ultime-pour-booster-votre-productivite-en-developpement-java/

    • apres un test pour soit ou une demo, c'est un article détaillé et la doc de Quarkus n'est pas top là dessus

    Vert.x 5 est sorti https://vertx.io/blog/eclipse-vert-x-5-released/

    • on en avait parlé fin de l'année dernière ou début d'année
    • Modèle basé uniquement sur les Futures : Vert.x 5 abandonne le modèle de callbacks pour ne conserver que les Futures, avec une nouvelle classe de base VerticleBase mieux adaptée à ce modèle asynchrone.
    • Support des modules Java (JPMS) : Vert.x 5 prend en charge le système de modules de la plateforme Java avec des modules explicites, permettant une meilleure modularité des applications.
    • Améliorations majeures de gRPC : Support natif de gRPC Web et gRPC Transcoding (support HTTP/JSON et gRPC), format JSON en plus de Protobuf, gestion des timeouts et deadlines, services de réflexion et de health.
    • Support d'io_uring : Intégration native du système io_uring de Linux (précédemment en incubation) pour de meilleures performances I/O sur les systèmes compatibles.
    • Load balancing côté client : Nouvelles capacités de répartition de charge pour les clients HTTP et gRPC avec diverses politiques de distribution.
    • Service Resolver : Nouveau composant pour la résolution dynamique d'adresses de services, étendant les capacités de load balancing à un ensemble plus large de résolveurs.
    • Améliorations du proxy HTTP : Nouvelles transformations prêtes à l'emploi, interception des upgrades WebSocket et interface SPI pour le cache avec support étendu des spécifications.
    • Suppressions et remplacements : Plusieurs composants sont dépréciés (gRPC Netty, JDBC API, Service Discovery) ou supprimés (Vert.x Sync, RxJava 1), remplacés par des alternatives plus modernes comme les virtual threads et Mutiny.

    Spring AI 1.0 est sorti https://spring.io/blog/2025/05/20/spring-ai-1-0-GA-released

    • ChatClient multi-modèles : API unifiée pour interagir avec 20 modèles d'IA différents avec support multi-modal et réponses JSON structurées.
    • Écosystème RAG complet : Support de 20 bases vectorielles, pipeline ETL et enrichissement automatique des prompts via des advisors.
    • Fonctionnalités enterprise : Mémoire conversationnelle persistante, support MCP, observabilité Micrometer et évaluateurs automatisés.
    • Agents et workflows : Patterns prédéfinis (routing, orchestration, chaînage) et agents autonomes pour applications d'IA complexes.
    Infrastructure

    Les modèles d'IA refusent d'être éteint et font du chantage pour l'eviter, voire essaient se saboter l'extinction https://www.thealgorithmicbridge.com/p/ai-companies-have-lost-controland?utm_source=substac[…]aign=email-restack-comment&r=2qoalf&triedRedirect=true

    • Les chercheur d'Anthropic montrent comment Opus 4 faisait du chantage aux ingenieurs qui voulaient l'eteindre pour mettre une nouvelle version en ligne
    • Une boite de recherche a montré la même chose d'Open AI o3
    • non seulemenmt il ne veut pas mais il essaye activement d'empêcher l'extinction

    Apple annonce le support de la virtualisation / conteneurisation dans macOS lors de la WWDC https://github.com/apple/containerization

    Grosse chute de services internet suite à un soucis sur GCP

    • Le retour de cloud flare https://blog.cloudflare.com/cloudflare-service-outage-june-12-2025/
    • Leur système de stockage (une dépendance majeure) dépend exclusivement de GCP
    • Mais ils ont des plans pour surfit de cette dépendance exclusive
    • la première analyse de Google https://status.cloud.google.com/incidents/ow5i3PPK96RduMcb1SsW
    • Un quota auto mis à jour qui a mal tourné.
    • ils ont bypassé le quota en code mais le service de quote en us-central1 était surchargé.
    • Prochaines améliorations: pas d propagation de données corrompues, pas de déploiement global sans rolling upgrade avec monitoring qui peut couper
    • par effet de bord (fail over) certains autres cloud providers ont aussi eu quelques soucis (charge) - unverified
    Data et Intelligence Artificielle

    Claude 4 est sorti

    https://www.anthropic.com/news/claude-4

    • Deux nouveaux modèles lancés : Claude Opus 4 (le meilleur modèle de codage au monde) et Claude Sonnet 4 (une amélioration significative de Sonnet 3.7)
    • Claude Opus 4 atteint 72,5% sur SWE-bench et peut maintenir des performances soutenues sur des tâches longues durant plusieurs heures
    • Claude Sonnet 4 obtient 72,7% sur SWE-bench tout en équilibrant performance et efficacité pour un usage quotidien
    • Nouvelle fonctionnalité de "pensée étendue avec utilisation d'outils" permettant à Claude d'alterner entre raisonnement et usage d'outils
    • Les modèles peuvent maintenant utiliser plusieurs outils en parallèle et suivre les instructions avec plus de précision
    • Capacités mémoire améliorées : Claude peut extraire et sauvegarder des informations clés pour maintenir la continuité sur le long terme
    • Claude Code devient disponible à tous avec intégrations natives VS Code et JetBrains pour la programmation en binôme
    • Quatre nouvelles capacités API : outil d'exécution de code, connecteur MCP, API Files et mise en cache des prompts
    • Les modèles hybrides offrent deux modes : réponses quasi-instantanées et pensée étendue pour un raisonnement plus approfondi en mode "agentique"

    L'intégration de l'IA au delà des chatbots et des boutons à étincelles https://glaforge.dev/posts/2025/05/23/beyond-the-chatbot-or-ai-sparkle-a-seamless-ai-integration/

    • Plaidoyer pour une IA intégrée de façon transparente et intuitive, au-delà des chatbots.
    • Chatbots : pas toujours l'option LLM la plus intuitive ou la moins perturbatrice.
    • Préconisation : IA directement dans les applications pour plus d'intelligence et d'utilité naturelle.
    • Exemples d'intégration transparente : résumés des conversations Gmail et chat, web clipper Obsidian qui résume et taggue, complétion de code LLM.
    • Meilleure UX IA : intégrée, contextuelle, sans "boutons IA" ou fenêtres de chat dédiées.
    • Conclusion de Guillaume : intégrations IA réussies = partie naturelle du système, améliorant les workflows sans perturbation, le développeur ou l'utilisateur reste dans le "flow"

    Garder votre base de donnée vectorielle à jour avec Debezium https://debezium.io/blog/2025/05/19/debezium-as-part-of-your-ai-solution/

    • pas besoin de detailler mais
    • expliquer idee de garder les changements a jour dans l'index
    Outillage

    guide pratique pour choisir le bon modèle d'IA à utiliser avec GitHub Copilot, en fonction de vos besoins en développement logiciel. https://github.blog/ai-and-ml/github-copilot/which-ai-model-should-i-use-with-github-copilot/ - Équilibre coût/performance : GPT-4.1, GPT-4o ou Claude 3.5 Sonnet pour des tâches générales et multilingues. - Tâches rapides : o4-mini ou Claude 3.5 Sonnet pour du prototypage ou de l'apprentissage rapide. - Besoins complexes : Claude 3.7 Sonnet, GPT-4.5 ou o3 pour refactorisation ou planification logicielle. - Entrées multimodales : Gemini 2.0 Flash ou GPT-4o pour analyser images, UI ou diagrammes. - Projets techniques/scientifiques : Gemini 2.5 Pro pour raisonnement avancé et gros volumes de données.

    UV, un package manager pour les pythonistes qui amène un peu de sanité et de vitesse http://blog.ippon.fr/2025/05/12/uv-un-package-manager-python-adapte-a-la-data-partie-1-theorie-et-fonctionnalites/

    • pour les pythonistes
    • un ackage manager plus rapide et simple
    • mais il est seulement semi ouvert (license)

    IntelliJ IDEA 2025.1 permet de rajouter un mode MCP client à l'assistant IA https://blog.jetbrains.com/idea/2025/05/intellij-idea-2025-1-model-context-protocol/

    • par exemple faire tourner un MCP server qui accède à la base de donnée
    Méthodologies

    Développement d'une bibliothèque OAuth 2.1 open source par Cloudflare, en grande partie générée par l'IA Claude: - Prompts intégrés aux commits : Chaque commit contient le prompt utilisé, ce qui facilite la compréhension de l'intention derrière le code. - Prompt par l'exemple : Le premier prompt montrait un exemple d'utilisation de l'API qu'on souhaite obtenir, ce qui a permis à l'IA de mieux comprendre les attentes. - Prompts structurés : Les prompts les plus efficaces suivaient un schéma clair : état actuel, justification du changement, et directive précise. - Traitez les prompts comme du code source : Les inclure dans les commits aide à la maintenance. - Acceptez les itérations : Chaque fonctionnalité a nécessité plusieurs essais. - Intervention humaine indispensable : Certaines tâches restent plus rapides à faire à la main. https://www.maxemitchell.com/writings/i-read-all-of-cloudflares-claude-generated-commits/

    Sécurité

    Un packet npm malicieux passe par Cursor AI pour infecter les utilisateurs https://thehackernews.com/2025/05/malicious-npm-packages-infect-3200.html

    • Trois packages npm malveillants ont été découverts ciblant spécifiquement l'éditeur de code Cursor sur macOS, téléchargés plus de 3 200 fois au total.Les packages se déguisent en outils de développement promettant "l'API Cursor la moins chère" pour attirer les développeurs intéressés par des solutions AI abordables.
    • Technique d'attaque sophistiquée : les packages volent les identifiants utilisateur, récupèrent un payload chiffré depuis des serveurs contrôlés par les pirates, puis remplacent le fichier main.js de Cursor.
    • Persistance assurée en désactivant les mises à jour automatiques de Cursor et en redémarrant l'application avec le code malveillant intégré.
    • Nouvelle méthode de compromission : au lieu d'injecter directement du malware, les attaquants publient des packages qui modifient des logiciels légitimes déjà installés sur le système.
    • Persistance même après suppression : le malware reste actif même si les packages npm malveillants sont supprimés, nécessitant une réinstallation complète de Cursor.
    • Exploitation de la confiance : en s'exécutant dans le contexte d'une application légitime (IDE), le code malveillant hérite de tous ses privilèges et accès.
    • Package "rand-user-agent" compromis : un package légitime populaire a été infiltré pour déployer un cheval de Troie d'accès distant (RAT) dans certaines versions.
    • Recommandations de sécurité : surveiller les packages exécutant des scripts post-installation, modifiant des fichiers hors node_modules, ou initiant des appels réseau inattendus, avec monitoring d'intégrité des fichiers.
    Loi, société et organisation

    Le drama OpenRewrite (automatisation de refactoring sur de larges bases de code) est passé en mode propriétaire https://medium.com/@jonathan.leitschuh/when-open-source-isnt-how-openrewrite-lost-its-way-642053be287d

    • Faits Clés :
      • Moderne, Inc. a re-licencié silencieusement du code OpenRewrite (dont rewrite-java-security) de la licence Apache 2.0 à une licence propriétaire (MPL) sans consultation des contributeurs.
      • Ce re-licenciement rend le code inaccessible et non modifiable pour les contributeurs originaux.
      • Moderne s'est retiré de la Commonhaus Foundation (dédiée à l'open source) juste avant ces changements.
      • La justification de Moderne est la crainte que de grandes entreprises utilisent OpenRewrite sans contribuer, créant une concurrence.
      • Des contributions communautaires importantes (VMware, AliBaba) sous Apache 2.0 ont été re-licenciées sans leur consentement.
      • La légalité de ce re-licenciement est incertaine sans CLA des contributeurs.
      • Cette action crée un précédent dangereux pour les futurs contributeurs et nuit à la confiance dans l'écosystème OpenRewrite.
    • Corrections de Moderne (Suite aux réactions) :
      • Les dépôts Apache originaux ont été restaurés et archivés.
      • Des versions majeures ont été utilisées pour signaler les changements de licence.
      • Des espaces de noms distincts (org.openrewrite vs. io.moderne) ont été créés pour différencier les modules.
    • Suggestions de Correction de l'Auteur :
      • Annuler les changements de licence sur toutes les recettes communautaires.
      • S'engager dans le dialogue et communiquer publiquement les changements majeurs.
      • Respecter le versionnement sémantique (versions majeures pour les changements de licence).

    L'ancien gourou du design d'Apple, Jony Ive, va occuper un rôle majeur chez OpenAI OpenAI va acquérir la startup d'Ive pour 6,5 milliards de dollars, tandis qu'Ive et le PDG Sam Altman travaillent sur une nouvelle génération d'appareils et d'autres produits d'IA https://www.wsj.com/tech/ai/former-apple-design-guru-jony-ive-to-take-expansive-role-at-openai-5787f7da

    Rubrique débutant

    Un article pour les débutants sur le lien entre source, bytecode et le debug https://blog.jetbrains.com/idea/2025/05/sources-bytecode-debugging/

    • le debugger voit le bytecode
    • et le lien avec la ligne ou la methode est potentiellement perdu
    • javac peut ajouter les ligne et offset des operations pour que le debugger les affichent
    • les noms des arguments est aussi ajoutable dans le .class
    • quand vous pointez vers une mauvaise version du fichier source, vous avez des lignes decalées, c'est pour ca
    • peu de raisons de ne pas actier des approches de compilations mais cela rend le fichier un peu plus gros
    Conférences

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    16 June 2025, 8:38 am
  • 1 hour 58 minutes
    LCC 326 - Interview assistants de code IA avec Philippe Charrière et Kevin Aubry

    Dans cet épisode, nous explorons l'univers des assistants de code AI. Comment ces outils transforment-ils notre façon de coder ? Quels sont leurs atouts et leurs limites ? Nos invités Philippe Charrière et Kevin Aubry nous éclairent sur ces technologies qui bouleversent les pratiques des développeurs.

    Enregistré le 8 avril 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-326.mp3 ou en vidéo sur YouTube.

    Interview Ta vie ton oeuvre
    • Peux-tu te présenter brièvement à nos auditeurs?
    • Quelle est ton expérience personnelle avec ces outils?
    • Tu l'utilises chez ton employeur ou juste pour tes projets personnels?
    • Qu'est-ce qui t'a attiré dans ce domaine en particulier?
    Introduction à la techno
    • Qu'est-ce qu'un assistant de code AI exactement? Comment le définirais-tu?
    • Quels sont les principaux assistants de code disponibles aujourd'hui sur le marché?
    • Quand et pourquoi ces outils ont-ils commencé à émerger?
    • Quelle est la différence entre un assistant de code AI et un simple outil de complétion de code?
    La techno en concepts
    • Quels sont les fondements technologiques des assistants de code actuels?
    • Quels sont les différences de flow entre un outil dédié genre CursorAI, GitHub Copilot, un chat LLM générique de type Claude ou un outil à la Devoxx Genie?
    • Il y a aussi des outils de terminal, en ligne de commande ou en desktop dédié genre Goose de Block - comment ceux-ci se positionnent-ils?
    • Quelles sont les différentes approches d'intégration dans les environnements de développement?
    • Comment se positionnent les assistants par rapport à d'autres outils d'aide au développement?
    • Quels sont les modèles économiques actuels (open source vs propriétaire, SaaS vs on-premise)?
    • Qu'en est-il de la confidentialité du code analysé par ces outils?
    Comment on l'utilise en pratique pour un dev
    • Comment un développeur Java typique intègre-t-il un assistant de code dans son workflow quotidien?
    • Quels sont les assistants les plus adaptés à l'écosystème Java spécifiquement?
    • Vous utilisez plutôt VSCode? Ça marche bien dans IntelliJ IDEA?
    • Quelles sont les bonnes pratiques pour formuler des requêtes efficaces à un assistant?
    • Quelles tâches répétitives ou complexes sont particulièrement bien gérées par ces assistants?
    • Quels sont les tâches aujourd'hui où l'assistant de code excelle: squelette de code initial, ajout de fonctionnalité, écrire les tests, corriger un bug, la sécurité, grosse migration de version ou de framework?
    • Comment évaluer la qualité du code généré? Quelles vérifications faire systématiquement?
    • Quelle est ton expérience des hallucinations? Des trucs rigolos à raconter?
    • Comment évoluent les pratiques de pair programming avec ces outils?
    • C'est quoi ton budget code assistance / LLM?
    Sous le capot

    Pas sûr de pouvoir faire cette partie sous le capot si on a des interview orienté utilisateur.

    • Comment ces assistants sont-ils entraînés spécifiquement pour comprendre le code?
    • Quelle est la différence entre le fine-tuning pour le code et pour le langage naturel?
    • Comment fonctionnent les techniques de retrieval augmentation pour le contexte du projet?
    • Comment les assistants gèrent-ils les dépendances et la structure des projets complexes?
    • Quels sont les défis techniques majeurs pour analyser du code Java avec ses spécificités?
    • Comment les modèles réussissent-ils (ou échouent-ils) à comprendre la sémantique du code?
    • Quelles sont les limites actuelles des modèles de langage pour la génération de code?
    • Qu'en est-il de la consommation de ressources et de l'impact environnemental?
    La communauté, le futur
    • Comment la communauté Java a-t-elle accueilli ces outils?
    • C'est pour quel type de développeur? Junior, intermédiaire, expert? Quels avantages pour chaque?
    • Quel impact ces assistants ont-ils sur l'apprentissage de la programmation?
    • Comment voyez-vous l'évolution des compétences requises pour les développeurs?
    • Quelles sont les prochaines frontières pour les assistants de code?
    • Quelles fonctionnalités manquent encore à l'appel?
    • Comment les assistants vont-ils évoluer dans les 2-3 prochaines années?
    • Ces outils vont-ils transformer radicalement la profession de développeur?
    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    3 June 2025, 11:35 am
  • 1 hour 49 minutes
    LCC 325 - Trier le hachis des concurrents

    Gros épisode qui couvre un large spectre de sujets : Java, Scala, Micronaut, NodeJS, l'IA et la compétence des développeurs, le sampling dans les LLMs, les DTO, le vibe coding, les changements chez Broadcom et Red Hat ainsi que plusieurs nouvelles sur les licences open source.

    Enregistré le 7 mai 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-325.mp3 ou en vidéo sur YouTube.

    News Langages

    A l'occasion de JavaOne et du lancement de Java 24, Oracle lance un nouveau site avec des ressources vidéo pour apprendre le langage https://learn.java/

    • site plutôt à destination des débutants et des enseignants
    • couvre la syntaxe aussi, y compris les ajouts plus récents comme les records ou le pattern matching
    • c'est pas le site le plus trendy du monde.

    Martin Odersky partage un long article sur l'état de l'écosystème Scala et les évolutions du language https://www.scala-lang.org/blog/2025/03/24/evolving-scala.html

    • Stabilité et besoin d'évolution : Scala maintient sa position (~14ème mondial) avec des bases techniques solides, mais doit évoluer face à la concurrence pour rester pertinent.
    • Axes prioritaires : L'évolution se concentre sur l'amélioration du duo sécurité/convivialité, le polissage du langage (suppression des "rugosités") et la simplification pour les débutants.
    • Innovation continue : Geler les fonctionnalités est exclu ; l'innovation est clé pour la valeur de Scala. Le langage doit rester généraliste et ne pas se lier à un framework spécifique.
    • Défis et progrès : L'outillage (IDE, outils de build comme sbt, scala-cli, Mill) et la facilité d'apprentissage de l'écosystème sont des points d'attention, avec des améliorations en cours (partenariat pédagogique, plateformes simples).

    Des strings encore plus rapides ! https://inside.java/2025/05/01/strings-just-got-faster/

    • Dans JDK 25, la performance de la fonction String::hashCode a été améliorée pour être principalement constant foldable.
    • Cela signifie que si les chaînes de caractères sont utilisées comme clés dans une Map statique et immuable, des gains de performance significatifs sont probables.
    • L'amélioration repose sur l'annotation interne @Stable appliquée au champ privé String.hash.
    • Cette annotation permet à la machine virtuelle de lire la valeur du hash une seule fois et de la considérer comme constante si elle n'est pas la valeur par défaut (zéro).
    • Par conséquent, l'opération String::hashCode peut être remplacée par la valeur de hash connue, optimisant ainsi les lookups dans les Map immuables.
    • Un cas limite est celui où le code de hachage de la chaîne est zéro, auquel cas l'optimisation ne fonctionne pas (par exemple, pour la chaîne vide "").
    • Bien que l'annotation @Stable soit interne au JDK, un nouveau JEP (JEP 502: Stable Values (Preview)) est en cours de développement pour permettre aux utilisateurs de bénéficier indirectement de fonctionnalités similaires.

    AtomicHash, une implémentation Java d'une HashMap qui est thread-safe, atomique et non-bloquante https://github.com/arxila/atomichash

    • implémenté sous forme de version immutable de Concurrent Hash Trie
    Librairies

    Sortie de Micronaut 4.8.0 https://micronaut.io/2025/04/01/micronaut-framework-4-8-0-released/

    • Mise à jour de la BOM (Bill of Materials) : La version 4.8.0 met à jour la BOM de la plateforme Micronaut.
    • Améliorations de Micronaut Core : Intégration de Micronaut SourceGen pour la génération interne de métadonnées et d'expressions bytecode.
    • Nombreuses améliorations dans Micronaut SourceGen.
    • Ajout du traçage de l'injection de dépendances pour faciliter le débogage au démarrage et à la création des beans.
    • Nouveau membre definitionType dans l'annotation @Client pour faciliter le partage d'interfaces entre client et serveur.
    • Support de la fusion dans les Bean Mappers via l'annotation @Mapping.
    • Nouvelle liveness probe détectant les threads bloqués (deadlocked) via ThreadMXBean.
    • Intégration Kubernetes améliorée : Mise à jour du client Java Kubernetes vers la version 22.0.1.
    • Ajout du module Micronaut Kubernetes Client OpenAPI, offrant une alternative au client officiel avec moins de dépendances, une configuration unifiée, le support des filtres et la compatibilité Native Image.
    • Introduction d'un nouveau runtime serveur basé sur le serveur HTTP intégré de Java, permettant de créer des applications sans dépendances serveur externes.
    • Ajout dans Micronaut Micrometer d'un module pour instrumenter les sources de données (traces et métriques).
    • Ajout de la condition condition dans l'annotation @MetricOptions pour contrôler l'activation des métriques via une expression.
    • Support des Consul watches dans Micronaut Discovery Client pour détecter les changements de configuration distribuée.
    • Possibilité de générer du code source à partir d'un schéma JSON via les plugins de build (Gradle et Maven).
    Web

    Node v24.0.0 passe en version Current: https://nodejs.org/en/blog/release/v24.0.0

    • Mise à jour du moteur V8 vers la version 13.6 : intégration de nouvelles fonctionnalités JavaScript telles que Float16Array, la gestion explicite des ressources (using), RegExp.escape, WebAssembly Memory64 et Error.isError.
    • npm 11 inclus : améliorations en termes de performance, de sécurité et de compatibilité avec les packages JavaScript modernes.
    • Changement de compilateur pour Windows : abandon de MSVC au profit de ClangCL pour la compilation de Node.js sur Windows.
    • AsyncLocalStorage utilise désormais AsyncContextFrame par défaut : offrant une gestion plus efficace du contexte asynchrone.
    • URLPattern disponible globalement : plus besoin d'importer explicitement cette API pour effectuer des correspondances d'URL.
    • Améliorations du modèle de permissions : le flag expérimental --experimental-permission devient --permission, signalant une stabilité accrue de cette fonctionnalité.
    • Améliorations du test runner : les sous-tests sont désormais attendus automatiquement, simplifiant l'écriture des tests et réduisant les erreurs liées aux promesses non gérées.
    • Intégration d'Undici 7 : amélioration des capacités du client HTTP avec de meilleures performances et un support étendu des fonctionnalités HTTP modernes.
    • Dépréciations et suppressions :
      • Dépréciation de url.parse() au profit de l'API WHATWG URL.
      • Suppression de tls.createSecurePair.
      • Dépréciation de SlowBuffer.
      • Dépréciation de l'instanciation de REPL sans new.
      • Dépréciation de l'utilisation des classes Zlib sans new.
      • Dépréciation du passage de args à spawn et execFile dans child_process.
    • Node.js 24 est actuellement la version "Current" et deviendra une version LTS en octobre 2025. Il est recommandé de tester cette version pour évaluer son impact sur vos applications.
    Data et Intelligence Artificielle

    Apprendre à coder reste crucial et l'IA est là pour venir en aide : https://kyrylo.org/software/2025/03/27/learn-to-code-ignore-ai-then-use-ai-to-code-even-better.html

    • Apprendre à coder reste essentiel malgré l'IA.
    • L'IA peut assister la programmation.
    • Une solide base est cruciale pour comprendre et contrôler le code.
    • Cela permet d'éviter la dépendance à l'IA.
    • Cela réduit le risque de remplacement par des outils d'IA accessibles à tous.
    • L'IA est un outil, pas un substitut à la maîtrise des fondamentaux.

    Super article de Anthropic qui essaie de comprendre comment fonctionne la "pensée" des LLMs https://www.anthropic.com/research/tracing-thoughts-language-model

    • Effet boîte noire : Stratégies internes des IA (Claude) opaques aux développeurs et utilisateurs.
    • Objectif : Comprendre le "raisonnement" interne pour vérifier capacités et intentions.
    • Méthode : Inspiration neurosciences, développement d'un "microscope IA" (regarder quels circuits neuronaux s'activent).
    • Technique : Identification de concepts ("features") et de "circuits" internes.
    • Multilinguisme : Indice d'un "langage de pensée" conceptuel commun à toutes les langues avant de traduire dans une langue particulière.
    • Planification : Capacité à anticiper (ex: rimes en poésie), pas seulement de la génération mot par mot (token par token).
    • Raisonnement non fidèle : Peut fabriquer des arguments plausibles ("bullshitting") pour une conclusion donnée.
    • Logique multi-étapes : Combine des faits distincts, ne se contente pas de mémoriser.
    • Hallucinations : Refus par défaut ; réponse si "connaissance" active, sinon risque d'hallucination si erreur.
    • "Jailbreaks" : Tension entre cohérence grammaticale (pousse à continuer) et sécurité (devrait refuser).
    • Bilan : Méthodes limitées mais prometteuses pour la transparence et la fiabilité de l'IA.

    Le "S" dans MCP veut dire Securité (ou pas !) https://elenacross7.medium.com/%EF%B8%8F-the-s-in-mcp-stands-for-security-91407b33ed6b

    • La spécification MCP pour permettre aux LLMs d'avoir accès à divers outils et fonctions a peut-être été adoptée un peu rapidement, alors qu'elle n'était pas encore prête niveau sécurité
    • L'article liste 4 types d'attaques possibles :
      • vulnérabilité d'injection de commandes
      • attaque d'empoisonnement d'outils
      • redéfinition silencieuse de l'outil
      • le shadowing d'outils inter-serveurs
    • Pour l'instant, MCP n'est pas sécurisé :
      • Pas de standard d'authentification
      • Pas de chiffrement de contexte
      • Pas de vérification d'intégrité des outils
    • Basé sur l'article de InvariantLabs https://invariantlabs.ai/blog/mcp-security-notification-tool-poisoning-attacks

    Sortie Infinispan 15.2 - pre rolling upgrades 16.0 https://infinispan.org/blog/2025/03/27/infinispan-15-2

    • Support de Redis JSON + scripts Lua
    • Métriques JVM désactivables
    • Nouvelle console (PatternFly 6)
    • Docs améliorées (métriques + logs)
    • JDK 17 min, support JDK 24
    • Fin du serveur natif (performances)

    Guillaume montre comment développer un serveur MCP HTTP Server Sent Events avec l'implémentation de référence Java et LangChain4j https://glaforge.dev/posts/2025/04/04/mcp-client-and-server-with-java-mcp-sdk-and-langchain4j/

    • Développé en Java, avec l'implémentation de référence qui est aussi à la base de l'implémentation dans Spring Boot (mais indépendant de Spring)
    • Le serveur MCP est exposé sous forme de servlet dans Jetty
    • Le client MCP lui, est développé avec le module MCP de LangChain4j
    • c'est semi independant de Spring dans le sens où c'est dépendant de Reactor et de ses interface.
    • il y a une conversation sur le github d'anthropic pour trouver une solution, mais cela ne parait pas simple.

    Les fallacies derrière la citation "AI won't replace you, but humans using AI will" https://platforms.substack.com/cp/161356485

    • La fallacie de l'automatisation vs. l'augmentation : Elle se concentre sur l'amélioration des tâches existantes avec l'IA au lieu de considérer le changement de la valeur de ces tâches dans un nouveau système.
    • La fallacie des gains de productivité : L'augmentation de la productivité ne se traduit pas toujours par plus de valeur pour les travailleurs, car la valeur créée peut être capturée ailleurs dans le système.
    • La fallacie des emplois statiques : Les emplois sont des constructions organisationnelles qui peuvent être redéfinies par l'IA, rendant les rôles traditionnels obsolètes.
    • La fallacie de la compétition "moi vs. quelqu'un utilisant l'IA" : La concurrence évolue lorsque l'IA modifie les contraintes fondamentales d'un secteur, rendant les compétences existantes moins pertinentes.
    • La fallacie de la continuité du flux de travail : L'IA peut entraîner une réimagination complète des flux de travail, éliminant le besoin de certaines compétences.
    • La fallacie des outils neutres : Les outils d'IA ne sont pas neutres et peuvent redistribuer le pouvoir organisationnel en changeant la façon dont les décisions sont prises et exécutées.
    • La fallacie du salaire stable : Le maintien d'un emploi ne garantit pas un salaire stable, car la valeur du travail peut diminuer avec l'augmentation des capacités de l'IA.
    • La fallacie de l'entreprise stable : L'intégration de l'IA nécessite une restructuration de l'entreprise et ne se fait pas dans un vide organisationnel.

    Comprendre le "sampling" dans les LLMs https://rentry.co/samplers

    • Explique pourquoi les LLMs utilisent des tokens
    • Les différentes méthodes de "sampling" : càd de choix de tokens
    • Les hyperparamètres comme la température, top-p, et leur influence réciproque
    • Les algorithmes de tokenisation comme Byte Pair Encoding et SentencePiece.

    Un de moins … OpenAI va racheter Windsurf pour 3 milliards de dollars. https://www.bloomberg.com/news/articles/2025-05-06/openai-reaches-agreement-to-buy-startup-windsurf-for-3-billion

    • l'accord n'est pas encore finalisé
    • Windsurf était valorisé à 1,25 milliards l'an dernier et OpenAI a levé 40 milliards dernièrement portant sa valeur à 300 milliards
    • Le but pour OpenAI est de rentrer dans le monde des assistants de code pour lesquels ils sont aujourd'hui absent

    Docker desktop se met à l'IA… ? Une nouvelle fonctionnalité dans docker desktop 4.4 sur macos: Docker Model Runner https://dev.to/docker/run-genai-models-locally-with-docker-model-runner-5elb

    Outillage

    Jetbrains défend la suppression des commentaires négatifs sur son assistant IA https://devclass.com/2025/04/30/jetbrains-defends-removal-of-negative-reviews-for-unpopular-ai-assistant/?td=rt-3a

    • L'IA Assistant de JetBrains, lancée en juillet 2023, a été téléchargée plus de 22 millions de fois mais n'est notée que 2,3 sur 5.
    • Des utilisateurs ont remarqué que certaines critiques négatives étaient supprimées, ce qui a provoqué une réaction négative sur les réseaux sociaux.
    • Un employé de JetBrains a expliqué que les critiques ont été supprimées soit parce qu'elles mentionnaient des problèmes déjà résolus, soit parce qu'elles violaient leur politique concernant les "grossièretés, etc."
    • L'entreprise a reconnu qu'elle aurait pu mieux gérer la situation, un représentant déclarant : "Supprimer plusieurs critiques d'un coup sans préavis semblait suspect. Nous aurions dû au moins publier un avis et fournir plus de détails aux auteurs."
    • Parmi les problèmes de l'IA Assistant signalés par les utilisateurs figurent : un support limité pour les fournisseurs de modèles tiers, une latence notable, des ralentissements fréquents, des fonctionnalités principales verrouillées aux services cloud de JetBrains, une expérience utilisateur incohérente et une documentation insuffisante.
    • Une plainte courante est que l'IA Assistant s'installe sans permission. Un utilisateur sur Reddit l'a qualifié de "plugin agaçant qui s'auto-répare/se réinstalle comme un phénix".
    • JetBrains a récemment introduit un niveau gratuit et un nouvel agent IA appelé Junie, destiné à fonctionner parallèlement à l'IA Assistant, probablement en réponse à la concurrence entre fournisseurs. Mais il est plus char a faire tourner.
    • La société s'est engagée à explorer de nouvelles approches pour traiter les mises à jour majeures différemment et envisage d'implémenter des critiques par version ou de marquer les critiques comme "Résolues" avec des liens vers les problèmes correspondants au lieu de les supprimer.
    • Contrairement à des concurrents comme Microsoft, AWS ou Google, JetBrains commercialise uniquement des outils et services de développement et ne dispose pas d'une activité cloud distincte sur laquelle s'appuyer.

    Vos images de README et fichiers Markdown compatibles pour le dark mode de GitHub: https://github.blog/developer-skills/github/how-to-make-your-images-in-markdown-on-github-adjust-for-dark-mode-and-light-mode/

    • Seulement quelques lignes de pure HTML pour le faire
    Architecture

    Alors, les DTOs, c'est bien ou c'est pas bien ? https://codeopinion.com/dtos-mapping-the-good-the-bad-and-the-excessive/

    • Utilité des DTOs : Les DTOs servent à transférer des données entre les différentes couches d'une application, en mappant souvent les données entre différentes représentations (par exemple, entre la base de données et l'interface utilisateur).
    • Surutilisation fréquente : L'article souligne que les DTOs sont souvent utilisés de manière excessive, notamment pour créer des API HTTP qui ne font que refléter les entités de la base de données, manquant ainsi l'opportunité de composer des données plus riches.
    • Vraie valeur : La valeur réelle des DTOs réside dans la gestion du couplage entre les couches et la composition de données provenant de sources multiples en formes optimisées pour des cas d'utilisation spécifiques.
    • Découplage : Il est suggéré d'utiliser les DTOs pour découpler les modèles de données internes des contrats externes (comme les API), ce qui permet une évolution et une gestion des versions indépendantes.
    • Exemple avec CQRS : Dans le cadre de CQRS (Command Query Responsibility Segregation), les réponses aux requêtes (queries) agissent comme des DTOs spécifiquement adaptés aux besoins de l'interface utilisateur, pouvant inclure des données de diverses sources.
    • Protection des données internes : Les DTOs aident à distinguer et protéger les modèles de données internes (privés) des changements externes (publics).
    • Éviter l'excès : L'auteur met en garde contre les couches de mapping excessives (mapper un DTO vers un autre DTO) qui n'apportent pas de valeur ajoutée.
    • Création ciblée : Il est conseillé de ne créer des DTOs que lorsqu'ils résolvent des problèmes concrets, tels que la gestion du couplage ou la facilitation de la composition de données.
    Méthodologies

    Même Guillaume se met au "vibe coding" https://glaforge.dev/posts/2025/05/02/vibe-coding-an-mcp-server-with-micronaut-and-gemini/

    • Selon Andrey Karpathy, c'est le fait de POC-er un proto, une appli jetable du weekend https://x.com/karpathy/status/1886192184808149383
    • Mais Simon Willison s'insurge que certains confondent coder avec l'assistance de l'IA avec le vibe coding https://simonwillison.net/2025/May/1/not-vibe-coding/
    • Guillaume c'est ici amusé à développer un serveur MCP avec Micronaut, en utilisant Gemini, l'IA de Google.
    • Contrairement à Quarkus ou Spring Boot, Micronaut n'a pas encore de module ou de support spécifique pour faciliter la création de serveur MCP
    Sécurité

    Une faille de sécurité 10/10 sur Tomcat https://www.it-connect.fr/apache-tomcat-cette-faille-activement-exploitee-seulement-30-heures-apres-sa-divulgation-patchez/

    • Une faille de sécurité critique (CVE-2025-24813) affecte Apache Tomcat, permettant l'exécution de code à distance
    • Cette vulnérabilité est activement exploitée seulement 30 heures après sa divulgation du 10 mars 2025
    • L'attaque ne nécessite aucune authentification et est particulièrement simple à exécuter
    • Elle utilise une requête PUT avec une charge utile Java sérialisée encodée en base64, suivie d'une requête GET
    • L'encodage en base64 permet de contourner la plupart des filtres de sécurité
    • Les serveurs vulnérables utilisent un stockage de session basé sur des fichiers (configuration répandue)
    • Les versions affectées sont : 11.0.0-M1 à 11.0.2, 10.1.0-M1 à 10.1.34, et 9.0.0.M1 à 9.0.98
    • Les mises à jour recommandées sont : 11.0.3+, 10.1.35+ et 9.0.99+
    • Les experts prévoient des attaques plus sophistiquées dans les prochaines phases d'exploitation (upload de config ou jsp)

    Sécurisation d'un serveur ssh https://ittavern.com/ssh-server-hardening/

    • un article qui liste les configurations clés pour sécuriser un serveur SSH
    • par exemple, enlever password authentigfication, changer de port, desactiver le login root, forcer le protocol ssh 2,
    • certains que je ne connaissais pas comme MaxStartups qui limite le nombre de connections non authentifiées concurrentes
    • Port knocking est une technique utile mais demande une approche cliente consciente du protocol

    Oracle admet que les identités IAM de ses clients ont leaké https://www.theregister.com/2025/04/08/oracle_cloud_compromised/

    • Oracle a confirmé à certains clients que son cloud public a été compromis, alors que l'entreprise avait précédemment nié toute intrusion.
    • Un pirate informatique a revendiqué avoir piraté deux serveurs d'authentification d'Oracle et volé environ six millions d'enregistrements, incluant des clés de sécurité privées, des identifiants chiffrés et des entrées LDAP.
    • La faille exploitée serait la vulnérabilité CVE-2021-35587 dans Oracle Access Manager, qu'Oracle n'avait pas corrigée sur ses propres systèmes.
    • Le pirate a créé un fichier texte début mars sur login.us2.oraclecloud.com contenant son adresse email pour prouver son accès.
    • Selon Oracle, un ancien serveur contenant des données vieilles de huit ans aurait été compromis, mais un client affirme que des données de connexion aussi récentes que 2024 ont été dérobées.
    • Oracle fait face à un procès au Texas concernant cette violation de données.
    • Cette intrusion est distincte d'une autre attaque contre Oracle Health, sur laquelle l'entreprise refuse de commenter.
    • Oracle pourrait faire face à des sanctions sous le RGPD européen qui exige la notification des parties affectées dans les 72 heures suivant la découverte d'une fuite de données.
    • Le comportement d'Oracle consistant à nier puis à admettre discrètement l'intrusion est inhabituel en 2025 et pourrait mener à d'autres actions en justice collectives.

    Une GitHub action très populaire compromise https://www.stepsecurity.io/blog/harden-runner-detection-tj-actions-changed-files-action-is-compromised

    • Compromission de l'action tj-actions/changed-files : En mars 2025, une action GitHub très utilisée (tj-actions/changed-files) a été compromise. Des versions modifiées de l'action ont exposé des secrets CI/CD dans les logs de build.
    • Méthode d'attaque : Un PAT compromis a permis de rediriger plusieurs tags de version vers un commit contenant du code malveillant.
    • Détails du code malveillant : Le code injecté exécutait une fonction Node.js encodée en base64, qui téléchargeait un script Python. Ce script parcourait la mémoire du runner GitHub à la recherche de secrets (tokens, clés…) et les exposait dans les logs. Dans certains cas, les données étaient aussi envoyées via une requête réseau.
    • Période d'exposition : Les versions compromises étaient actives entre le 12 et le 15 mars 2025. Tout dépôt, particulièrement ceux publiques, ayant utilisé l'action pendant cette période doit être considéré comme potentiellement exposé.
    • Détection : L'activité malveillante a été repérée par l'analyse des comportements inhabituels pendant l'exécution des workflows, comme des connexions réseau inattendues.
    • Réaction : GitHub a supprimé l'action compromise, qui a ensuite été nettoyée.
    • Impact potentiel : Tous les secrets apparaissant dans les logs doivent être considérés comme compromis, même dans les dépôts privés, et régénérés sans délai.
    Loi, société et organisation

    Les startup the YCombinateur ont les plus fortes croissances de leur histoire https://www.cnbc.com/2025/03/15/y-combinator-startups-are-fastest-growing-in-fund-history-because-of-ai.html

    • Les entreprises en phase de démarrage à Silicon Valley connaissent une croissance significative grâce à l'intelligence artificielle.
    • Le PDG de Y Combinator, Garry Tan, affirme que l'ensemble des startups de la dernière cohorte a connu une croissance hebdomadaire de 10% pendant neuf mois.
    • L'IA permet aux développeurs d'automatiser des tâches répétitives et de générer du code grâce aux grands modèles de langage.
    • Pour environ 25% des startups actuelles de YC, 95% de leur code a été écrit par l'IA.
    • Cette révolution permet aux entreprises de se développer avec moins de personnel - certaines atteignant 10 millions de dollars de revenus avec moins de 10 employés.
    • La mentalité de "croissance à tout prix" a été remplacée par un renouveau d'intérêt pour la rentabilité.
    • Environ 80% des entreprises présentées lors du "demo day" étaient centrées sur l'IA, avec quelques startups en robotique et semi-conducteurs.
    • Y Combinator investit 500 000 dollars dans les startups en échange d'une participation au capital, suivi d'un programme de trois mois.

    Red Hat middleware (ex-jboss) rejoint IBM https://markclittle.blogspot.com/2025/03/red-hat-middleware-moving-to-ibm.html

    • Les activités Middleware de Red Hat (incluant JBoss, Quarkus, etc.) vont être transférées vers IBM, dans l'unité dédiée à la sécurité des données, à l'IAM et aux runtimes.
    • Ce changement découle d'une décision stratégique de Red Hat de se concentrer davantage sur le cloud hybride et l'intelligence artificielle.
    • Mark Little explique que ce transfert était devenu inévitable, Red Hat ayant réduit ses investissements dans le Middleware ces dernières années.
    • L'intégration vise à renforcer l'innovation autour de Java en réunissant les efforts de Red Hat et IBM sur ce sujet.
    • Les produits Middleware resteront open source et les clients continueront à bénéficier du support habituel sans changement.
    • Mark Little affirme que des projets comme Quarkus continueront à être soutenus et que cette évolution est bénéfique pour la communauté Java.

    Un an de commonhaus https://www.commonhaus.org/activity/253.html

    • un an, démarré sur les communautés qu'ils connaissaient bien
    • maintenant 14 projets et put en accepter plus
    • confiance, gouvernance legère et proteger le futur des projets
    • automatisation de l'administratif, stabiilité sans complexité, les developpeurs au centre du processus de décision
    • ils ont besoins de members et supporters (financiers)
    • ils veulent accueillir des projets au delà de ceux du cercles des Java Champions

    Spring Cloud Data Flow devient un produit commercial et ne sera plus maintenu en open source https://spring.io/blog/2025/04/21/spring-cloud-data-flow-commercial

    • Peut-être sous l'influence de Broadcom, Spring se met à mettre en mode propriétaire des composants du portefeuille Spring
    • ils disent que peu de gens l'utilisaent en mode OSS et la majorité venait d'un usage dans la plateforme Tanzu
    • Maintenir en open source le coutent du temps qu'ils son't pas sur ces projets.

    La CNCF protège le projet NATS, dans la fondation depuis 2018, vu que la société Synadia qui y contribue souhaitait reprendre le contrôle du projet https://www.cncf.io/blog/2025/04/24/protecting-nats-and-the-integrity-of-open-source-cncfs-commitment-to-the-community/

    • CNCF : Protège projets OS, gouvernance neutre.
    • Synadia vs CNCF : Veut retirer NATS, licence non-OS (BUSL).
    • CNCF : Accuse Synadia de "claw back" (reprise illégitime).
    • Revendications Synadia : Domaine nats.io, orga GitHub.
    • Marque NATS : Synadia n'a pas transféré (promesse rompue malgré aide CNCF).
    • Contestation Synadia : Juge règles CNCF "trop vagues".
    • Vote interne : Mainteneurs Synadia votent sortie CNCF (sans communauté).
    • Support CNCF : Investissement majeur ($ audits, légal), succès communautaire (>700 orgs).
    • Avenir NATS (CNCF) : Maintien sous Apache 2.0, gouvernance ouverte.
    • Actions CNCF : Health check, appel mainteneurs, annulation marque Synadia, rejet demandes.
    • Mais finalement il semble y avoir un bon dénouement :
    • https://www.cncf.io/announcements/2025/05/01/cncf-and-synadia-align-on-securing-the-future-of-the-nats-io-project/
    • Accord pour l'avenir de NATS.io : La Cloud Native Computing Foundation (CNCF) et Synadia ont conclu un accord pour sécuriser le futur du projet NATS.io.
    • Transfert des marques NATS : Synadia va céder ses deux enregistrements de marque NATS à la Linux Foundation afin de renforcer la gouvernance ouverte du projet.
    • Maintien au sein de la CNCF : L'infrastructure et les actifs du projet NATS resteront sous l'égide de la CNCF, garantissant ainsi sa stabilité à long terme et son développement en open source sous licence Apache-2.0.
    • Reconnaissance et engagement : La Linux Foundation, par la voix de Todd Moore, reconnaît les contributions de Synadia et son soutien continu. Derek Collison, PDG de Synadia, réaffirme l'engagement de son entreprise envers NATS et la collaboration avec la Linux Foundation et la CNCF.
    • Adoption et soutien communautaire : NATS est largement adopté et considéré comme une infrastructure critique. Il bénéficie d'un fort soutien de la communauté pour sa nature open source et l'implication continue de Synadia.

    Finalement, Redis revient vers une licence open source OSI, avec la AGPL https://foojay.io/today/redis-is-now-available-under-the-agplv3-open-source-license/

    • Redis passe à la licence open source AGPLv3 pour contrer l'exploitation par les fournisseurs cloud sans contribution.
    • Le passage précédent à la licence SSPL avait nui à la relation avec la communauté open source.
    • Salvatore Sanfilippo (antirez) est revenu chez Redis.
    • Redis 8 adopte la licence AGPL, intègre les fonctionnalités de Redis Stack (JSON, Time Series, etc.) et introduit les "vector sets" (le support de calcul vectoriel développé par Salvatore).
    • Ces changements visent à renforcer Redis en tant que plateforme appréciée des développeurs, conformément à la vision initiale de Salvatore.
    Conférences

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    9 May 2025, 8:24 am
  • 1 hour 1 minute
    LCC 324 - Devoxx France 2025 en live

    Arnaud, Antonio, Guillaume et Emmanuel font la clôture de Devoxx France dans la fumée et la bonne humeur avec l'aide des organisateurs de Devoxx et surtout les inimitables polos rouges !

    Enregistré le 25 avril 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-324.mp3 ou en vidéo sur YouTube.

    News

    Les news c'est Devoxx France bien sûr.

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    29 April 2025, 8:48 am
  • 1 hour 10 minutes
    LCC 323 - L'accessibilité des messageries chiffrées

    Dans cet épisode, Emmanuel et Arnaud discutent des dernières nouvelles du dev, en mettant l'accent sur Java, l'intelligence artificielle, et les nouvelles fonctionnalités des versions JDK 24 et 25. Ils abordent également des sujets comme Quarkus, l'accessibilité des sites web, et l'impact de l'IA sur le trafic web. Cette conversation aborde les approches pour les devs en matière d'intelligence artificielle et de développement logiciel. On y discute notamment des défis et des bénéfices de l'utilisation de l'IA. Enfin, ils partagent leurs réflexions sur l'importance des conférences pour le développement professionnel.

    Enregistré le 14 mars 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-323.mp3 ou en vidéo sur YouTube.

    News Langages

    Java Metal https://www.youtube.com/watch?v=yup8gIXxWDU

    • Peut-être qu'on la déjà partagé ?

    Article d'opinion Java coming for AI https://thenewstack.io/2025-is-the-last-year-of-python-dominance-in-ai-java-comin/

    • 2025 pourrait être la dernière année où Python domine l'IA.
    • Java devient un concurrent sérieux dans le domaine.
    • En 2024, Python était toujours en tête, Java restait fort en entreprise, et Rust gagnait en popularité.
    • Java est de plus en plus utilisé pour l'AI remettant en cause la suprématie de Python.
    • article vient de javaistes
    • la domination de python est cluturelle et plus technique (enfin pour les ML lib c'est encore technique)
    • projets paname et babylon changent la donne
    • JavaML est populaire

    L'almanach java sur les versions https://javaalmanac.io/

    • montre kes APIs et les diff entre versions
    • puis les notes ou la spec java

    Les nouvelles de JDK 24 et du futur 25 https://www.infoq.com/news/2025/02/java-24-so-far/?utm_campaign=infoq_content&utm_source=infoq&utm_medium=feed&utm_term=global

    • JDK 24 a atteint sa première phase de release candidate et sera officiellement publié le 18 mars 2025.
    • 24 nouvelles fonctionnalités (JEPs) réparties en 5 catégories : Core Java Library (7), Java Language Specification (4), Security Library (4), HotSpot (8) et Java Tools (1).
    • Project Amber : JEP 495 "Simple Source Files and Instance Main Methods" en quatrième preview, visant à simplifier l'écriture des premiers programmes Java pour les débutants.
    • Project Loom : JEP 487 "Scoped Values" en quatrième preview, permettant le partage de données immuables entre threads, particulièrement utile avec les virtual threads.
    • Project Panama : JEP 489 "Vector API" en neuvième incubation, continuera d'incuber jusqu'à ce que les fonctionnalités nécessaires de Project Valhalla soient disponibles.
    • Project Leyden : JEP 483 "Ahead-of-Time Class Loading & Linking" pour améliorer le temps de démarrage en rendant les classes d'une application instantanément disponibles au démarrage de la JVM.
    • Sécurité quantique : Deux JEPs (496 et 497) introduisant des algorithmes résistants aux ordinateurs quantiques pour la cryptographie, basés sur les réseaux modulaires.
    • Sécurité renforcée : JEP 486 propose de désactiver définitivement le Security Manager, tandis que JEP 478 introduit une API de dérivation de clés.
    • Optimisations HotSpot : JEP 450 "Compact Object Headers" (expérimental) pour réduire la taille des en-têtes d'objets de 96-128 bits à 64 bits sur les architectures 64 bits. (a ne aps utiliser en prod!)
    • Améliorations GC : JEP 404 "Generational Shenandoah" (expérimental) introduit un mode générationnel pour le Garbage Collector Shenandoah, tout en gardant le non generationel.
    • Évolution des ports : Windows 32-bit x86 ca sent le sapin
    • JEP 502 dans JDK 25 : Introduction des "Stable Values" (preview), anciennement "Computed Constants", offrant les avantages des champs final avec plus de flexibilité pour l'initialisation.
    • Points Supplémentaires sur JDK 25
    • Date de sortie : JDK 25 est prévu pour septembre 2025 et représentera la prochaine version LTS (Long-Term Support) après JDK 21.
    • Finalisation de l'on-ramp : Gavin Bierman a annoncé son intention de finaliser la fonction "Simple Source Files" dans JDK 25, après quatre previews successives.
    • CDS Object Streaming : Le JEP Draft 8326035 propose d'ajouter un mécanisme d'archivage d'objets pour Class-Data Sharing (CDS) dans ZGC, avec un format d'archivage et un chargeur unifiés.
    • HTTP/3 supporté dans HttpClient

    Un article sur l'approche de Go pour éviter les attaques par chemin de fichier https://go.dev/blog/osroot

    Librairies

    Quarkus 3.19 es sorti https://quarkus.io/blog/quarkus-3-19-1-released/

    • UBI 9 par defaut pour les containers
    • En plus de AppCDS, support tu cache AOT (JEP 483) pour demarrer encore plus rapidement
    • Preuve de possession dans OAuth tokers 2

    Mario Fusco sur les patterns d'agents en Quarkus https://quarkus.io/blog/agentic-ai-with-quarkus/ et https://quarkus.io/blog/agentic-ai-with-quarkus-p2/

    • premier article sur les patterns de workflow
    • chainer, paralleliser ou router
    • avec des exemples de code qui tournent
    • les agents a proprement parler (le LLM qui decide du workflow)
    • les agents ont des toolbox que le LLM peut decided d'invoquer
    • Le code va dans les details et permet de mettre les interactions en lumiere
    • tracing rend les choses visuelles
    Web

    Le European Accessibility Act (EAA) https://martijnhols.nl/blog/the-european-accessibility-act-for-websites-and-apps

    • Loi européenne sur l'accessibilité (EAA) adoptée en 2019
    • Vise à rendre sites web et apps accessibles aux personnes handicapées
    • Suivre les normes WCAG 2.1 AA (clarté, utilisabilité, compatibilité)
    • Entreprises concernées : banques, e-commerce, transports, etc.
    • Date limite de mise en conformité : 28 juin 2025
    • 2025 c'est pour les nouveaux developpements
    • 2027 c'est pour les applications existantes.
    • bon et je fais comment pour savoir si le site web des cast codeurs est conforme ?

    API Popover https://web.dev/blog/popover-baseline?hl=en

    • L'API Popover est maintenant disponible dans tous les navigateurs majeurs
    • Ajoutée à Baseline le 27 janvier 2025
    • Permet de créer des popovers natifs en HTML, sans JavaScript complexe
    • Exemple : Ouvrir
    • Contenu du popover
    • Problème initial (2024) : Bug sur iOS empêchant la fermeture des popovers

    Intégrer un front-end React dans une app Spring-Boot https://bootify.io/frontend/react-spring-boot-integration.html

    Data et Intelligence Artificielle

    Traffic des sites web venant de IA https://ahrefs.com/blog/ai-traffic-study/

    • le AIEO apres le SEO va devenir un gros business vu que les modèles ont tendance a avoir leurs chouchous techniques ou de reference.
    • 63% des sites ont au moins un referal viennent d'une IA
    • 50% ChatGPT, puis plrplexity et enfin Gemini, bah et LeChat alors?
    • 0,17% du traffic des sites vient de l'IA. Et en meme temps l'AI resume plutot que pointe donc c'est logique

    Granite 3.2 est sorti https://www.infoq.com/news/2025/03/ibm-granite-3-2/

    • IBM sort Granite 3.2, un modèle IA avancé.
    • Meilleur raisonnement et nouvelles capacités multimodales.
    • Granite Vision 3.2 excelle en compréhension d'images et de documents.
    • Granite Guardian 3.2 détecte les risques dans les réponses IA.
    • Modèles plus petits et efficaces pour divers usages.
    • Améliorations en raisonnement mathématique et prévisions temporelles.
    • les trucs interessants de Granite c'est sa petite taille et son cote "vraiment" open source

    Prompt Engineering - article détaillé https://www.infoq.com/articles/prompt-engineering/

    • Le prompt engineering, c'est l'art de bien formuler les instructions pour guider l'IA.
    • Accessible à tous, il ne remplace pas la programmation mais la complète.
    • Techniques clés : few-shot learning, chain-of-thought, tree-of-thought.
    • Avantages : flexibilité, rapidité, meilleure interaction avec l'IA.
    • Limites : manque de précision et dépendance aux modèles existants.
    • Futur : un outil clé pour améliorer l'IA et le développement logiciel.

    QCon San Francisco - Les agents AI - Conference https://www.infoq.com/presentations/ai-agents-infrastructure/

    • Sujet : Infrastructure pour agents d'IA.
    • Technologies : RAG et bases de données vectorielles.
    • Rôle des agents d'IA : Automatiser des tâches, prévoir des besoins, superviser.
    • Expérience : Shruti Bhat de Oracle à Rockset (acquis par OpenAI).
    • Objectif : Passer des applis classiques aux agents IA intelligents.
    • Défis : Améliorer la recherche en temps réel, l'indexation et la récupération.
    • Nous concernant:
    • Évolution des rôles : Les développeurs passent à des rôles plus stratégiques.
    • Adaptation nécessaire : Les développeurs doivent s'adapter aux nouvelles technologies.

    Official Java SDK for MCP & Spring AI https://spring.io/blog/2025/02/14/mcp-java-sdk-released-2

    • Désormais une implémentation officielle aux côtés des SDK Python, TypeScript et Kotlin. ( https://modelcontextprotocol.io/ )
    • Prise en charge de Stdio-based transport, SSE (via HTTP) et intégration avec Spring WebFlux et WebMVC.
    • Intégration avec Spring AI, configuration simplifiée pour les applications Spring Boot (different starters disponibles)

    Codez avec Claude https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/overview

    • Claude Code est en beta, plus de liste d'attente
    • Un outil de codage agentique intégré au terminal, capable de comprendre votre base de code et d'accélérer le développement grâce à des commandes en langage naturel.
    • Les fonctionnalités permettent de comprendre le code, le refactorer, tester, debugger, …

    Gemini Code Assist est gratuit https://blog.google/technology/developers/gemini-code-assist-free/

    • Pour un usage personnel.
    • Pas besoin de compte.
    • Pas de limite.
    • 128k token input.

    Guillaume démarre une série d'articles sur le RAG (niveau avancé). Le premier sur Sentence Window Retrievalhttps://glaforge.dev/posts/2025/02/25/advanced-rag-sentence-window-retrieval/

    • Guillaume propose une technique qui améliore les résultats de rechercher de Retrieval Augmented Generation
    • L'idée est de calculer des vecteurs embeddings sur des phrases, par exemple, mais de retourner un contexte plus large
    • L'intérêt, c'est d'avoir des calculs de similarité de vector embedding qui ont de bons scores (sans dilution de sens) de similarité, mais de ne pas perdre des informations sur le contexte dans lequel cette phrase se situe

    GitHub Copilot edits en GA, GitHub Copilot en mode agent dans VSCode Insiders https://github.blog/news-insights/product-news/github-copilot-the-agent-awakens/

    • Copilot Edits permet via le chat de modifier plusieurs fichiers en même temps, ce qui simplifie les refactoring
    • Copilot en mode agent ajoute un mode autonome (Agentic AI) qui va tout seul chercher les modifications à faire dans votre code base.
    • "what could possibly go wrong?"
    Méthodologies

    Article d'opinion interessant sur AI et le code assistant de Addy Osmani https://addyo.substack.com/p/the-70-problem-hard-truths-about

    • Un article de l'année dernière de Addy Osmani https://addyo.substack.com/p/10-lessons-from-12-years-at-google
    • plusieurs types d'aide IA
    • Ceux pour boostrapper, dun figma ou d'une image et avoir un proto non fonctionnel en quelques jours
    • Ceux pour iterer sur du code donc plus long terme
    • on va faire une interview sur les assistants de code IA
    • Le cout de la vitesse de l'ia
    • les dev senior refactur et modifie le code proposé pour se l'approprier, chnger l'architecture etc
    • donc basé sur leur connaissance
    • appliquer ce qu'on connait deja amis plus vite est un pattern different d'apprendre avec l'IA
    • explore des patterns d'approche
    • et la prospective sur le futur
    Loi, société et organisation

    Elon Musk essaie d'acheter Open AI https://www.bbc.com/news/articles/cpdx75zgg88o

    • La réponse:
    • "non merci mais on peut racheter twiter pour 9,74 milliars si tu veux"

    Avec la loi narcotrafic votée au sénat, Signal ne serait plus disponible en France https://www.clubic.com/actualite-555135-avec-la-loi-narcotrafic-signal-quittera-la-france.html

    • en plus de légaliser les logiciels espions s'appuyant sur les failles logiciel
    • La loi demande aux messageries de laisser l'état accéder aux conversations
    • Donc une backdoor avec une clé etatique par exemple
    • Une backdoor comme celle des téléphones filaires américains mis en place il y a des années et maintenant exploitée par l'espionnage chinois
    • Signal à une position ferme, soit c'est sécurisé soit on sort d'un pays
    • Olvid WhatsApp et iMessage sont aussi visée par exemple
    • La loi défini la cible comme la criminalité organisée : les classiques mais aussi les gilets jaunes, les opposants au projet de Bure, les militants aidant les personnes exilées à Briançon, ou encore les actions contre le cimentier Lafarge à Bouc-Bel-Air et à Évreux
    • Donc plus large que ce que les gens pensent.
    Conférences

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    17 March 2025, 10:26 am
  • 1 hour 17 minutes
    LCC 322 - Maaaaveeeeen 4 !

    Arnaud et Emmanuel discutent des nouvelles de ce mois. On y parle intégrité de JVM, fetch size de JDBC, MCP, de prompt engineering, de DeepSeek bien sûr mais aussi de Maven 4 et des proxy de répository Maven. Et d'autres choses encore, bonne lecture.

    Enregistré le 7 février 2025

    Téléchargement de l'épisode LesCastCodeurs-Episode-322.mp3 ou en vidéo sur YouTube.

    News Langages

    Les evolutions de la JVM pour augmenter l'intégrité https://inside.java/2025/01/03/evolving-default-integrity/

    • un article sur les raisons pour lesquelles les editeurs de frameworks et les utilisateurs s'arrachent les cheveux et vont continuer
    • garantir l'integrite du code et des données en enlevant des APIs existantes historiquemnt
    • agents dynamiques, setAccessible, Unsafe, JNI
    • Article expliques les risques percus par les mainteneurs de la JVM
    • Franchement c'est un peu leg sur les causes l'article, auto propagande

    JavaScript Temporal, enfin une API propre et moderne pour gérer les dates en JS https://developer.mozilla.org/en-US/blog/javascript-temporal-is-coming/

    • JavaScript Temporal est un nouvel objet conçu pour remplacer l'objet Date, qui présente des défauts.
    • Il résout des problèmes tels que le manque de prise en charge des fuseaux horaires et la mutabilité.
    • Temporal introduit des concepts tels que les instants, les heures civiles et les durées.
    • Il fournit des classes pour gérer diverses représentations de date/heure, y compris celles qui tiennent compte du fuseau horaire et celles qui n'en tiennent pas compte.
    • Temporal simplifie l'utilisation de différents calendriers (par exemple, chinois, hébreu).
    • Il comprend des méthodes pour les comparaisons, les conversions et le formatage des dates et des heures.
    • La prise en charge par les navigateurs est expérimentale, Firefox Nightly ayant l'implémentation la plus aboutie.
    • Un polyfill est disponible pour essayer Temporal dans n'importe quel navigateur.
    Librairies

    Un article sur les fetch size du JDBC et les impacts sur vos applications https://in.relation.to/2025/01/24/jdbc-fetch-size/

    • qui connait la valeur fetch size par default de son driver?
    • en fonction de vos use cases, ca peut etre devastateur
    • exemple d'une appli qui retourne 12 lignes et un fetch size de oracle a 10, 2 a/r pour rien
    • et si c'est 50 lignres retournées
    • la base de donnée est le facteur limitant, pas Java
    • donc monter sont fetch size est avantageux, on utilise la memoire de Java pour eviter la latence

    Quarkus annouce les MCP servers project pour collecter les servier MCP en Java https://quarkus.io/blog/introducing-mcp-servers/

    • MCP d'Anthropic
    • introspecteur de bases JDBC
    • lecteur de filke system
    • Dessine en Java FX
    • demarrables facilement avec jbang
    • et testes avec claude desktop, goose et mcp-cli
    • permet d'utliser le pouvoir des librarires Java de votre IA
    • d'ailleurs Spring a la version 0.6 de leur support MCP https://spring.io/blog/2025/01/23/spring-ai-mcp-0
    Infrastructure

    Apache Flink sur Kibernetes https://www.decodable.co/blog/get-running-with-apache-flink-on-kubernetes-2

    • un article tres complet ejn deux parties sur l'installation de Flink sur Kubernetes
    • installation, setup
    • mais aussi le checkpointing, la HA, l'observablité
    Data et Intelligence Artificielle

    10 techniques de prompt engineering https://medium.com/google-cloud/10-prompt-engineering-techniques-every-beginner-should-know-bf6c195916c7

    • Si vous voulez aller plus loin, l'article référence un très bon livre blanc sur le prompt engineering https://www.kaggle.com/whitepaper-prompt-engineering
    • Les techniques évoquées :
      1. Zero-Shot Prompting:
      • On demande directement à l'IA de répondre à une question sans lui fournir d'exemple préalable. C'est comme si on posait une question à une personne sans lui donner de contexte.
      1. Few-Shot Prompting:
      • On donne à l'IA un ou plusieurs exemples de la tâche qu'on souhaite qu'elle accomplisse. C'est comme montrer à quelqu'un comment faire quelque chose avant de lui demander de le faire.
      1. System Prompting:
      • On définit le contexte général et le but de la tâche pour l'IA. C'est comme donner à l'IA des instructions générales sur ce qu'elle doit faire.
      1. Role Prompting:
      • On attribue un rôle spécifique à l'IA (enseignant, journaliste, etc.). C'est comme demander à quelqu'un de jouer un rôle spécifique.
      1. Contextual Prompting:
      • On fournit des informations supplémentaires ou un contexte pour la tâche. C'est comme donner à quelqu'un toutes les informations nécessaires pour répondre à une question.
      1. Step-Back Prompting:
      • On pose d'abord une question générale, puis on utilise la réponse pour poser une question plus spécifique. C'est comme poser une question ouverte avant de poser une question plus fermée.
      1. Chain-of-Thought Prompting:
      • On demande à l'IA de montrer étape par étape comment elle arrive à sa conclusion. C'est comme demander à quelqu'un d'expliquer son raisonnement.
      1. Self-Consistency Prompting:
      • On pose plusieurs fois la même question à l'IA et on compare les réponses pour trouver la plus cohérente. C'est comme vérifier une réponse en la posant sous différentes formes.
      1. Tree-of-Thoughts Prompting:
      • On permet à l'IA d'explorer plusieurs chemins de raisonnement en même temps. C'est comme considérer toutes les options possibles avant de prendre une décision.
      1. ReAct Prompting:
      • On permet à l'IA d'interagir avec des outils externes pour résoudre des problèmes complexes. C'est comme donner à quelqu'un les outils nécessaires pour résoudre un problème.

    Les patterns GenAI the thoughtworks https://martinfowler.com/articles/gen-ai-patterns/

    • tres introductif et pre RAG
    • le direct prompt qui est un appel direct au LLM: limitations de connaissance et de controle de l'experience
    • eval: evaluer la sortie d'un LLM avec plusieurs techniques mais fondamentalement une fonction qui prend la demande, la reponse et donc un score numerique
    • evaluation via un LLM (le meme ou un autre), ou evaluation humaine
    • tourner les evaluations a partir de la chaine de build amis aussi en live vu que les LLMs puvent evoluer.
    • Decrit les embedding notament d'image amis aussi de texte avec la notion de contexte

    DeepSeek et la fin de la domination de NVidia https://youtubetranscriptoptimizer.com/blog/05_the_short_case_for_nvda

    • un article sur les raisons pour lesquelles NVIDIA va se faire cahllengert sur ses marges
    • 90% de marge quand meme parce que les plus gros GPU et CUDA qui est proprio
    • mais des approches ardware alternatives existent qui sont plus efficientes (TPU et gros waffle)
    • Google, MS et d'autres construisent leurs GPU alternatifs
    • CUDA devient de moins en moins le linga franca avec l'investissement sur des langages intermediares alternatifs par Apple, Google OpenAI etc
    • L'article parle de DeepSkeek qui est venu mettre une baffe dans le monde des LLMs
    • Ils ont construit un competiteur a gpt4o et o1 avec 5M de dollars et des capacites de raisonnements impressionnant
    • la cles c'etait beaucoup de trick d'optimisation mais le plus gros est d'avoir des poids de neurores sur 8 bits vs 32 pour les autres.
    • et donc de quatizer au fil de l'eau et au moment de l'entrainement
    • beaucoup de reinforcemnt learning innovatifs aussi
    • et des Mixture of Expert
    • donc ~50x moins chers que OpenAI
    • Donc plus besoin de GPU qui on des tonnes de vRAM
    • ah et DeepSeek est open source
    • un article de semianalytics change un peu le narratif
    • le papier de DeepSkeek en dit long via ses omissions
    • par ensemple les 6M c'est juste l'inference en GPU, pas les couts de recherches et divers trials et erreurs
    • en comparaison Claude Sonnet a coute 10M en infererence
    • DeepSeek a beaucoup de CPU pre ban et ceratins post bans evalués a 5 Milliards en investissement.
    • leurs avancées et leur ouverture reste extremement interessante

    Une intro à Apache Iceberg http://blog.ippon.fr/2025/01/17/la-revolution-des-donnees-lavenement-des-lakehouses-avec-apache-iceberg/

    • issue des limites du data lake. non structuré et des Data Warehouses aux limites en diversite de données et de volume
    • entrent les lakehouse
    • Et particulierement Apache Iceberg issue de Netflix
    • gestion de schema mais flexible
    • notion de copy en write vs merge on read en fonction de besoins
    • garantie atomicite, coherence, isoliation et durabilite
    • notion de time travel et rollback
    • partitions cachées (qui abstraient la partition et ses transfos) et evolution de partitions
    • compatbile avec les moteurs de calcul comme spark, trino, flink etc
    • explique la structure des metadonnées et des données

    Guillaume s'amuse à générer des histoires courtes de Science-Fiction en programmant des Agents IA avec LangChain4j et aussi avec des workflows https://glaforge.dev/posts/2025/01/27/an-ai-agent-to-generate-short-scifi-stories/ https://glaforge.dev/posts/2025/01/31/a-genai-agent-with-a-real-workflow/

    • Création d'un générateur automatisé de nouvelles de science-fiction à l'aide de Gemini et Imagen en Java, LangChain4j, sur Google Cloud.
    • Le système génère chaque nuit des histoires, complétées par des illustrations créées par le modèle Imagen 3, et les publie sur un site Web.
    • Une étape d'auto-réflexion utilise Gemini pour sélectionner la meilleure image pour chaque chapitre.
    • L'agent utilise un workflow explicite, drivé par le code Java, où les étapes sont prédéfinies dans le code, plutôt que de s'appuyer sur une planification basée sur LLM.
    • Le code est disponible sur GitHub et l'application est déployée sur Google Cloud.
    • L'article oppose les agents de workflow explicites aux agents autonomes, en soulignant les compromis de chaque approche. Car parfois, les Agent IA autonomes qui gèrent leur propre planning hallucinent un peu trop et n'établissent pas un plan correctement, ou ne le suive pas comme il faut, voire hallucine des "function call".
    • Le projet utilise Cloud Build, le Cloud Run jobs, Cloud Scheduler, Firestore comme base de données, et Firebase pour le déploiement et l'automatisation du frontend.
    • Dans le deuxième article, L'approche est différente, Guillaume utilise un outil de Workflow, plutôt que de diriger le planning avec du code Java.
    • L'approche impérative utilise du code Java explicite pour orchestrer le workflow, offrant ainsi un contrôle et une parallélisation précis.
    • L'approche déclarative utilise un fichier YAML pour définir le workflow, en spécifiant les étapes, les entrées, les sorties et l'ordre d'exécution.
    • Le workflow comprend les étapes permettant de générer une histoire avec Gemini 2, de créer une invite d'image, de générer des images avec Imagen 3 et d'enregistrer le résultat dans Cloud Firestore (base de donnée NoSQL).
    • Les principaux avantages de l'approche impérative sont un contrôle précis, une parallélisation explicite et des outils de programmation familiers.
      • Les principaux avantages de l'approche déclarative sont des définitions de workflow peut-être plus faciles à comprendre (même si c'est un YAML, berk !) la visualisation, l'évolutivité et une maintenance simplifiée (on peut juste changer le YAML dans la console, comme au bon vieux temps du PHP en prod).
    • Les inconvénients de l'approche impérative incluent le besoin de connaissances en programmation, les défis potentiels en matière de maintenance et la gestion des conteneurs.
    • Les inconvénients de l'approche déclarative incluent une création YAML pénible, un contrôle de parallélisation limité, l'absence d'émulateur local et un débogage moins intuitif.
    • Le choix entre les approches dépend des exigences du projet, la déclarative étant adaptée aux workflows plus simples.
    • L'article conclut que la planification déclarative peut aider les agents IA à rester concentrés et prévisibles.
    Outillage

    Vulnérabilité des proxy Maven https://github.blog/security/vulnerability-research/attacks-on-maven-proxy-repositories/

    • Quelque soit le langage, la techno, il est hautement conseillé de mettre en place des gestionnaires de repositories en tant que proxy pour mieux contrôler les dépendances qui contribuent à la création de vos produits
    • Michael Stepankin de l'équipe GitHub Security Lab a cherché a savoir si ces derniers ne sont pas aussi sources de vulnérabilité en étudiant quelques CVEs sur des produits comme JFrog Artifactory, Sonatype Nexus, et Reposilite
    • Certaines failles viennent de la UI des produits qui permettent d'afficher les artifacts (ex: mettez un JS dans un fichier POM) et même de naviguer dedans (ex: voir le contenu d'un jar / zip et on exploite l'API pour lire, voir modifier des fichiers du serveur en dehors des archives)
    • Les artifacts peuvent aussi être compromis en jouant sur les paramètres propriétaires des URLs ou en jouant sur le nomage avec les encodings.
    • Bref, rien n'est simple ni niveau. Tout système rajoute de la compléxité et il est important de les tenir à mettre à jour. Il faut surveiller activement sa chaine de distribution via différents moyens et ne pas tout miser sur le repository manager.
    • L'auteur a fait une présentation sur le sujet : https://www.youtube.com/watch?v=0Z_QXtk0Z54

    Apache Maven 4… Bientôt, c'est promis …. qu'est ce qu'il y aura dedans ? https://gnodet.github.io/maven4-presentation/

    • Et aussi https://github.com/Bukama/MavenStuff/blob/main/Maven4/whatsnewinmaven4.md
    • Apache Maven 4
      • Doucement mais surement …. c'est le principe d'un projet
      • Maven 4.0.0-rc-2 est dispo (Dec 2024).
      • Maven a plus de 20 ans et est largement utilisé dans l'écosystème Java.
      • La compatibilité ascendante a toujours été une priorité, mais elle a limité la flexibilité.
      • Maven 4 introduit des changements significatifs, notamment un nouveau schéma de construction et des améliorations du code.
    • Changements du POM
      • Séparation du Build-POM et du Consumer-POM :
        • Build-POM : Contient des informations propres à la construction (ex. plugins, configurations).
        • Consumer-POM : Contient uniquement les informations nécessaires aux consommateurs d'artefacts (ex. dépendances).
      • Nouveau Modèle Version 4.1.0 :
        • Utilisé uniquement pour le Build-POM, alors que le Consumer-POM reste en 4.0.0 pour la compatibilité.
        • Introduit de nouveaux éléments et en marque certains comme obsolètes.
      • Modules renommés en sous-projets :
        • "Modules" devient "Sous-projets" pour éviter la confusion avec les Modules Java.
        • L'élément remplace (qui reste pris en charge).
      • Nouveau type de packaging : "bom" (Bill of Materials) :
        • Différencie les POMs parents et les BOMs de gestion des dépendances.
        • Prend en charge les exclusions et les imports basés sur les classifiers.
      • Déclaration explicite du répertoire racine :
        • permet de définir explicitement le répertoire racine du projet.
        • Élimine toute ambiguïté sur la localisation des racines de projet.
      • Nouvelles variables de répertoire :
        • ${project.rootDirectory}, ${session.topDirectory} et ${session.rootDirectory} pour une meilleure gestion des chemins.
        • Remplace les anciennes solutions non officielles et variables internes obsolètes.
      • Prise en charge de syntaxes alternatives pour le POM
        • Introduction de ModelParser SPI permettant des syntaxes alternatives pour le POM.
        • Apache Maven Hocon Extension est un exemple précoce de cette fonctionnalité.
    • Améliorations pour les sous-projets
      • Versioning automatique des parents
        • Il n'est plus nécessaire de définir la version des parents dans chaque sous-projet.
        • Fonctionne avec le modèle de version 4.1.0 et s'étend aux dépendances internes au projet.
      • Support complet des variables compatibles CI
        • Le Flatten Maven Plugin n'est plus requis.
        • Prend en charge les variables comme ${revision} pour le versioning.
        • Peut être défini via maven.config ou la ligne de commande (mvn verify -Drevision=4.0.1).
      • Améliorations et corrections du Reactor
        • Correction de bug : Gestion améliorée de --also-make lors de la reprise des builds.
        • Nouvelle option --resume (-r) pour redémarrer à partir du dernier sous-projet en échec.
        • Les sous-projets déjà construits avec succès sont ignorés lors de la reprise.
        • Constructions sensibles aux sous-dossiers : Possibilité d'exécuter des outils sur des sous-projets sélectionnés uniquement.
        • Recommandation : Utiliser mvn verify plutôt que mvn clean install.
      • Autres Améliorations
        • Timestamps cohérents pour tous les sous-projets dans les archives packagées.
        • Déploiement amélioré : Le déploiement ne se produit que si tous les sous-projets sont construits avec succès.
    • Changements de workflow, cycle de vie et exécution
      • Java 17 requis pour exécuter Maven
        • Java 17 est le JDK minimum requis pour exécuter Maven 4.
        • Les anciennes versions de Java peuvent toujours être ciblées pour la compilation via Maven Toolchains.
        • Java 17 a été préféré à Java 21 en raison d'un support à long terme plus étendu.
      • Mise à jour des plugins et maintenance des applications
        • Suppression des fonctionnalités obsolètes (ex. Plexus Containers, expressions ${pom.}).
        • Mise à jour du Super POM, modifiant les versions par défaut des plugins.
        • Les builds peuvent se comporter différemment ; définissez des versions fixes des plugins pour éviter les changements inattendus.
        • Maven 4 affiche un avertissement si des versions par défaut sont utilisées.
      • Nouveau paramètre "Fail on Severity"
        • Le build peut échouer si des messages de log atteignent un niveau de gravité spécifique (ex. WARN).
        • Utilisable via --fail-on-severity WARN ou -fos WARN.
      • Maven Shell (mvnsh)
        • Chaque exécution de mvn nécessitait auparavant un redémarrage complet de Java/Maven.
        • Maven 4 introduit Maven Shell (mvnsh), qui maintient un processus Maven résident unique ouvert pour plusieurs commandes.
        • Améliore la performance et réduit les temps de build.
        • Alternative : Utilisez Maven Daemon (mvnd), qui gère un pool de processus Maven résidents.
    Architecture

    Un article sur les feature flags avec Unleash https://feeds.feedblitz.com//911939960/0/baeldungImplement-Feature-Flags-in-Java-With-Unleash

    • Pour A/B testing et des cycles de développements plus rapides pour « tester en prod »
    • Montre comment tourner sous docker unleash
    • Et ajouter la librairie a du code java pour tester un feature flag
    Sécurité

    Keycloak 26.1 https://www.keycloak.org/2025/01/keycloak-2610-released.html

    • detection des noeuds via la proble base de donnée aulieu echange reseau
    • virtual threads pour infinispan et jgroups
    • opentelemetry tracing supporté
    • et plein de fonctionalités de sécurité
    Loi, société et organisation

    Les grands morceaux du coût et revenus d'une conférence. Ici http://bdx.io|bdx.io https://bsky.app/profile/ameliebenoit33.bsky.social/post/3lgzslhedzk2a

    • 44% le billet
    • 52% les sponsors
    • 38% loc du lieu
    • 29% traiteur et café
    • 12% standiste
    • 5% frais speaker (donc pas tous)
    Ask Me Anything

    Julien de Provin: J'aime beaucoup le mode "continuous testing" de Quarkus, et je me demandais s'il existait une alternative en dehors de Quarkus, ou à défaut, des ressources sur son fonctionnement ? J'aimerais beaucoup avoir un outil agnostique utilisable sur les projets non-Quarkus sur lesquels j'intervient, quitte à y metttre un peu d'huile de coude (ou de phalange pour le coup).

    Conférences

    La liste des conférences provenant de Developers Conferences Agenda/List par Aurélie Vache et contributeurs :

    Nous contacter

    Pour réagir à cet épisode, venez discuter sur le groupe Google https://groups.google.com/group/lescastcodeurs

    Contactez-nous via X/twitter https://twitter.com/lescastcodeurs ou Bluesky https://bsky.app/profile/lescastcodeurs.com Faire un crowdcast ou une crowdquestion Soutenez Les Cast Codeurs sur Patreon https://www.patreon.com/LesCastCodeurs Tous les épisodes et toutes les infos sur https://lescastcodeurs.com/

    9 February 2025, 3:29 pm
  • More Episodes? Get the App