<?xml version="1.0" encoding="ISO-8859-1"?>

<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/">
	<channel>
		<title>Forum du club des développeurs et IT Pro - JetBrains</title>
		<link>https://www.developpez.net/forums/</link>
		<description>Forum consacré aux différents EDIs consacrés à JetBrains (IntelliJ IDEA, PHPStorm, WebStorm...)</description>
		<language>fr</language>
		<lastBuildDate>Mon, 02 Nov 2026 05:34:14 GMT</lastBuildDate>
		<generator>vBulletin</generator>
		<ttl>15</ttl>
		<image>
			<url>https://forum.developpez.be/images/misc/rss.png</url>
			<title>Forum du club des développeurs et IT Pro - JetBrains</title>
			<link>https://www.developpez.net/forums/</link>
		</image>
		<item>
			<title><![CDATA[La qualité du code ne change jamais - ou l'IA remet-elle cette idée en question ?]]></title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186386&amp;goto=newpost</link>
			<pubDate>Wed, 28 Oct 2026 09:47:50 GMT</pubDate>
			<description>*La qualité du code ne change...</description>
			<content:encoded><![CDATA[<div><b><font size="4">La qualité du code ne change jamais - ou l'IA remet-elle cette idée en question ? L'analyse statique associée à l'IA représente la solution, d'après JetBrains</font></b><br />
<br />
JetBrains est une société à responsabilité limitée internationale spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux développeurs et aux chefs de projet. L'entreprise a son siège social à Amsterdam et dispose de bureaux en Chine, en Europe et aux États-Unis. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter dans une machine virtuelle Java (JVM).<br />
<br />
Qodana est un outil d'analyse de la qualité du code qui utilise l'analyse statique pour aider les utilisateurs à réaliser des revues de code, à mettre en place des contrôles de qualité et à appliquer les directives relatives à la qualité du code. Lancé officiellement en juillet 2023, il est compatible avec les EDI de l'écosystème JetBrains, s'intègre aux pipelines CI/CD et prend en charge l'analyse de code dans plus de 60 langages de programmation.<br />
<br />
Cet article est adapté de l'intervention de Kai Schmithuesen lors du JetBrains Game Development Day 2026. Découvrez ci-dessous la vidéo complète de la présentation et la séance de questions-réponses, ou poursuivez votre lecture !<br />
<br />
<div style="text-align: center;">
<div class="video-container"><iframe class="restrain" title="YouTube video player" width="560" height="315" allowfullscreen src="//www.youtube.com/embed/ytMKtuZ4yYM?wmode=transparent&amp;fs=1" frameborder="0"></iframe></div>
</div><br />
Nous allons tout d’abord définir ce que nous entendons par « qualité du code », puis examiner son impact sur les résultats de l’entreprise, le rôle de l’IA dans ce domaine, son influence sur la qualité et les moyens de la préserver au sein de votre équipe.<br />
<br />
Vous pouvez appliquer les méthodologies décrites ici à de nombreuses solutions, mais nous allons également étudier un exemple concret avec Qodana.<br />
<br />
La qualité du code est un sujet qui a parfois tendance à être négligé, en particulier dans le développement de jeux vidéo où d’autres problèmes peuvent accaparer votre attention. Cependant, d’après les échanges que nous avons eus avec de nombreux clients de JetBrains lors de conférences sur le développement de jeux vidéo, il existe une prise de conscience quant à l’importance de ce sujet. Cela dit, il n’existe pas de bonnes pratiques établies dans le secteur du jeu vidéo ; c’est pourquoi nous partageons dans cette présentation certaines de ces bonnes pratiques issues d’autres secteurs.<br />
<br />
<b><font size="3">Qu’entend-on par « qualité du code » ?</font></b><br />
<br />
La définition de ce sujet, pourtant crucial, peut s’avérer « floue ». Si vous interrogez dix collègues, vous obtiendrez probablement autant de réponses différentes. Le premier point concerne l’exactitude.<br />
<br />
Exactitude : mon code fait-il ce pour quoi je l’ai conçu ?<br />
Performances : un aspect crucial pour les jeux vidéo, est-il suffisamment rapide ?<br />
Stabilité : le code plante-t-il ou non, et quel est son niveau de stabilité du point de vue des joueurs ?<br />
Sécurité : également importante si vous ne voulez pas faire la une de l’actualité du secteur parce que vous avez été piraté.<br />
Facilité de maintenance : mon code fonctionne-t-il aujourd’hui et fonctionnera-t-il encore dans quelques années ? Surtout que certains jeux restent en service pendant 10 à 12 ans.<br />
Réutilisabilité : c’est un sujet qui prend de plus en plus d’importance pour les grands studios : puis-je réutiliser le code que j’ai déjà développé pour d’autres projets ? Tous ces éléments vous donnent un aperçu de ce qu’implique la qualité du code.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679650d1793203065/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 34
Taille : 48,7 Ko"  style="float: CONFIG" /></div><br />
Si vous vous rendez sur des forums aussi animés que X ou LinkedIn, par exemple, vous constaterez que l’importance de la qualité du code fait l’objet d’un débat animé. D’une personne affirmant ne pas se soucier de l’aspect de son code à l’autre extrême, « Mon code doit être magnifique et irréprochable avant que je ne le publie », en passant par toutes les nuances intermédiaires. Les opinions divergent énormément.<br />
<br />
L’équipe de Qodana souligne que la qualité du code peut avoir un impact réel sur votre activité et sur l’accueil réservé à votre jeu. Un studio AAA a perdu 33 % de sa valeur une semaine après le lancement.<br />
<br />
Les temps de chargement de GTA ont été réduits de 70 % simplement en corrigeant deux petites failles dans le code. Le temps de chargement est passé de 6 à 2 minutes (grâce à un joueur), puis Dark Souls a été hors ligne pendant 2 mois en raison de failles d’exécution de code à distance (problème de sécurité) ; si vous perdez des joueurs au cours de ces deux mois, il y a de fortes chances qu’ils ne reviennent pas, ce qui a un impact concret sur le chiffre d’affaires. Un code de mauvaise qualité ne reste pas seulement de votre côté. Il se répercute sur vos joueurs, ce qui peut entraîner des demandes de remboursement et de mauvaises critiques.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679651d1793203070/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 30
Taille : 43,3 Ko"  style="float: CONFIG" /></div><br />
Lorsque l’on consulte IGN ou PC Gamer, la qualité, les bugs et la stabilité du jeu influencent toujours les notes. Cela détermine en fin de compte le nombre de joueurs que vous attirerez, et les jeux bogués mènent à des joueurs mécontents. Il existe quelques exemples de grands studios qui s’en sortent malgré tout, comme Bethesda, mais c’est un risque que vous ne devriez pas prendre.<br />
<br />
<b><font size="3">Pourquoi du code de mauvaise qualité est-il commercialisé ?</font></b><br />
<br />
Dans de nombreuses discussions, nous constatons que la simple pression liée à la mise sur le marché de votre jeu est immense. Le calendrier de développement est un véritable problème, comme en témoigne le nombre de développeurs de jeux ayant dû faire face à des périodes de « crunch » ou travailler des heures supplémentaires – soit plus de la moitié d’entre eux. Cela incite de nombreux studios à chercher comment utiliser l’IA pour remédier à ce problème.<br />
<br />
L’IA, en particulier dans le développement de jeux, est un sujet très débattu. Cependant, 95 % des développeurs Unity (Rapport 2026 sur les développeurs de jeux Unity) l’utilisent au travail pour faciliter le processus de codage, ce qui montre que l’IA, si elle est utilisée correctement, peut être un outil utile.<br />
<br />
Vous pouvez créer des prototypes beaucoup plus rapidement, tester de nouvelles mécaniques de jeu, etc. Auparavant, cela prenait plusieurs mois, mais aujourd’hui, quelques jours suffisent pour écarter ce qui ne fonctionne pas. Vous n’avez plus à consacrer autant de temps aux problèmes de code standard, ce qui se traduit par un gain d’efficacité.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679652d1793203076/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 28
Taille : 60,2 Ko"  style="float: CONFIG" /></div><br />
L’objectif n’est pas de supprimer des développeurs des équipes, mais simplement de permettre à votre équipe d’utiliser l’IA pour se consacrer à des tâches plus intéressantes. Cependant, cette rapidité et l’utilisation de l’IA s’accompagnent d’un inconvénient potentiel en matière de qualité du code. L’IA peut générer beaucoup de code très rapidement ; ce code n’est pas nécessairement meilleur ou pire, mais il augmente considérablement le nombre de problèmes. Auparavant, vous écriviez peut-être quelques centaines de lignes. Aujourd’hui, en même temps, l’IA peut en écrire 10 000. Cela entraîne des problèmes concrets, par exemple :<br />
<br />
Un code lent : mon jeu est-il à la hauteur en termes de performances ? Est-il stable ? Est-il vulnérable ou présente-t-il des failles de sécurité potentielles ? La bonne et la mauvaise nouvelle, c’est que le code généré par l’IA n’est pas nécessairement pire que celui généré par l’homme ; il semble assez comparable en termes de nombre total de problèmes, mais il présente des défaillances différentes de celles du code humain.<br />
<br />
En matière de logique et d’erreurs, il génère 1,7 fois plus de problèmes que le code écrit par des humains. Quant à la maintenabilité, etc., il s’avère moins performant et, plus inquiétant encore, il risque également de créer davantage de problèmes de sécurité qu’un développeur humain. Ces conclusions proviennent d’une étude menée par CodeRabbit, un fournisseur d’IA.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679653d1793203120/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 28
Taille : 50,9 Ko"  style="float: CONFIG" /></div><br />
Cependant, la question n’est pas nécessairement de savoir quel type de problèmes est généré par qui (les humains ou l’IA), mais la seule question que nous posons est : « Notre code est-il globalement à la hauteur et répond-il à nos normes de qualité ? » C’est là que l’analyse statique peut nous aider. La bonne nouvelle, c’est que vous pouvez utiliser l’analyse statique pour couvrir pratiquement tous ces six domaines.<br />
<br />
<b><font size="3">Utiliser l’analyse statique de code pour résoudre les problèmes des développeurs de jeux</font></b><br />
<br />
En matière d’exactitude, vous disposez d’inspections standard. Vous pouvez également vérifier les seuils de couverture de code, qui prennent de plus en plus d’importance. Non seulement en termes de couverture, mais aussi quant à la manière de les utiliser.<br />
<br />
Les performances constituent un domaine que l’analyse statique peut couvrir. Quant à la stabilité, on peut citer quelques exemples : la sécurité null, les fuites de ressources, les inspections d’exceptions, les inspections de sécurité et l’analyse des composants logiciels – vérifier la présence de dépendances obsolètes ou effectuer une analyse de contamination dans le cadre de votre analyse statique pour détecter des problèmes plus complexes tels que les scripts SQL, etc.<br />
<br />
Du point de vue de la maintenabilité, vous pouvez repérer les « code smells », la complexité du code et les doublons. C’est un domaine dans lequel l’IA excelle. Elle détecte volontiers les doublons, mais n’apprécie guère la refactorisation. Si vous ne disposez pas d’un moyen de contrôler cela, cela nuira considérablement à votre maintenabilité à l’avenir, car personne ne sera plus en mesure de comprendre votre code à un certain stade.<br />
<br />
Il en va de même pour la réutilisabilité : le code dupliqué complique les choses, et l’analyse statique permet de vérifier si votre code respecte vos propres normes de codage internes, afin d’adopter une approche uniforme, quel que soit le projet sur lequel vous travaillez. De cette manière, vous pouvez également partager votre code beaucoup plus facilement.<br />
<br />
L’IA génère ce genre de problèmes, la raison la plus courante étant qu’elle a été entraînée sur des sources obsolètes. Ces sources sont toutes épuisées et peu de nouveaux travaux voient le jour, ce qui peut entraîner des dépendances obsolètes et d’autres problèmes similaires.<br />
<br />
<b><font size="3">L'analyse statique associée à l'IA en tant que la solution</font></b><br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679654d1793203127/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/5.jpg/" border="0" alt="Nom : 5.jpg
Affichages : 35
Taille : 48,1 Ko"  style="float: CONFIG" /></div><br />
L’inconvénient, c’est que ce type d’analyse existe depuis longtemps, mais pour une bonne raison. L’une d’elles est que les résultats sont déterministes.<br />
<br />
Si vous lancez dix fois une analyse avec un outil d’analyse statique de code, il vous donnera dix fois le même ensemble de résultats. Si vous l’exécutez dix fois, cela ne vous coûte pas plus cher non plus, car cela ne consomme aucun jeton. Si vous soumettez le même morceau de code dix fois à l’IA, vous obtiendrez vingt réponses différentes.<br />
<br />
C’est rapide et peu coûteux ; si l’on compare un réviseur basé sur l’IA à l’analyse statique, cette dernière est généralement beaucoup plus rapide. Pour en revenir au caractère déterministe, vous pouvez associer chaque résultat à une inspection spécifique et comprendre pourquoi il s’agit d’un problème.<br />
<br />
Cela deviendra de plus en plus important à mesure que les exigences de conformité ne cessent de se renforcer. L’une des plus importantes est la nouvelle loi européenne sur la cyber-résilience, déjà en vigueur dans certaines régions. Une partie de cette loi vous oblige à créer une nomenclature logicielle. Si vous utilisez l’IA, cela s’avérera difficile. Si vous utilisez l’analyse statique du code et que vous pouvez établir une relation biunivoque entre le résultat et le code source, vous aurez plus de chances d’être en conformité. Cependant, les deux méthodes présentent leurs avantages et leurs inconvénients.<br />
<br />
<b><font size="3">Avantages et inconvénients de l’analyse statique et de l’analyse par IA</font></b><br />
<br />
Elle ne peut pas comprendre l’intention de votre code, car elle se contente essentiellement de rechercher des modèles. C’est là que l’IA entre en jeu. Si vous souhaitez vérifier que le code fait ce que vous attendez de lui à travers différents fichiers ou dans l’ensemble de votre projet, ou encore détecter des problèmes liés à la logique, c’est là que l’IA prend tout son sens.<br />
<br />
Idéalement, vous devriez donc utiliser une combinaison d’analyse statique pour couvrir les bases, complétée par l’IA. Un humain écrit le code, et l’IA peut également en écrire une partie. Ensuite, une fois que vous lancez votre pipeline, l’analyse statique se charge de l’analyse initiale. Qodana peut détecter d’éventuels problèmes, mais aussi créer automatiquement des corrections rapides. Vous pouvez donc toujours automatiser le processus, même sans IA.<br />
<br />
Ces corrections rapides ne sont pas générées par QIA, ce qui vous offre les avantages généraux de l’analyse statique : rapidité, absence de coût supplémentaire et fiabilité. Vous passerez ensuite à l’outil d’IA de votre choix pour examiner le reste et créer des corrections pour d’autres problèmes complexes, tels que des erreurs de logique ou des refactorisations. Cela peut compléter votre pipeline.<br />
<br />
Idéalement, vous obtenez alors une boucle : l’IA renvoie le code dans le pipeline vers votre analyse statique afin que celle-ci puisse reconfirmer que ce que l’IA a créé est conforme et respecte vos normes de qualité et de sécurité du code. Vous pouvez ensuite fusionner le code dans votre branche principale.<br />
<br />
Cela peut sembler chronophage, mais l’ironie est que cela ne prend probablement que quelques minutes à chaque fois et peut vous faire gagner du temps à l’avenir. Ce sont quelques minutes investies pour éviter de passer des heures plus tard si des problèmes n’avaient pas été détectés.<br />
<br />
<b><font size="3">Que révèlent les chiffres ?</font></b><br />
<br />
Certaines études ont déjà démontré les avantages de cette approche. En combinant l’analyse statique et les appels aux LLM, le nombre de tokens utilisés a diminué de 72 à 92 %, tout en augmentant le volume de code utilisé dans le cadre de cette étude. Une deuxième étude a révélé que cette combinaison permettait de réduire jusqu’à 33 % le nombre de vulnérabilités dans le code LLM intégré à la branche « master ».<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679655d1793203135/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/6.jpg/" border="0" alt="Nom : 6.jpg
Affichages : 25
Taille : 46,1 Ko"  style="float: CONFIG" /></div><br />
Voici un bref exemple illustrant à quoi cela peut ressembler dans Qodana ou dans l’outil d’analyse statique de votre choix. Nous prenons en charge les moteurs de jeu les plus courants dès l’installation. Voici à quoi cela ressemble dans Qodana même. En tant que développeur, vous ne passeriez normalement pas beaucoup de temps ici. Cette fonctionnalité est particulièrement utile pour un chef d’équipe ou un chef de projet. L’un des membres de l’équipe Qodana a réalisé ce projet d’exemple ci-dessous en « vibe-coding ». Il s’agissait d’une interface utilisateur bancaire écrite en Java, et la partie « vibe-coding » n’a pris que quelques minutes pour être mise en place et fonctionner.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679656d1793203143/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/7.jpg/" border="0" alt="Nom : 7.jpg
Affichages : 23
Taille : 77,3 Ko"  style="float: CONFIG" /></div><br />
Qodana a détecté 126 problèmes et vous offre un moyen pratique d’avoir un aperçu rapide de ce qui est important. Vous pouvez ensuite leur appliquer des corrections rapides. Il existe différentes façons de configurer cela (avec des niveaux d’automatisation variables).<br />
<br />
Ici, nous l’avons intégré dans un pipeline GitHub Actions. Nous avons ensuite placé les problèmes restants dans la « Baseline ». Une fois qu’ils se trouvent dans la « Baseline », ils ne vous ralentissent plus. La prochaine fois que vous lancerez une analyse avec Qodana et que vous détecterez de nouveaux problèmes, idéalement, trois d’entre eux seront corrigés automatiquement, et vous n’en verrez que deux nouveaux. Il est donc plus facile de déterminer comment employer votre temps.<br />
<br />
Si l’on examine les cinq problèmes restants, on constate que certains indiquent du code dupliqué. Bien que vous puissiez les visualiser depuis Qodana, vous ne pouvez pas les corriger à partir de là. Ainsi, si nous ouvrons cela dans IntelliJ IDEA, vous pouvez voir que cela nous amène à l’emplacement exact dans la base de code d’IntelliJ IDEA.<br />
<br />
Cela fonctionne avec nos EDI, mais aussi avec Visual Studio, Visual Studio Code et Cursor. Vous pouvez également utiliser notre outil de CI. Ici, vous pouvez passer en revue les problèmes, comme le code en double, en passant la souris dessus (selon votre solution), puis en accédant aux « Actions supplémentaires », puis aux « Actions IA », et laisser l’IA corriger ces problèmes à votre place.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679657d1793203152/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/8.jpg/" border="0" alt="Nom : 8.jpg
Affichages : 23
Taille : 53,2 Ko"  style="float: CONFIG" /></div><br />
Vous pouvez effectuer cette opération manuellement ou via un agent, en la semi-automatisant pour qu’elle s’exécute en arrière-plan, tandis que vous attendez que le code soit nettoyé. Si vous souhaitez en savoir plus, n’hésitez pas à nous contacter : nous pourrons vous montrer comment l’utiliser, ou vous et votre équipe pourrez l’essayer gratuitement.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679658d1793203165/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/9.jpg/" border="0" alt="Nom : 9.jpg
Affichages : 24
Taille : 88,3 Ko"  style="float: CONFIG" /></div><br />
<b>Une fois que vous demandez à l’IA d’ajouter des tests, ceux-ci finissent par s’accumuler dans tous les dépôts, et même des processus aussi simples que le linting peuvent devenir lents. Avez-vous déjà rencontré ce problème ?</b><br />
<br />
Dans certains cas, il faut passer par dix étapes différentes pour publier du code. La plupart du temps, cela est dû au fait que quelqu’un a lancé le processus, mais que personne ne revoyait jamais le pipeline pour déterminer ce qui était pertinent et ce qui ne l’était pas ; or, l’analyse statique ne devrait pas vous ralentir. Ainsi, dans Qodana, un mode dit « pull request » ne vérifie que les fichiers modifiés et ne devrait prendre qu’une minute ou deux.<br />
<br />
<b>Dans quelle mesure les agents intégrés de JetBrains dans les EDI peuvent-ils lire les outils d’analyse statique de l’EDI ?</b><br />
<br />
Rider dispose d’une fonctionnalité appelée « Hooks ». Chaque fois que l’agent génère du code, il appelle les Hooks dans Rider. L’un d’entre eux sert à reformater le code, tandis que l’autre vérifie les problèmes actuels dans un fichier, effectue le linting, identifie les problèmes et les signale à l’agent ; celui-ci peut alors régénérer le code selon vos normes ou corriger uniquement ce que vous lui demandez. Ce processus est déterministe : l’agent est donc contraint d’utiliser les hooks, et non pas simplement invité à le faire. Le hook est activé et exécuté à chaque fois.<br />
<br />
Remarque : les technologies d’IA largement adoptées sont relativement récentes et les résultats issus de cette explosion de données doivent toujours être examinés de manière approfondie, y compris les données présentées dans cet article.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7155" target="_blank">Essayez Qodana gratuitement</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679650d1793203065/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679651d1793203070/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679652d1793203076/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679653d1793203120/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679654d1793203127/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/5.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679655d1793203135/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/6.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679656d1793203143/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/7.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679657d1793203152/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/8.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679658d1793203165/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-lia-remet-cette-idee-question/9.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>JetBrains</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186386/environnements-developpement/autres-edi/jetbrains/qualite-code-ne-change-jamais-l-ia-remet-cette-idee-question/</guid>
		</item>
		<item>
			<title>Air Governance : gérez les agents IA, les accès et les dépenses au sein de votre organisation</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186372&amp;goto=newpost</link>
			<pubDate>Tue, 27 Oct 2026 15:56:32 GMT</pubDate>
			<description>*JetBrains annonce la...</description>
			<content:encoded><![CDATA[<div><b><font size="4">JetBrains annonce la disponibilité de Air Governance, anciennement JetBrains Central, une couche organisationnelle pour gérer les agents IA, les accès et les dépenses au sein de votre organisation</font></b><br />
<br />
En septembre 2026, JetBrains a annoncé JetBrains Air : un système de produits ouvert et cohérent qui s’adresse aux développeurs, aux équipes et aux organisations, dans les EDI JetBrains et au-delà. Il s’agit d’un système qui s’étend sur plusieurs interfaces et plusieurs services. Chaque produit résout un problème distinct, mais les produits fonctionnent mieux ensemble. JetBrains Air intègre Air Governance (anciennement JetBrains Central).<br />
<br />
Récemment, JetBrains Air Governance est disponible pour tous. Anciennement connu sous le nom de JetBrains Central, il s’agit de la couche organisationnelle de <a href="https://jetbrains.developpez.com/actu/388453/JetBrains-presente-JetBrains-Air-un-systeme-de-produits-ouvert-pour-le-developpement-logiciel-avec-des-agents-IA-concus-pour-le-travail-individuel-et-la-coordination-des-equipes/" target="_blank">JetBrains Air, un système de produits pour le développement agentique.</a> Air Governance vous offre un espace centralisé pour gérer les agents d’IA, les modèles et les fournisseurs d’IA utilisés par vos équipes, définir des plafonds de dépenses, et suivre ce que l’utilisation de l’IA vous coûte et vous apporte. Il fonctionne avec Claude Agent, Codex, Gemini CLI, Junie et d’autres agents compatibles avec l’ACP, sur diverses interfaces de développement, notamment les EDI, la CLI, les navigateurs web et les appareils mobiles.<br />
<br />
Air Governance est maintenant disponible pour toutes les organisations clientes de JetBrains, avec des forfaits gratuits et payants pour répondre aux besoins des différentes équipes.<br />
<br />
<div style="text-align: center;">
<div class="video-container"><iframe class="restrain" title="YouTube video player" width="560" height="315" allowfullscreen src="//www.youtube.com/embed/tRWMbwnl1ec?wmode=transparent&amp;fs=1" frameborder="0"></iframe></div>
</div><br />
Voici l'annonce de JetBrains Air Governance :<br />
<br />
<b><font size="3">Pourquoi nous avons créé Air Governance</font></b><br />
<br />
Aujourd’hui, la plupart des équipes d’ingénierie utilisent simultanément plusieurs outils d’IA de différents fournisseurs. Elles travaillent avec des agents IA via un IDE, une CLI ou une interface web, et alternent entre Claude Code, Codex, Gemini, Junie et d’autres agents. Chaque outil ayant son propre contrat, son propre tableau de bord et ses propres paramètres d’administration, il est difficile d’avoir une vision complète de qui utilise quels agents et modèles, de combien l’IA coûte à l’entreprise et si elle est réellement utile.<br />
<br />
Nous avions le même problème chez JetBrains. Nos dépenses liées à l’IA ont été multipliées par dix environ au cours du premier semestre 2026, et il nous a fallu quatre jours pour compiler manuellement notre premier rapport d’utilisation multi-fournisseur. Nous avons alors créé une suite d’outils pour résoudre ce problème, et ces outils sont devenus Air Governance, qui aide maintenant à gérer l’utilisation d’agents par environ 2 300 personnes chez JetBrains chaque mois. <br />
<br />
Air Governance permet aux administrateurs de gérer l’utilisation de l’IA depuis une seule console. Il fonctionne avec différents fournisseurs, ce qui permet aux développeurs d’utiliser les agents et les modèles adaptés à leurs tâches. Lorsqu’un nouvel agent ou modèle sort, il vous suffit de l’intégrer aux règles existantes. Aucun nouveau contrat ni configuration d’administration distincte n’est nécessaire.<br />
<br />
<b><font size="3">Gérer l’IA au sein de votre organisation</font></b><br />
<br />
Dans la console, vous pouvez :<br />
<br />
- <b>Définir des limites de crédits IA</b> pour les utilisateurs individuels, les équipes et les comptes de service, afin que les budgets soient réellement respectés, et pas seulement présentés dans des rapports.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679622d1793121254/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 246
Taille : 60,6 Ko"  style="float: CONFIG" /></div><br />
- <b>Gérer les fournisseurs d’IA et configurer un BYOK centralisé</b> : utilisez JetBrains AI ou connectez vos propres comptes OpenAI, Anthropic, Amazon Bedrock ou Google Vertex AI.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679623d1793121259/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 205
Taille : 45,8 Ko"  style="float: CONFIG" /></div><br />
- <b>Définir les agents d’IA approuvés</b> pour une utilisation dans toute l’organisation.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679624d1793121264/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 193
Taille : 44,4 Ko"  style="float: CONFIG" /></div><br />
- <b>Configurer des serveurs MCP au niveau de l’entreprise</b>, afin que tout le monde travaille avec les mêmes outils externes approuvés.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679625d1793121272/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 207
Taille : 43,6 Ko"  style="float: CONFIG" /></div><br />
- <b>Créer des politiques pour l’utilisation de l’IA</b>, concernant les fournisseurs, les modèles, les agents et les limites de crédits approuvées pour différents groupes d’utilisateurs. <br />
<br />
<b><font size="3">Suivez ce que l’IA vous coûte et vous apporte</font></b><br />
<br />
Il est facile de dépenser toujours plus dans l’IA. Expliquer à sa direction en quoi ces dépenses sont justifiées est bien plus difficile. Air Governance vous permet de suivre à la fois les coûts et l’impact de l’ensemble de vos agents :<br />
<br />
- <b>Coûts de l’IA par utilisateur</b> : identifiez où va votre budget, jusqu’à l’échelle de chaque développeur. <br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679626d1793121277/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/5.jpg/" border="0" alt="Nom : 5.jpg
Affichages : 190
Taille : 76,3 Ko"  style="float: CONFIG" /></div><br />
- <b>Coûts de l’IA par agent</b> : comparez les dépenses entre Junie, Claude Agent, Codex, Gemini CLI et d’autres agents.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679627d1793121286/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/6.jpg/" border="0" alt="Nom : 6.jpg
Affichages : 177
Taille : 73,1 Ko"  style="float: CONFIG" /></div><br />
- <b>Coûts de l’IA par modèle et par fournisseur</b> : identifiez les modèles qui pèsent le plus sur votre facture. <br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679628d1793121300/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/7.jpg/" border="0" alt="Nom : 7.jpg
Affichages : 169
Taille : 71,4 Ko"  style="float: CONFIG" /></div><br />
- <b>Indicateurs de résultats de l’IA</b> : découvrez comment l’IA transforme la façon dont vos développeurs travaillent. Les indicateurs incluent la répartition entre le code écrit par des humains et le code généré par l’IA, ainsi que la quantité de code générée ou modifiée par l’IA.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679629d1793121305/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/8.jpg/" border="0" alt="Nom : 8.jpg
Affichages : 170
Taille : 68,7 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Ce qui est prévu pour la suite </font></b><br />
<br />
Air va évoluer au fil d’une série de versions et Air Governance suivra la même approche. Voici quelques-unes des fonctionnalités sur lesquelles nous travaillons actuellement :<br />
<br />
- Propagation des serveurs MCP vers les CLI tierces, afin que les outils approuvés par l’entreprise concernent tous les agents, pas seulement ceux de JetBrains.<br />
- Prise en charge de GitHub Copilot via Air Gateway, notre connecteur pour les CLI tierces.<br />
- Connexion aux agents cloud via Air Gateway.<br />
- Analytique avancée de l’IA.<br />
- Plafonds de crédits et tarification personnalisée pour les modèles utilisés avec votre propre clé API (BYOK).<br />
- Possibilité de gérer les skills entre les équipes.<br />
<br />
<b>Premiers pas avec Air Governance</b><br />
<br />
Air Governance est désormais disponible pour toutes les organisations dans le cadre du forfait Business, au prix de 20 USD par mois pour chaque développeur ayant un accès à l’IA. Les développeurs n’ont pas besoin de licences d’IA individuelles et puisent dans un pool partagé de crédits IA, que votre organisation achète séparément et qui couvre l’utilisation de l’IA dans les produits JetBrains et les agents connectés.<br />
<br />
Les clients JetBrains existants peuvent découvrir Air Governance directement dans la console (accès administrateur requis).<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7153" target="_blank">Demandez une démo</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679629d1793121305/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/8.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679628d1793121300/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/7.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679627d1793121286/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/6.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679626d1793121277/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/5.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679625d1793121272/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679624d1793121264/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679623d1793121259/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679622d1793121254/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/1.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186372/environnements-developpement/autres-edi/jetbrains/air-governance-gerez-agents-ia-acces-depenses-sein-organisation/</guid>
		</item>
		<item>
			<title>Une Nouvelle Expérience Agentique : JetBrains Air dans les IDE – EAP maintenant ouvert</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186366&amp;goto=newpost</link>
			<pubDate>Tue, 27 Oct 2026 10:36:57 GMT</pubDate>
			<description>*JetBrains présente JetBrains...</description>
			<content:encoded><![CDATA[<div><b><font size="4">JetBrains présente JetBrains Air dans les EDI, une expérience de développement agentique complète pour diriger et orchestrer les agents IA et vérifier leur travail au sein des EDI JetBrains</font></b><br />
<br />
JetBrains est une société à responsabilité limitée internationale spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux développeurs et aux chefs de projet. L'entreprise a son siège social à Amsterdam et dispose de bureaux en Chine, en Europe et aux États-Unis. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter dans une machine virtuelle Java (JVM).<br />
<br />
En septembre 2026, JetBrains a annoncé JetBrains Air : un système de produits ouvert et cohérent qui s’adresse aux développeurs, aux équipes et aux organisations, dans les EDI JetBrains et au-delà. Il s’agit d’un système qui s’étend sur plusieurs interfaces et plusieurs services. Chaque produit résout un problème distinct, mais les produits fonctionnent mieux ensemble. JetBrains Air intègre Air dans les EDI JetBrains : une expérience de développement agentique complète pour diriger et orchestrer les agents IA et vérifier leur travail au sein des EDI JetBrains.<br />
<br />
Début octobre 2026, JetBrains a lancé le programme d’accès anticipé (EAP) pour Air dans les EDI JetBrains. Il est disponible en tant que plugin sur la JetBrains Marketplace ou nativement dans les builds EAP 2026.3 des EDI JetBrains. Essayez Air avec des exécutions gratuites de Junie Lite, l'agent de programmation de JetBrains pour les tâches du quotidien. Avec le plugin Air pour les EDI JetBrains, vous accédez directement aux agents et aux abonnements que vous utilisez déjà. Air n’est pas un fournisseur d’IA et aucun agent n’est installé par défaut avec le plugin.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679617d1793108910/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 426
Taille : 46,3 Ko"  style="float: CONFIG" /></div><br />
Voici l'annonce de JetBrains :<br />
<br />
<b><font size="3">Pourquoi une nouvelle expérience ?</font></b><br />
<br />
Jusqu’ici, l’IA dans l’EDI s’est principalement concentrée sur le chat IA. Cependant, le développement agentique change le modèle d’interaction établi : vous déléguez des tâches plus importantes et laissez les agents travailler en parallèle. Vous devez donc pouvoir suivre leur travail et les guider à chaque étape. Nous avons cherché à intégrer cette fonctionnalité à notre solution AI Assistant existante en ajoutant de nouveaux agents au chat IA. Mais à mesure que ces workflows ont évolué, une chose est devenue claire : orchestrer plusieurs tâches en parallèle est fondamentalement différent d’avoir une conversation avec une IA.<br />
<br />
Air a été conçu autour de cette différence. Derrière cela se cache un changement de paradigme plus large, et nous n’allons pas y aller par quatre chemins : le développement agentique devient la norme, et un EDI qui tient les agents à distance aura du mal à rester pertinent.<br />
<br />
Cela rend l’EDI plus important, pas moins : alors que les agents effectuent de plu en plus de travail, en vérifier le résultat et en assumer la responsabilité devient la partie difficile, et c’est précisément à cela que sert l’EDI. Le centre de gravité des EDI JetBrains se déplace vers le développement agentique, et Air est notre façon d’y parvenir.<br />
<br />
<b><font size="3">Présentation de JetBrains Air dans les EDI</font></b><br />
<br />
Air apporte le développement agentique dans l’EDI sans vous limiter à un agent particulier ni changer la façon dont vous travaillez. Il repose sur trois principes. Nous vous avons déjà parlé des deux premiers. La nouveauté, c’est un produit conçu dès le départ autour de ces principes.<br />
<br />
<b><i>1. Intégrez vos agents existants à votre EDI</i></b><br />
<br />
Air fonctionne avec les agents que vous utilisez déjà, tels que Codex, GitHub Copilot, Junie, Cursor, et d’autres agents compatibles avec l’ACP. Il détecte les agents déjà installés sur votre machine et permet de les intégrer directement dans l’EDI facilement. Avec JetBrains Air dans les EDI, vous pouvez également utiliser votre abonnement à Claude dans le terminal et l’onglet plein écran d’Air. Vous n’avez pas besoin d’un abonnement à JetBrains AI pour utiliser vos agents avec Air. Utilisez les abonnements dont vous disposez déjà, qu’il s’agisse d’abonnements auprès de fournisseurs d’IA ou à JetBrains AI.<br />
<br />
<b><i>2. L’intelligence de l’EDI pour vous et pour vos agents</i></b><br />
<br />
Le développement ne s’arrête pas une fois le code généré : il faut encore l’exécuter, le réviser et le valider. C’est exactement ce pour quoi un EDI est conçu. Il vous donne les outils pour comprendre et examiner le travail de l’agent : des diffs à la navigation, en passant par les inspections et bien plus. Et les agents profitent eux aussi de toute la puissance de l’EDI. Grâce aux fonctionnalités et outils intégrés à l’EDI, les agents compatibles bénéficient de l’expertise et des workflows spécialisés de JetBrains pour déboguer, analyser les performances, explorer les bases de données et effectuer des recherches sémantiques dans le code. Cela peut aider les agents à produire de meilleurs résultats et, pour certaines tâches, à utiliser moins de tokens.<br />
<br />
<b><i>3. Une expérience utilisateur pensée d’abord pour l’agentique</i></b><br />
<br />
Air est conçu pour travailler avec plusieurs agents en parallèle, et pas seulement pour interagir avec un seul à la fois. Le travail des agents est organisé en sessions, toutes visibles au même endroit, afin que vous puissiez suivre la progression, voir ce qui requiert votre attention, guider les agents et examiner leur travail sur tous vos projets.<br />
<br />
<b><font size="3">Travailler avec Air</font></b><br />
<br />
Voici ce à quoi cela ressemble en pratique :<br />
<br />
<b>Gardez le contrôle du travail parallèle des agents.</b> Visualisez en un coup d’œil les sessions de tous vos projets au même endroit, avec l’activité, les mises à jour non lues, les fichiers modifiés et les commits sortants. Prenez connaissance du coût de chaque session au fil de votre travail, pour garder une visibilité claire sur vos dépenses entre agents et tâches. Cela facilite le suivi de la progression et permet de voir rapidement ce qui a changé et ce qui requiert votre attention.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679618d1793108919/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 335
Taille : 113,6 Ko"  style="float: CONFIG" /></div><br />
<b>Déléguez une tâche avec une seule touche.</b> Appuyez deux fois sur Ctrl depuis n’importe où dans l’IDE pour ouvrir une fenêtre de prompt et démarrer une nouvelle session d’agent, avec votre contexte actuel déjà joint.<br />
<br />
<b>Choisissez l’interface que vous préférez pour une session d’agent.</b> Les sessions s’ouvrent directement dans l’éditeur sous forme d’onglets, donnant au travail des agents un véritable espace à l’écran, aux côtés de votre code. Si vous préférez l’interface du terminal, vous pouvez continuer à l’utiliser directement dans l’EDI. Ou alors choisir un chat graphique lorsque cela convient mieux à la tâche.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679619d1793108923/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 332
Taille : 89,5 Ko"  style="float: CONFIG" /></div><br />
<b>Exécutez les agents en local ou dans le cloud.</b> Pour les tâches complexes, longues ou réalisables en arrière-plan, lancez les agents dans le cloud, puis éteignez votre machine. Suivez le travail de l’agent sur mobile (bientôt disponible) pour le guider. Actuellement disponible pour les organisations disposant de licences IA.<br />
<br />
<b>Isolez le travail parallèle des agents grâce à des worktrees temporaires.</b> Lancez une session depuis n’importe quelle branche, sur une nouvelle branche ou en mode détaché. Suivez les modifications et les commits depuis le chat, puis réintégrez le résultat dans votre projet principal avec un cherry-pick dès qu’il est prêt.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679620d1793108928/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 328
Taille : 54,8 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Vous gardez le contrôle</font></b><br />
<br />
L’AI Assistant reste disponible pendant que vous essayez Air dans votre EDI. Avec le temps, nous nous attendons à voir Air devenir l’expérience principale pour les workflows agentiques dans les EDI JetBrains. À mesure qu’Air prend une place croissante dans les EDI JetBrains, beaucoup d’entre vous se poseront d’abord une question essentielle concernant le contrôle : Puis-je désactiver Air et où mon code va-t-il ?<br />
<br />
<b>Pas d’agents ? Rien ne quitte votre machine.</b> Air est une fenêtre d’outils, pas un fournisseur d’IA, et aucun agent n’est installé par défaut. Il détecte les agents déjà présents sur votre machine, de la même façon que l’EDI détecte votre terminal, mais rien ne s’exécute et aucune donnée ne quitte votre machine tant que vous ne vous connectez pas à un agent ou à un forfait JetBrains AI. Si votre organisation n’autorise pas les agents, Air n’a rien à exécuter et rien à envoyer.<br />
<br />
<b>Vos données vont à votre fournisseur, pas à JetBrains.</b> Avec un abonnement tiers, les données vont directement à ce fournisseur, dans le cadre de l’accord que vous avez déjà conclu avec lui. Elles ne transitent pas par JetBrains. Si vous utilisez JetBrains AI, vous êtes soumis aux conditions d’utilisation de JetBrains AI, comme c’est déjà le cas pour l’AI Assistant. Air n’ajoute aucune nouvelle condition de traitement des données.<br />
<br />
<b>Vous pouvez le désactiver.</b> Désactivez le plugin Air et rien d’autre ne change.<br />
<br />
<b><font size="3">Essayez-le gratuitement avec Junie Lite</font></b><br />
<br />
Nous pensons qu’il est important d’offrir une version gratuite de l’IA dans nos EDI, c’est pourquoi nous vous proposons d’utiliser Air gratuitement avec Junie Lite, notre agent de programmation pour les tâches du quotidien.<br />
<br />
Confiez à Air une vraie tâche : lancez des sessions d’agent sur plusieurs projets et dites-nous comment cela s’intègre à votre workflow. Partagez vos retours via YouTrack pour qu’ils arrivent directement dans le backlog de nos équipes ou faites-nous part de vos impressions dans les commentaires ci-dessous.<br />
<br />
Installez Air depuis la JetBrains Marketplace, via la notification dans l’AI Assistant ou dans le cadre des builds EAP 2026.3 des JetBrains IDEs, puis connectez les agents que vous utilisez déjà ou utilisez ceux qui sont disponibles via JetBrains AI. Si vous installez Air à partir de la notification dans l’AI Assistant, ce dernier sera désactivé afin d’éviter que les deux ne s’exécutent en parallèle. Vous pouvez le réactiver à tout moment dans Settings | Plugins ou le réinstaller depuis la Marketplace.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7152" target="_blank">Essayez Air dans votre EDI</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679617d1793108910/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679620d1793108928/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679618d1793108919/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679619d1793108923/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/3.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186366/environnements-developpement/autres-edi/jetbrains/nouvelle-experience-agentique-jetbrains-air-ide-eap-ouvert/</guid>
		</item>
		<item>
			<title>Air Teams : partagez vos meilleurs workflows agentiques avec toute votre équipe et automatisez</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186355&amp;goto=newpost</link>
			<pubDate>Mon, 26 Oct 2026 19:54:50 GMT</pubDate>
			<description>*JetBrains présente Air...</description>
			<content:encoded><![CDATA[<div><b><font size="4">JetBrains présente Air Teams, un espace de collaboration dédié au développement logiciel avec des agents IA, permettant de partager les workflows agentiques et d'automatiser les tâches</font></b><br />
<br />
JetBrains est une société à responsabilité limitée internationale spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux développeurs et aux chefs de projet. L'entreprise a son siège social à Amsterdam et dispose de bureaux en Chine, en Europe et aux États-Unis. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter dans une machine virtuelle Java (JVM).<br />
<br />
Début septembre 2026, JetBrains a annoncé JetBrains Air : un système de produits ouvert et cohérent qui s’adresse aux développeurs, aux équipes et aux organisations, dans les EDI JetBrains et au-delà. Il s’agit d’un système qui s’étend sur plusieurs interfaces et plusieurs services. Chaque produit résout un problème distinct, mais les produits fonctionnent mieux ensemble.  JetBrains Air intègre JetBrains Air Teams, l’espace de collaboration dédié au développement agentique. Il fournit aux équipes et aux agents le contexte, les environnements, les outils et les instructions partagés dont ils ont besoin pour collaborer efficacement tout au long du cycle de développement.<br />
<br />
<b><font size="3">Air Teams : des développeurs individuels aux équipes</font></b><br />
<br />
Il y a plusieurs mois, JetBrains a présenté l’application Air comme étant un premier pas dans le développement agentique. En travaillant au développement de Air, JetBrains rapporte deux éléments qui sont devenus de plus en plus évidents. Premièrement, les développeurs n’ont pas besoin d’une énième application autonome : les outils et les agents doivent être intégrés à l’environnement dans lequel ils travaillent déjà. Deuxièmement, à mesure que les développeurs individuels gagnaient en productivité grâce aux agents, le véritable goulot d’étranglement s’est déplacé au niveau de l’équipe.<br />
<br />
Dans ce contexte l'équipe de JetBrains a déclaré : « <i>Nous avons donc décidé de faire évoluer Air pour aller au-delà d’une simple application de bureau autonome et proposer un système plus vaste et intégré. Air prend désormais en charge le développement agentique à trois niveaux : développeurs individuels, équipes et organisations.</i> » Air Teams est un espace de travail partagé dans lequel les équipes d’ingénierie exécutent des agents de programmation et réutilisent ce qui fonctionne. Aujourd’hui, la majeure partie du travail agentique se fait sur les ordinateurs portables des développeurs : chacun a sa propre configuration et ses propres prompts, et ce qui fonctionne pour l’un ne se transmet pas facilement au reste de l’équipe. Air Teams rassemble les workflows agentiques en un seul endroit : ce qu’un développeur découvre, toute l’équipe peut l’utiliser.<br />
<br />
Air Teams comporte quatre parties :<br />
<br />
- Les <b>automatisations</b> prennent en charge de manière autonome les tâches récurrentes, comme les révisions de code, les corrections de tickets et les mises à jour des dépendances. Un événement ou une planification déclenche chaque exécution.<br />
<br />
- Les <b>environnements cloud partagés</b> fournissent aux agents les outils, les dépendances et les identifiants dont ils ont besoin pour compiler et tester le code. L’équipe le configure une fois, et tout le monde le réutilise.<br />
<br />
- Les <b>tâches cloud</b> s’exécutent dans ces environnements, en parallèle, sans monopoliser l’ordinateur portable de qui que ce soit. Vous pouvez les démarrer et les suivre depuis votre IDE ou votre navigateur, et bientôt depuis votre téléphone.<br />
<br />
- Les <b>projets</b> relient le tout, avec des crédits partagés, des rôles clairs et des automatisations qui ne dépendent d’aucune personne en particulier.<br />
<br />
<div style="text-align: center;">
<div class="video-container"><iframe class="restrain" title="YouTube video player" width="560" height="315" allowfullscreen src="//www.youtube.com/embed/ynH76SA5yE0?wmode=transparent&amp;fs=1" frameborder="0"></iframe></div>
</div><br />
<b><font size="3">Automatisations : fini de surveiller les agents en permanence</font></b><br />
<br />
Les agents peuvent travailler vite, mais ils attendent encore que des humains démarrent les tâches, fournissent des instructions et passent à l’étape suivante. À un moment donné, orchestrer manuellement chaque exécution devient le goulot d’étranglement.<br />
<br />
Les automatisations de Air sont des workflows agentiques qui s’exécutent seuls, dans le cloud, déclenchés par un événement ou une planification plutôt que par une personne. Ce sont des ressources partagées par l’équipe : un développeur peut créer une automatisation, et toute l’équipe peut l’exécuter, la réutiliser et l’améliorer. Ce qui fonctionne bien pour une personne peut devenir une pratique commune à toute l’équipe. Par exemple, une automatisation peut relire chaque nouvelle pull request dès son ouverture, ou mettre à jour les dépendances deux fois par semaine. Air Teams est fourni avec 10 modèles d’automatisation, notamment pour la révision de code, la correction de bugs, la mise à jour des dépendances et la maintenance de la documentation. Vous pouvez utiliser les modèles tels quels ou les adapter à la façon de travailler de votre équipe.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679602d1793087971/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 328
Taille : 45,5 Ko"  style="float: CONFIG" /></div><br />
<b>Comment fonctionnent les automatisations</b><br />
<br />
Les automatisations sont conçues pour le travail récurrent qui suit un schéma : une pull request à relire, un ticket étiqueté à examiner, ou des dépendances à vérifier chaque semaine.<br />
<br />
Vous configurez quatre éléments une seule fois, et l’automatisation les réutilise à chaque exécution :<br />
<br />
<b>Instructions </b> : ce que l’agent doit faire ;<br />
<br />
<b>Environnement</b> : où l’agent s’exécute ;<br />
<br />
<b>Outils</b> : ce que l’agent peut utiliser, y compris Jira, Figma et Linear via des connecteurs ;<br />
<br />
<b>Déclencheur</b> : le moment où l’agent démarre, qu’il s’agisse d’un événement GitHub ou Jira, d’un webhook ou d’une planification, avec d’autres types de déclencheurs à venir.<br />
<br />
Voici un exemple : une automatisation déclenchée par l’ajout d’un libellé. Lorsque quelqu’un ajoute le libellé Bug, l’automatisation lance un agent. L’agent lit le ticket et le ticket Jira associé, identifie la cause dans le code, puis ouvre une pull request avec une proposition de correctif qu’un ingénieur pourra vérifier.<br />
<br />
Les automatisations font partie d’un projet d’équipe, si bien que toute l’équipe utilise la même automatisation au lieu que chacun crée la sienne. Une fois qu’une automatisation a fait ses preuves, elle peut aller au-delà du projet : l’équipe peut la réutiliser sur un autre dépôt ou l’enregistrer comme un modèle que n’importe qui dans l’organisation peut utiliser tel quel ou adapter.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679603d1793087975/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 240
Taille : 38,2 Ko"  style="float: CONFIG" /></div><br />
<b>Exemples d’automatisations</b><br />
<br />
Voici trois automatisations présentées par l'équipe de JetBrains :<br />
<br />
<b>Révisions de code.</b> À l’ouverture d’une pull request, un agent analyse le code et les échanges concernés, publie des commentaires directement dans le code ainsi qu’un résumé, et peut approuver la pull request ou demander des modifications. Chaque nouveau commit déclenche une nouvelle exécution : l’agent relit sa révision précédente ainsi que les éventuelles réponses, note les problèmes qui ont été corrigés et ceux qui subsistent, puis réduit ses anciennes révisions afin que seule la plus récente reste visible. Un agent d’IA doit faciliter votre workflow, pas le bloquer. Lorsque vous décidez de traiter un problème dans une pull request distincte, l’agent respecte votre choix et termine sa vérification.<br />
<br />
<b>Corrections de tickets.</b> Lorsqu’un membre de l’équipe attribue à un agent une tâche simple et bien définie dans YouTrack, l’agent rassemble le contexte nécessaire, tente d’effectuer la tâche et ouvre une pull request pour revue. Cette même automatisation gère également les retours concernant les révisions. Lorsqu’une pull request ouverte par une automatisation reçoit des commentaires de relecture, qu’ils viennent d’un membre de l’équipe ou de l’automatisation de révision de code, l’agent les prend en compte et fait les corrections.<br />
<br />
<b>Mises à jour des dépendances.</b> Deux fois par semaine, un agent met à niveau les dépendances du projet, en ignorant celles que ses instructions indiquent de laisser telles quelles. Il compile le projet et exécute les tests. Lorsqu’une mise à niveau casse quelque chose, l’agent corrige le code concerné sans en modifier le comportement, ou annule la mise à niveau s’il n’y parvient pas. Il ouvre ensuite une pull request répertoriant les mises à niveau appliquées, ignorées ou annulées. Si la pull request précédente n’a pas encore été fusionnée, l’agent la ferme, de sorte que l’équipe dispose toujours d’une seule pull request à jour à fusionner quand elle est prête.<br />
<br />
<b>Gardez le contrôle</b><br />
<br />
Une préoccupation légitime avec les agents IA est le bruit : des commentaires que personne ne lit et des pull requests que personne n’a demandées. Les automatisations laissent les décisions à l’équipe. Les ingénieurs choisissent les tâches à confier aux agents et leurs instructions permettent de limiter leur périmètre d’intervention, comme dans les exemples ci-dessus : une seule pull request pour les mises à jour de dépendances et une seule révision en cours par pull request.<br />
Chaque exécution conserve également la conversation complète de l’agent et ses appels d’outils, de sorte que lorsqu’un résultat semble incorrect, l’équipe puisse en comprendre la raison. Chaque modification de code arrive sous forme de pull request, et un ingénieur décide de la fusionner ou non.<br />
<br />
<br />
<b><font size="3">Environnements cloud partagés : une configuration que votre équipe et vos agents peuvent réutiliser</font></b><br />
<br />
Chaque automatisation, comme chaque tâche cloud, s’exécute dans un environnement, et un agent ne peut pas faire mieux que ce que son environnement permet. Avant de pouvoir construire ou tester quoi que ce soit, il lui faut ce dont tout nouvel ingénieur a besoin dès son premier jour : les bons outils, les dépendances, les identifiants et les accès réseau nécessaires. Un petit projet peut fonctionner avec les paramètres par défaut, mais la plupart des bases de code nécessitent des éléments supplémentaires, comme un registre privé de paquets, des versions figées de la chaîne d’outils ou un outil interne de suivi des tickets auquel l’agent doit pouvoir accéder. Quelqu’un doit configurer cela, et une seule fois devrait suffire.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679604d1793088010/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 247
Taille : 41,5 Ko"  style="float: CONFIG" /></div><br />
Dans Air Teams, cette configuration se trouve dans un environnement cloud partageable. Vous en créez un pour un dépôt dans votre projet d’équipe. Vous choisissez la taille de la VM, déterminez quels domaines la machine peut atteindre, et ajoutez les variables et les secrets dont le build a besoin. La configuration elle-même se trouve dans votre dépôt, à l’emplacement <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">.air/cloud/startup.sh</span>, ce qui permet à votre équipe de la versionner et de la relire avec le reste du code. <br />
<br />
Vous pouvez aussi confier la première ébauche à un agent. Il inspecte le dépôt, exécute réellement l’installation et le build, demande les secrets manquants, puis valide un script de démarrage testé dans une branche distincte. Puis vous vérifiez, comme pour n’importe quelle autre modification. Une fois l’environnement prêt, Air l’enregistre sous forme d’instantané, et vous le partagez avec l’équipe. Partager la configuration ne signifie pas partager les identifiants. Les secrets partagés permettent aux membres de l’équipe et à vos automatisations d’utiliser une valeur sans la voir, tandis que les secrets personnels et l’accès au dépôt restent propres à chaque personne.<br />
<br />
À partir de là, les membres de l’équipe choisissent l’environnement dans lequel exécuter leurs tâches dans le cloud, et les automatisations du projet s’exécutent dans cet environnement. Aucun agent ne perd de temps ni de tokens à redécouvrir comment compiler le dépôt. Chaque tâche commence directement par le travail à effectuer.<br />
<br />
<b><font size="3">Tâches cloud : travaillez depuis votre EDI et n’importe quel appareil</font></b><br />
<br />
Une fois les environnements configurés, vous pouvez commencer à confier du travail aux agents. Choisissez un environnement et un agent, puis décrivez la tâche. Si votre dépôt n’a pas besoin d’une configuration personnalisée, utilisez l’environnement par défaut. Vous pouvez exécuter une tâche localement ou dans le cloud. Le bon choix dépend de la tâche, de la configuration qu’elle nécessite et du degré d’interaction que vous souhaitez avoir avec l’agent.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679605d1793088018/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 250
Taille : 230,9 Ko"  style="float: CONFIG" /></div><br />
La différence essentielle est que les tâches cloud ne sont pas liées à l’appareil sur lequel vous les avez démarrées. Vous pouvez démarrer une tâche dans votre IDE et la reprendre plus tard sur le web. L’agent continue de travailler même après que vous ayez fermé votre ordinateur portable.<br />
<br />
<b><font size="3">Projets d’équipe : le travail appartient à l’équipe</font></b><br />
<br />
Un projet d’équipe est un espace commun pour le travail agentique d’une équipe. Il rassemble les membres de l’équipe, les environnements partagés, les connecteurs MCP et les automatisations. Deux rôles définissent qui peut faire quoi. Les administrateurs du projet gèrent l’appartenance à l’équipe, les environnements, les connecteurs et les automatisations. Ils peuvent également autoriser certains membres à modifier un environnement. Les membres utilisent les environnements partagés, créent leurs propres automatisations et voient les résultats de chaque exécution.<br />
<br />
Les automatisations ne dépendent pas nécessairement de la personne qui les a créées. Chaque projet dispose de son propre compte de service et de ses propres crédits IA, et un administrateur décide si les automatisations du projet consomment ces crédits ou ceux de leurs créateurs. Avec les crédits du projet, les automatisations s’exécutent au nom du compte du projet et continuent de fonctionner même après le départ de leur créateur.<br />
<br />
<b>Premiers pas avec Air Teams</b><br />
<br />
Avec Air Teams, le travail agentique devient une activité partagée par toute l’équipe. Les automatisations gèrent le travail récurrent, les environnements partagés donnent la même configuration à chaque tâchn, les tâches cloud continuent de s’exécuter après la fermeture de votre ordinateur portable, et les projets d’équipe garantissent que rien de tout cela ne dépende d’une seule personne.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7151" target="_blank">Essayez Air Teams</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679602d1793087971/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679603d1793087975/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679604d1793088010/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679605d1793088018/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/4.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186355/environnements-developpement/autres-edi/jetbrains/air-teams-partagez-vos-meilleurs-workflows-agentiques-toute-equipe-automatisez/</guid>
		</item>
		<item>
			<title>JetBrains Air : construire un système de produits pour le développement logiciel agentique</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186352&amp;goto=newpost</link>
			<pubDate>Mon, 26 Oct 2026 15:18:54 GMT</pubDate>
			<description>*JetBrains présente JetBrains...</description>
			<content:encoded><![CDATA[<div><b><font size="4">JetBrains présente JetBrains Air, un système de produits ouvert pour le développement logiciel avec des agents IA, conçus pour le travail individuel et la coordination des équipes</font></b><br />
<br />
JetBrains est une société à responsabilité limitée internationale spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux développeurs et aux chefs de projet. L'entreprise a son siège social à Amsterdam et dispose de bureaux en Chine, en Europe et aux États-Unis. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter dans une machine virtuelle Java (JVM).<br />
<br />
En 2026, JetBrains avait commencé à expérimenter publiquement avec des environnements de développement agentique. Ils ont présenté JetBrains Central comme un système ouvert de contrôle et d’exécution pour le développement piloté par les agents. Ensuite, ils ont commencé à déployer JetBrains Central CLI, le contexte partagé, les agents cloud, les automatisations, la gouvernance et le contrôle des coûts de l’IA pour les équipes et les organisations. Début septembre 2026, tout ce travail a été réuni au sein de JetBrains Air : un système de produits ouvert et cohérent qui s’adresse aux développeurs, aux équipes et aux organisations, dans les EDI JetBrains et au-delà. Il s’agit d’un système qui s’étend sur plusieurs interfaces et plusieurs services. Chaque produit résout un problème distinct, mais les produits fonctionnent mieux ensemble.<br />
<br />
L'équipe de JetBrains commentait cette annonce : « <i>JetBrains Air représente une expansion majeure de ce pour quoi JetBrains construit ses produits. Depuis 26 ans, nous nous sommes principalement concentrés sur l’environnement de travail du développeur individuel. Aujourd’hui, nous concevons nos produits pour le système plus large via lequel le travail agentique est initié, exécuté, coordonné, révisé et gouverné. L’EDI reste un élément central dans l’avenir de JetBrains. L’époque à laquelle tout le système de développement logiciel pouvait être contenu dans une fenêtre touche à sa fin. Dans le cadre de notre investissement continu, nous intégrons désormais l’expérience agentique fondamentale aux EDI JetBrains, pour offrir aux développeurs professionnels un environnement dans lequel ils peuvent travailler efficacement avec des agents tout en comprenant, modifiant et vérifiant le code qui en résulte. JetBrains Air s’intègre à l’écosystème plus large qui se développe autour de lui.</i> »<br />
<br />
Ce système repose sur une conviction fondamentale : l’avenir du développement agentique sera multifournisseur. Aucun modèle, agent ou service unique ne conviendra à tous les développeurs, équipes ou tâches. <br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679593d1793031703/environnements-developpement/autres-edi/jetbrains/jetbrains-air-construire-systeme-produits-developpement-logiciel-agentique/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 8362
Taille : 63,8 Ko"  style="float: CONFIG" /></div><br />
<b>D’un seul produit à un système de produits ouvert</b><br />
<br />
Ce changement stratégique a une conséquence concrète : JetBrains Air ne peut pas simplement être un agent ou un environnement de développement de plus. Il doit connecter des produits conçus pour le travail individuel, la coordination des équipes, le contrôle organisationnel, le contexte et l’automatisation des processus, tout en restant ouvert aux outils et aux agents choisis par les développeurs, y compris ceux qui ne sont pas conçus par JetBrains.<br />
<br />
JetBrains Air comprend les produits suivants, certains étant déjà disponible, d'autres seront introduits à mesure que le système évoluera :<br />
<br />
- <b>Air dans les EDI JetBrains</b> : une expérience de développement agentique complète pour diriger et orchestrer les agents et vérifier leur travail au sein des EDI JetBrains. <br />
<br />
- <b>Air Teams</b> : une nouvelle façon de coordonner et d’automatiser les workflows de livraison logicielle impliquant des développeurs et des agents autonomes. <br />
<br />
- <b>Air Governance</b> (anciennement JetBrains Central) : politique organisationnelle, visibilité, auditabilité, gestion des coûts et responsabilité pour le développement assisté par l’IA et piloté par les agents. <br />
<br />
<b>Junie</b> est l’agent de programmation de JetBrains pour le développement logiciel professionnel. Il sera pris en charge sur toutes les surfaces Air.<br />
<br />
Air dans les EDI JetBrains fournit aux développeurs l’environnement requis pour diriger les agents et vérifier leurs résultats grâce à l’intelligence du code de JetBrains. Air Teams transforme l’activité individuelle des agents en workflows d’équipe coordonnés. Air Governance rend cette activité visible et gouvernable, avec une obligation d’en rendre compte à l’échelle de l’organisation.<br />
<br />
Mais un système ouvert ne peut pas se limiter aux produits de JetBrains. L’Agent Client Protocol (ACP) standardise la connexion entre un EDI et le dispositif complet autour d’un agent, y compris sa planification, sa logique, ses outils, son routage de modèles et son observabilité. Grâce au registre ACP, les développeurs peuvent découvrir et exécuter un nombre croissant d’agents compatibles tout en continuant à travailler au sein des EDI JetBrains.<br />
<br />
Air Governance est conçu pour étendre la visibilité et la gouvernance des coûts à l’ensemble des fournisseurs et des différents outils avec lesquels le travail agentique s’effectue. Cela signifie que les développeurs peuvent choisir l’agent, le modèle ou le service adapté à une tâche sans que l’organisation n’ait à renoncer au contexte, à la visibilité ou au contrôle. Ensemble, les produits Air permettent au travail de circuler entre les développeurs, les agents, les outils et les environnements sans perdre le contexte ni les contrôles qui l’entourent.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679594d1793031707/environnements-developpement/autres-edi/jetbrains/jetbrains-air-construire-systeme-produits-developpement-logiciel-agentique/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 745
Taille : 43,5 Ko"  style="float: CONFIG" /></div><br />
<b>L’adoption individuelle a progressé plus vite que l’infrastructure organisationnelle</b><br />
<br />
Les développeurs ont adopté les agents plus rapidement que les organisations n’ont été capables de mettre en place l’infrastructure nécessaire autour d’eux. Les capacités des agents ont progressé, et différents modèles et agents se sont révélés utiles pour différentes tâches. Cependant, le contexte, la coordination, la gouvernance et la gestion des coûts afférents n’ont pas suivi le même rythme.<br />
<br />
Pour de nombreux développeurs, les agents apportent déjà une valeur concrète. Au niveau organisationnel, la rentabilité est beaucoup plus difficile à démontrer. Les coûts apparaissent ailleurs : dans la révision, les retouches, la sécurité, l’infrastructure et les dépenses. Quels agents peuvent accéder au code de l’entreprise ? Où les données peuvent-elles aller ? Quels résultats nécessitent une révision humaine ? Que s’est-il passé pendant qu’un agent travaillait à distance ? Qui a approuvé la modification qui en a résulté et comment a-t-elle été vérifiée ?<br />
<br />
La fragmentation à ce niveau n’est pas seulement gênante. Elle rend le développement logiciel plus difficile à comprendre, à mesurer et à gouverner, précisément au moment où une part croissante du travail est déléguée.<br />
<br />
<b>Le goulot d’étranglement se déplace avec le travail</b><br />
<br />
Les erreurs évidentes dans le code sont rapidement détectées. Cette partie du système continue de fonctionner. Le problème le plus complexe réside dans le code presque correct : plausible, capable de passer avec succès une vérification superficielle, mais contenant insidieusement une mauvaise hypothèse ou une incohérence architecturale qui ne se révélera que lorsqu’il sera devenu coûteux de la corriger.<br />
<br />
À mesure que les agents prennent en charge une part croissante de l’exécution, le goulot d’étranglement se déplace de la réalisation de modifications vers leur compréhension, leur vérification et le fait d’en assumer la responsabilité. Le code devient moins coûteux à générer, mais plus coûteux à vérifier. L’activité des agents devient plus facile à démarrer, mais plus difficile à coordonner, à auditer et à expliquer. Et si le travail peut être délégué, la responsabilité, elle, ne peut pas l’être. Un agent ne recevra pas un appel à 3 heures du matin lorsque quelque chose ne va pas. La responsabilité de ce qui est livré appartient toujours aux personnes et aux organisations qui le livrent. <br />
<br />
C’est pourquoi le contrôle devient plus difficile, et non plus facile, à mesure que l’IA progresse. Un modèle plus performant peut produire de meilleurs résultats. Il ne définit pas de politique organisationnelle, ne conserve pas les informations de traçabilité, ne fournit pas de visibilité sur les coûts et ne décide pas qui est responsable des modifications qui en résultent.<br />
<br />
<b>L’avenir est multifournisseur</b><br />
<br />
La prise en charge multifournisseur est un principe de conception fondamental de JetBrains Air, qui façonne la manière dont le système est construit dès le départ. L'équipe de JetBrains affirme : « <i>Nous ne pensons pas que ce marché se consolidera de sitôt. Les modèles ont chacun leurs points forts et les classements évoluent mois après mois. Au sein d’une même entreprise, les équipes font déjà des choix différents, et elles ont souvent raison de le faire. Standardiser ses outils autour d’un seul fournisseur d’IA aujourd’hui revient à s’engager pour plusieurs années dans un marché qui change à chaque trimestre.</i> »<br />
<br />
Garder les options ouvertes est la démarche la plus raisonnable. Le problème, c’est ce que cette ouverture coûte actuellement. Chaque nouveau modèle, agent ou service qu’une organisation ajoute lui fait perdre un peu plus de visibilité sur son propre travail de développement. Le contexte ne se transmet pas d’un outil à l’autre. Les dépenses ne peuvent pas être attribuées. Les politiques doivent être redéfinies pour chaque service. Les organisations ne devraient pas avoir à choisir entre utiliser les meilleurs outils disponibles et comprendre ce qui se passe au sein de leur propre ingénierie. Cette situation existe parce que rien dans la pile technologique actuelle n’a été conçu pour se situer au-dessus de plusieurs fournisseurs à la fois.<br />
<br />
C’est le travail que JetBrains a entrepris. L'équipe de JetBrains commente : « <i>Nous développons notre propre agent, et nous avons l’intention de le rendre excellent. Mais JetBrains Air n’oblige pas les clients à l’utiliser, et notre stratégie ne dépend pas du fournisseur de modèles qui est en tête des classements ce trimestre. Nous n’avons aucune raison de restreindre l’écosystème. Ce que nous pouvons offrir à la place, c’est un espace unique pour exécuter, suivre, gouverner et assurer la traçabilité du développement agentique quels que soient les modèles, agents et services utilisés, pour les développeurs, les équipes et l’organisation. </i>»<br />
<br />
La prise en charge de plusieurs modèles et agents est un point de départ, pas un aboutissement. Ce qui compte vraiment, c’est ce qu’il y a au-dessus : un contexte partagé, un ensemble unique de politiques, une vue unifiée des coûts et un historique de ce qui s’est passé, quel que soit le fournisseur à l’origine des changements.<br />
<br />
<b><font size="3">Ce que JetBrains apporte</font></b><br />
<br />
Le choix multifournisseur ne résout qu’une partie du problème. Les agents ont également besoin d’une intelligence logicielle fiable. En réponse à cet enjeu, JetBrains apporte 26 ans d’intelligence en ingénierie, pour aider développeurs à comprendre la structure et le comportement des logiciels complexes, plutôt que de simplement en générer davantage. Cette intelligence déterministe du code constitue une base permettant de rendre le travail agentique plus fiable, plus efficace et plus compréhensible, quels que soient les modèles et les agents utilisés.<br />
<br />
C’est un avantage économique autant que technique. Les agents consacrent du temps et de l’argent à redécouvrir des informations que la base de code contient déjà. Un agent capable de récupérer cette connaissance est moins coûteux et plus précis qu’un agent qui doit la reconstruire. Comme cette intelligence n’appartient pas à un seul modèle, ses avantages peuvent s’étendre à l’ensemble des agents et services pris en charge.  L'équipe de JetBrains a déclaré : « <i>Nous traversons également la même transition que les organisations pour lesquelles nous concevons nos produits : nous adoptons des agents en interne, repensons nos workflows et apprenons où les gains de productivité individuels se traduisent par une meilleure livraison logicielle et où ils ne font que déplacer le travail ailleurs.</i> »<br />
<br />
Voici un extrait de l'annonce de JetBrains Air :<br />
<br />
<b>Ce qui est prévu pour la suite</b><br />
<br />
JetBrains Air va évoluer au fil d’une série continue de versions. Nous serons transparents quant à ce que les clients peuvent utiliser dès maintenant, ce qui entre en préversion et ce qui fera partie de notre orientation à plus long terme.<br />
<br />
Avec le temps, JetBrains Air s’étendra davantage aux expériences mobiles et à distance, permettant aux utilisateurs d’initier, de suivre, de réviser et de poursuivre le travail agentique à mesure qu’il se déplace entre les environnements. L’objectif n’est pas de reproduire l’IDE sur toutes les surfaces. Nous mettons à disposition le bon contexte et les bons contrôles partout où des décisions doivent être prises. <br />
<br />
Nous intégrerons également l’intelligence de JetBrains à un plus grand nombre de workflows agentiques. Cela inclut un contexte plus riche issu du code, de l’architecture, des dépôts, du comportement à l’exécution et des connaissances organisationnelles, ainsi que de meilleurs moyens d’orienter le travail entre développeurs, modèles, agents et services.<br />
<br />
Une part croissante du travail sera déclenchée par des événements de dépôt, des planifications et des processus de livraison, plutôt que par un développeur ouvrant un éditeur et soumettant un prompt. JetBrains Air fournira l’intelligence, la supervision et le contrôle humain requis pour ces workflows, dans les différents outils et services utilisés.<br />
<br />
Nous ne citerons pas de futurs produits avant que leur périmètre et leur disponibilité ne soient prêts à être confirmés. À chaque version, nous expliquerons ce qui fonctionne, comment les différents éléments s’articulent et ce qui est encore en cours de développement.<br />
<br />
<b>Dans quelle direction va JetBrains Air</b><br />
<br />
Les entreprises qui adopteront l’IA avec succès ne seront pas nécessairement celles qui génèrent le plus de code ou déploient le plus d’agents. Ce seront celles qui seront capables d’étendre l’expérimentation tout en préservant la qualité, le contexte, la discipline de gestion des coûts et la compréhension humaine.<br />
<br />
JetBrains Air représente notre engagement à concevoir des produits adaptés à cette réalité. Il fait évoluer JetBrains de l’environnement de travail du développeur vers un système de produits connectant développeurs, agents, équipes et organisations.<br />
<br />
L’objectif n’est pas plus de code. C’est que les développeurs, les équipes et les organisations puissent comprendre, vérifier et assumer pleinement les logiciels qu’ils créent.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7150" target="_blank">Découvrez JetBrains Air</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679593d1793031703/environnements-developpement/autres-edi/jetbrains/jetbrains-air-construire-systeme-produits-developpement-logiciel-agentique/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679594d1793031707/environnements-developpement/autres-edi/jetbrains/jetbrains-air-construire-systeme-produits-developpement-logiciel-agentique/2.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186352/environnements-developpement/autres-edi/jetbrains/jetbrains-air-construire-systeme-produits-developpement-logiciel-agentique/</guid>
		</item>
		<item>
			<title><![CDATA[Comment Netflix a amélioré l'efficacité de ses agents de codage IA grâce à l'intelligence des EDI JetBrains]]></title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186340&amp;goto=newpost</link>
			<pubDate>Mon, 26 Oct 2026 08:47:17 GMT</pubDate>
			<description>*Comment Netflix a amélioré...</description>
			<content:encoded><![CDATA[<div><b><font size="4">Comment Netflix a amélioré l'efficacité de ses agents de codage IA grâce à l'intelligence des EDI JetBrains</font></b><br />
<br />
JetBrains est une société à responsabilité limitée internationale spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux développeurs et aux chefs de projet. L'entreprise a son siège social à Amsterdam et dispose de bureaux en Chine, en Europe et aux États-Unis. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter dans une machine virtuelle Java (JVM).<br />
<br />
Netflix a intégré le moteur d’intelligence de code « headless » de JetBrains – le même que celui qui équipe IntelliJ IDEA – à Claude Code et Codex, puis l’a testé dans divers scénarios. Vous trouverez ci-dessous les détails et les chiffres.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679645d1793179913/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 29
Taille : 35,4 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">En bref</font></b><br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679646d1793179962/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 27
Taille : 178,4 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">L’objectif : augmenter le retour sur investissement des agents</font></b><br />
<br />
JetBrains et Netflix se sont donné pour mission de doter les agents de codage d’une compréhension précise du code, équivalente à celle d’IntelliJ IDEA, dans des environnements sans interface graphique – sans qu’aucune instance d’IntelliJ IDEA ne soit en cours d’exécution.<br />
<br />
« <i>Les agents de codage tels que Claude Code sont lents et peu fiables lorsqu’il s’agit de parcourir du code Java/Kotlin, en particulier au-delà des limites des bibliothèques (JAR). Nous avons intégré le moteur de code d’un IDE JetBrains « headless » afin de doter les agents d’une intelligence de code équivalente à celle de l’IDE IntelliJ dans des environnements « headless », sans qu’aucun IDE ne soit en cours d’exécution. Nous avons créé un test de performance avec de véritables tâches de programmation, qui montre qu’avec le moteur de code de l’IDE JetBrains, les agents sont systématiquement plus efficaces : ils utilisent moins de tokens et prennent moins de temps, le gain exact dépendant du modèle.</i> » — Paul Bakker, ingénieur logiciel senior, Netflix<br />
<br />
Le problème lié aux fichiers JAR que Netflix tente de résoudre et que Paul décrit ci-dessus : les projets JVM fournissent généralement les bibliothèques uniquement sous forme de fichiers JAR, jamais sous forme de code source. Les agents doivent décompresser les fichiers JAR (en devinant lesquels sont pertinents), éventuellement décompiler les fichiers de classe, puis effectuer des recherches dans cette vue incomplète.<br />
<br />
<b><font size="3">La solution : l’intelligence de l’EDI JetBrains</font></b><br />
<br />
JetBrains a passé des années à développer le moteur d’intelligence de code qui sous-tend IntelliJ IDEA. Il repose sur un index déterministe de vos fichiers source de projet, y compris toutes les bibliothèques. Cette intelligence est désormais exposée via un LSP et disponible dans les éditeurs compatibles avec VS Code. Netflix a travaillé avec une version « headless » de ce moteur.<br />
<br />
Le LSP à lui seul ne suffit pas pour qu’un agent de codage puisse l’utiliser directement : il s’agit simplement d’un serveur utilisant un protocole, sans moyen simple pour un agent de l’appeler et sans gestion intégrée des processus permettant de réutiliser une instance en cours d’exécution entre deux appels. Netflix a comblé cette lacune par ses propres moyens en utilisant le démon et l’interface en ligne de commande (CLI) décrits dans la section suivante.<br />
<br />
<b><font size="3">Architecture en détail : maintenir l’index à jour</font></b><br />
<br />
La construction d’un index pour un projet prend du temps, tout comme l’ouverture d’un gros projet dans IntelliJ IDEA pour la première fois. Un agent de codage appelle le LSP en plusieurs petites étapes très fines, et une tâche réaliste nécessite plusieurs appels de ce type. Si chacun d’entre eux lançait un nouveau serveur LSP, chaque appel entraînerait un coût de démarrage à froid de plusieurs secondes – même sur un projet dont l’index avait déjà été construit une minute auparavant.<br />
<br />
Un processus démon est nécessaire pour éviter la surcharge liée au démarrage à froid du processus serveur LSP lors d’appels répétés. JetBrains travaille à la mise à disposition d’un démon, mais aucun n’était disponible au moment de l’évaluation ; Netflix en a donc développé un pour ses propres besoins :<br />
<br />
1. Chaque appel de l’outil était de courte durée et sans état : il se contentait de rediriger vers l’interface en ligne de commande (CLI).<br />
<br />
2. Le démon est la composante qui reste active : son gestionnaire de sessions achemine chaque appel, en fonction de la racine du projet, vers le processus serveur correspondant, qui conserve l’index de ce projet en mémoire.<br />
<br />
3. Un deuxième appel concernant le même projet ignore complètement l’indexation et passe directement par un serveur « chaud » via stdio.<br />
<br />
4. Le démon et l’interface en ligne de commande sont tous deux développés en Java et distribués sous forme d’exécutable GraalVM ; il n’y a donc aucune surcharge liée au démarrage ou à l’exécution de la JVM.<br />
<br />
<b><font size="3">Comment Netflix a mesuré le retour sur investissement de l’intelligence de l’EDI JetBrains</font></b><br />
<br />
Afin de déterminer si (et dans quelle mesure) l’intelligence de l’IDE JetBrains améliore les performances d’un agent de codage, une suite de tests de performance a été développée. Même modèle, même tâche, même base de code : la seule variable était la capacité de l’agent à faire appel à l’intelligence de l’EDI JetBrains. Les résultats sont présentés sous forme de différence de performances entre les exécutions avec l’intelligence de l’IDE JetBrains et celles sans.<br />
<br />
Environnement et approche d’évaluation :<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679647d1793179981/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 25
Taille : 200,8 Ko"  style="float: CONFIG" /></div><br />
Les tests de performance ont été effectués à plusieurs reprises afin de valider les résultats et d’observer les effets des modifications apportées par les nouvelles versions de LSP.<br />
<br />
<b><font size="3">Résultats</font></b><br />
<br />
Pour tous les modèles, agents et types de tâches testés, l’intelligence de l’EDI JetBrains a rendu les agents de codage globalement plus efficaces – généralement de 20 à 30 % plus efficaces, et jusqu’à environ 65 % dans le meilleur des cas, en fonction du modèle, de l’agent et de la tâche spécifiques. Ce sont les modèles les plus puissants, nécessitant un effort plus important, qui ont enregistré les gains les plus significatifs. Ces modèles sont plus coûteux, ce qui rend les gains d’efficacité d’autant plus importants, mais ils sont également plus performants dans l’utilisation efficace des index.<br />
<br />
Gain d’efficacité par configuration, combinant économies de tokens et de temps. Chaque comparaison exécute deux fois la même tâche, avec le même modèle et la même base de code : une fois avec l’intelligence de l’EDI JetBrains, et une fois sans.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679648d1793179997/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 26
Taille : 56,8 Ko"  style="float: CONFIG" /></div><br />
L’efficacité correspond à la moyenne des économies de tokens et de temps pour chaque configuration. La précision est restée stable ou s’est améliorée à chaque exécution. *Tokens uniquement : les appels de recherche par lots de cette configuration ont rendu la comparaison des temps de navigation dans le code non représentative – voir le corps de l’article. Les chiffres constituent un instantané et évolueront avec les nouvelles versions des modèles.<br />
<br />
Ces chiffres constituent un instantané, et non un résultat de benchmark fixe. Chaque nouvelle version de modèle modifie la manière dont les agents effectuent leurs recherches, raisonnent et utilisent les outils ; les pourcentages exacts continueront donc à évoluer – c’est pourquoi ce rapport présente des fourchettes plutôt que des résultats par modèle. Ce qui est resté constant d’un test à l’autre chez Netflix, c’est la tendance générale : chaque modèle et chaque agent testé a gagné en efficacité, les gains les plus importants ont été obtenus par le modèle le plus performant avec un niveau d’effort élevé, et l’ampleur du gain variait sensiblement d’un modèle à l’autre.<br />
<br />
<b>Tâches de navigation dans le code : une efficacité accrue à tous les niveaux, une précision maintenue ou améliorée</b><br />
<br />
Tous les modèles et tous les niveaux d’effort testés ont utilisé moins de tokens grâce à l’intelligence de l’IDE JetBrains – sans aucune exception –, avec des économies allant d’environ 15 % à 60 %. L’ampleur du gain dépendait principalement du modèle : le modèle le plus performant a enregistré de loin les plus grandes améliorations, tandis que les configurations plus légères se situaient dans la partie inférieure des deux fourchettes. La précision est restée stable dans la plupart des essais et s’est améliorée dans deux d’entre eux – elle n’a jamais baissé.<br />
<br />
Pour les tâches de navigation dans le code en particulier, une combinaison outil/modèle regroupe déjà plusieurs appels de recherche en une seule commande ; ainsi, avec ou sans l’intelligence de l’IDE JetBrains, un seul appel à l’outil est effectué à ce stade. L’appel à l’intelligence de l’EDI JetBrains est légèrement plus lent pour cet appel unique que la commande de recherche groupée – ce qui explique l’absence manifeste de gain de temps pour cette combinaison, qui ne reflète pas fidèlement l’utilisation en conditions réelles. C’est pourquoi la suite de tâches de bout en bout, plus large, constitue un indicateur plus fiable en termes de temps : l’intelligence de l’IDE JetBrains s’est avérée plus rapide pour tous les modèles et agents testés.<br />
<br />
<b>Tâches de bout en bout : une efficacité systématiquement supérieure, sans incidence sur la précision</b><br />
<br />
Lors de l’exécution étendue de bout en bout, la précision est restée stable pour tous les modèles et agents testés ; l’avantage réside donc entièrement dans l’efficacité, et non dans la simple réalisation de la tâche. Chaque combinaison de modèle et d’agent s’est avérée environ 10 à 30 % plus efficace avec l’intelligence de l’IDE JetBrains, si l’on considère le temps nécessaire à l’exécution et la consommation de jetons. Cela s’explique en grande partie par le fait que moins d’appels d’outils sont nécessaires pour parvenir aux mêmes conclusions.<br />
<br />
<b><font size="3">Autres alternatives évaluées</font></b><br />
<br />
Avant d’opter pour l’approche décrite, Netflix a écarté deux autres solutions. La première rejetée était une interface CLI interne développée en interne qui se connectait à une instance d’IntelliJ IDEA en cours d’exécution pour accéder à un index de projet. Le processus est similaire à celui décrit dans cet article, mais il nécessite qu’un EDI soit en cours d’exécution. Cette approche ne convenait pas aux agents « headless » pour des environnements tels qu’Otto, Bitbot, les outils de refactorisation distribués, l’intégration continue (CI), etc.<br />
<br />
Deuxièmement, un LSP Eclipse existant, utilisé pour Java dans VS Code, a été envisagé. Mais pour le système de build de Netflix (basé sur Gradle), cela ne fonctionnait tout simplement pas.<br />
<br />
<b><font size="3">Prochaines étapes</font></b><br />
<br />
<b>Quelle direction Netflix va-t-elle prendre ?</b><br />
<br />
À l’issue du test, Netflix a conclu que « les tests de performance montrent qu’il y a un avantage à disposer d’une couche d’intelligence déterministe aux côtés de votre agent ». Bien sûr, cela ne réduit pas chaque tâche des agents de codage d’un pourcentage fixe. Mais pour ce problème spécifique – la résolution de la structure réelle au-delà des limites des fichiers JAR –, l’avantage est considérable, vaut pour tous les modèles et n’entraîne aucune perte d’exactitude.<br />
<br />
Netflix prévoit d’appliquer la même méthodologie de benchmark à Python, TypeScript/JavaScript et Go. Les agents de codage pour ces langages rencontrent des problèmes similaires. Mais bien sûr, la manière dont les bibliothèques sont téléchargées dans un projet varie selon le langage ; les mécanismes des problèmes et les solutions possibles diffèrent donc. JetBrains prévoit de poursuivre cette collaboration et de soutenir davantage cette évaluation.<br />
<br />
<b>Le point de vue de JetBrains : le LSP n’est qu’une étape, pas une fin en soi</b><br />
<br />
L’intelligence de l’EDI JetBrains pour Java a été testée par Netflix et est désormais fournie dans le cadre de l’extension « Java &amp; Kotlin by IntelliJ IDEA ». JetBrains poursuit également ses expérimentations avec l’approche LSP+CLI et communiquera les résultats dès qu’ils seront prêts.<br />
<br />
La primitive de base du LSP est une position dans un document texte. La spécification définit une position comme « l’espace entre deux caractères, à l’instar d’un curseur d’insertion dans un éditeur ». Il s’agit là d’une primitive naturelle pour un utilisateur travaillant au clavier. Mais les agents ne raisonnent pas vraiment en termes d’emplacement du curseur. Ils posent des questions sur le programme, telles que « Pourquoi cet appel à l’intérieur de <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">createUser()</span> n’est-il pas résolu ? » ou « Quels tests couvrent cette méthode ? », etc. Il s’agit de comprendre les relations entre les différentes parties du code plutôt que de se concentrer sur les positions du curseur. De plus, une position dans le texte est une identité fragile : l’insertion d’un seul caractère avant une position donnée entraîne le déplacement de cette position.<br />
<br />
Ce dont un agent a besoin, ce n’est pas d’un curseur plus précis, mais d’une couche qui fournisse des réponses formulées de la même manière que les tâches elles-mêmes – c’est-à-dire en termes de symboles, de diagnostics, de relations de test, de comportement d’exécution – et qui renvoie suffisamment de contexte pour raisonner sur la réponse, et pas seulement des emplacements dans un document texte.<br />
<br />
« <i>C’est ce que j’entends par “moteur de code” : non pas un protocole de plus permettant à un agent d’imiter l’interaction avec un éditeur, mais un ensemble d’opérations précises portant sur la structure et l’exécution du programme – un ensemble qui renvoie suffisamment de contexte pour permettre de véritablement raisonner sur le résultat. Le LSP est utile, mais il ne devrait pas définir l’abstraction finale destinée à l’agent. Si vous concevez les outils destinés aux agents comme si ceux-ci étaient de minuscules êtres humains devant un éditeur, vous les forcez à s’exprimer en coordonnées de curseur. Les agents ont besoin d’un moteur de code, pas d’un éditeur virtuel.</i> »  — Aleksey Stukalov, responsable de la division EDI, JetBrains<br />
<br />
Les chiffres de Netflix prouvent que l’intelligence de code vaut la peine d’être financée. Déterminer quelle forme prendra cette intelligence est le défi qui nous attend.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7154" target="_blank">Découvrez le système d'IA agentique de JetBrains</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679646d1793179962/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679648d1793179997/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679647d1793179981/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679645d1793179913/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/1.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>JetBrains</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186340/environnements-developpement/autres-edi/jetbrains/netflix-ameliore-l-efficacite-agents-codage-ia-grace-l-intelligence-edi-jetbrains/</guid>
		</item>
		<item>
			<title>Outils d’observabilité des pipelines CI/CD : comment choisir la bonne configuration</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186303&amp;goto=newpost</link>
			<pubDate>Thu, 22 Oct 2026 18:30:08 GMT</pubDate>
			<description><![CDATA[*Outils d'observabilité des...]]></description>
			<content:encoded><![CDATA[<div><b><font size="4">Outils d'observabilité des pipelines de développement logiciel continu CI/CD : comment choisir la bonne configuration, par JetBrains</font></b><br />
<br />
En génie logiciel, le CI/CD ou CICD désigne l'ensemble des pratiques d'intégration continue (CI) et de livraison continue (CD) ou, plus rarement, de déploiement continu. Ces pratiques sont parfois désignées collectivement sous le nom de « développement continu » ou « développement logiciel continu ». TeamCity est un serveur de gestion des builds et d'intégration continue/livraison continue (CI/CD) développé par JetBrains. Lancé le 2 octobre 2006, TeamCity est conçu pour aider les équipes de développement à automatiser les processus de build, de test et de déploiement pour des projets logiciels sur plusieurs plateformes et technologies. TeamCity fonctionne selon un modèle de licence freemium, proposant une offre gratuite comprenant jusqu’à 100 configurations de build et trois licences d’agent de build, tandis que les projets open source peuvent demander des licences entièrement gratuites. Les fonctionnalités d’entreprise nécessitent une licence payante.<br />
<br />
Lorsqu’un pipeline CI/CD échoue, son tableau de bord permet généralement d’identifier la source du problème. Les outils d’observabilité des pipelines doivent vous aider à comprendre pourquoi, que la cause soit un test instable, un agent de compilation surchargé ou un problème situé ailleurs dans le processus de livraison. Cela devient plus difficile à mesure que les pipelines gagnent en complexité. Un pipeline fait appel à de nombreux systèmes distincts : contrôle de version, agents de build, conteneurs, frameworks de test, référentiels d’artefacts, scanners de sécurité et outils de déploiement. Chacun génère ses propres données, et il n’est pas aisé de les rassembler toutes lors d’une analyse.<br />
<br />
L’enquête JetBrains Developer Ecosystem Survey 2026 montre à quel point ces défis sont courants. Lorsque nous avons demandé à 20 416 participants de citer leurs trois principaux défis liés à l’utilisation d’une infrastructure cloud, 44 % ont mentionné le débogage et le dépannage dans les environnements cloud. La sécurité et le contrôle d’accès ont été cités par 36 %, tout comme la visibilité et l’optimisation des coûts. L’observabilité a été mentionnée par 16 %, tandis que 12 % ont souligné le nombre trop important d’outils, de consoles ou de tableaux de bord distincts.<br />
<br />
<div style="text-align: center;"><div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679565d1793008173/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 10482
Taille : 41,4 Ko"  style="float: CONFIG" /></div><i>Rapport sur l'écosystème des développeurs JetBrains 2026</i></div><br />
Cet article explique ce que signifie l’observabilité des pipelines CI/CD, quelles métriques méritent d’être suivies et comment se comparent les outils d’observabilité les plus courants. Il fournit également un cadre pour choisir les outils d’observabilité CI/CD adaptés à votre équipe.<br />
<br />
<b><font size="3">Qu’est-ce que l’observabilité des pipelines CI/CD ?</font></b><br />
<br />
L’observabilité des pipelines CI/CD est la capacité à comprendre l’état et le comportement d’un pipeline de livraison à partir des données qu’il produit, notamment les résultats de build, les métriques, les journaux, les événements et les traces.<br />
<br />
Concrètement, un pipeline observable devrait vous aider à répondre à des questions telles que :<br />
<br />
- Pourquoi les builds prennent-ils plus de temps que le mois dernier ?<br />
- Pourquoi un pool d’agents tombe-t-il plus souvent en panne qu’un autre ?<br />
- Quelle étape du pipeline a introduit une régression ?<br />
- La panne est-elle due à une modification du code ou à un changement dans l’environnement de build ?<br />
<br />
La surveillance et l’observabilité sont étroitement liées, mais elles ne sont pas identiques. La surveillance du pipeline suit des conditions connues. Vous définissez une métrique ou un événement, vous l’affichez sur un tableau de bord et vous pouvez éventuellement créer une alerte lorsqu’il dépasse un seuil. L’observabilité est utile lorsque la cause d’un problème n’est pas immédiatement évidente. Elle vous fournit suffisamment de données corrélées pour enquêter sur des défaillances inattendues sans avoir à mettre en place un nouveau suivi ni à attendre que le problème se reproduise.<br />
<br />
Par exemple, la surveillance peut montrer que la durée d’une build a soudainement augmenté. L’observabilité vous aide à attribuer cette augmentation à un pipeline, une étape, un agent de build, un commit, un test ou un problème d’infrastructure en particulier.<br />
<br />
<div style="text-align: center;"><div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679566d1793008182/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 399
Taille : 61,2 Ko"  style="float: CONFIG" /></div><i>Moniteur de performance TeamCity</i></div><br />
<b><font size="3">Que faut-il observer dans un pipeline CI/CD ?</font></b><br />
<br />
L’observabilité du pipeline couvre à la fois le travail effectué par le pipeline et la plateforme qui l’exécute. Au niveau du pipeline, ces métriques se répartissent en deux groupes : dans le premier, on trouve le temps d’attente en file d’attente, la durée totale et la durée par étape, qui vous indiquent à quel moment les développeurs sont mis en attente. Dans l’autre groupe, on trouve les taux de réussite, les nouvelles tentatives, les tests instables et les performances du cache, qui vous indiquent à quel moment le pipeline lui-même devient moins fiable.<br />
<br />
Au niveau de la plateforme, les équipes ont besoin d’une visibilité sur les agents ou les exécuteurs, la consommation de CPU et de mémoire, l’activité disque et réseau, l’état de santé des serveurs et la disponibilité des dépendances externes. Ce contexte permet de distinguer un problème de code d’un problème d’infrastructure. Les métriques les plus utiles sont celles liées à une analyse concrète.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679567d1793008190/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 410
Taille : 190,6 Ko"  style="float: CONFIG" /></div><br />
Les centiles sont généralement plus informatifs que les moyennes pour les métriques de durée et de temps d’attente. Une moyenne stable peut masquer une mauvaise expérience pour les 5 % ou 10 % de builds les plus lents. Se concentrer uniquement sur un taux de réussite global peut masquer des problèmes. Ce chiffre peut sembler satisfaisant même si une branche, une image d’agent de build ou une suite de tests échoue régulièrement. Pour identifier ces tendances, les équipes doivent pouvoir ventiler les métriques par projet, branche, étape du pipeline, pool d’agents, environnement et type d’échec.<br />
<br />
Votre système CI/CD constitue généralement la meilleure source d’informations sur l’identité des exécutions et la structure du pipeline. Par exemple, les graphiques statistiques de TeamCity relient la durée de la compilation, le temps d’attente, les taux de réussite, les tests, les artefacts et d’autres statistiques à la configuration de compilation sous-jacente. Ce contexte s’avère particulièrement précieux lorsque les données CI sont exportées vers un autre système d’observabilité.<br />
<br />
<div style="text-align: center;"><div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679568d1793008202/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 395
Taille : 165,2 Ko"  style="float: CONFIG" /></div><i>Statistiques de configuration de build dans TeamCity</i></div><br />
:fleche: <a href="https://www.developpez.com/redirect/7148" target="_blank">Apprenez-en plus sur TeamCity</a><br />
<br />
<br />
<b><font size="3">Comment les équipes surveillent les pipelines CI/CD en 2026</font></b><br />
<br />
L'enquête « The State of Developer Ecosystem Survey 2026 » a demandé à 8 323 participants quels outils ils utilisaient pour la surveillance des pipelines CI/CD. Les participants pouvaient sélectionner plusieurs réponses.<br />
<br />
<div style="text-align: center;"><div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679569d1793008229/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/5.jpg/" border="0" alt="Nom : 5.jpg
Affichages : 386
Taille : 36,6 Ko"  style="float: CONFIG" /></div><i>Rapport sur l'écosystème des développeurs JetBrains 2026</i></div><br />
Les tableaux de bord CI/CD intégrés constituent l'option la plus courante, utilisée par 76 % des participants. Ils font déjà partie intégrante de la plateforme CI/CD, ne nécessitent que peu de configuration et affichent les exécutions de pipeline, les étapes, les tests et les échecs dans leur contexte d’origine. Cependant, de nombreuses équipes utilisent plusieurs outils d’observabilité. Elles peuvent par exemple analyser un build ayant échoué dans le tableau de bord CI/CD, utiliser Prometheus et Grafana pour surveiller l’infrastructure de build, et effectuer des recherches dans les logs via Elastic ou OpenSearch.<br />
<br />
Ces outils ne constituent pas des alternatives directes : chacun fournit un type d’informations différent. Les métriques montrent les tendances et les évolutions au fil du temps, les journaux fournissent des enregistrements détaillés de ce qui s’est passé, et les traces montrent comment le travail a progressé à travers les différentes parties du pipeline. OpenTelemetry aide à collecter et à envoyer ces données, mais il nécessite tout de même un système distinct pour les stocker et les afficher.<br />
<br />
<b><font size="3">Comment choisir un outil d’observabilité pour un pipeline CI/CD</font></b><br />
<br />
La plupart des outils d’observabilité promettent les mêmes fonctionnalités de base : des tableaux de bord, des alertes et quelques intégrations. Ce qui les distingue réellement, c’est le type de données qu’ils collectent, la qualité de la connexion de ces données à vos pipelines, ainsi que la charge de travail nécessaire pour les configurer et les maintenir en fonctionnement. Les cinq critères suivants peuvent vous aider à comparer les différentes options et à choisir celle qui convient le mieux à votre équipe.<br />
<br />
<b>1. Profondeur d’analyse et contexte CI/CD</b><br />
<br />
Réfléchissez aux problèmes que vous souhaitez que l’outil vous aide à analyser. Si un pipeline échoue, pouvez-vous identifier rapidement l’étape ou le test concerné ? Pouvez-vous comparer l’exécution ayant échoué à des exécutions antérieures réussies ? Pour répondre à ces questions, l’outil doit maintenir chaque métrique, journal ou trace en lien avec l’exécution du pipeline concerné. Il doit être possible de voir de quel dépôt, branche, commit, étape et environnement proviennent les données.<br />
<br />
Vous pourriez également avoir besoin d’informations sur la pull request, l’agent de build, le test ou l’artefact impliqué.<br />
<br />
<div style="text-align: center;"><div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679570d1793008235/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/6.jpg/" border="0" alt="Nom : 6.jpg
Affichages : 385
Taille : 75,6 Ko"  style="float: CONFIG" /></div><i>L'assistant IA de TeamCity aide à analyser les échecs de compilation.</i></div><br />
Les tableaux de bord CI/CD intégrés sont utiles car ils disposent déjà de ce contexte. Lorsque vous évaluez un outil d’observabilité externe, vérifiez si son intégration conserve ces liens ou si elle réduit le pipeline à un ensemble de métriques et de journaux sans rapport les uns avec les autres.<br />
<br />
<b>2. Corrélation entre les systèmes</b><br />
<br />
Un problème de pipeline peut provenir de nombreuses sources, notamment d’un exécuteur de build, d’un conteneur, d’un service cloud, d’un référentiel d’artefacts, d’une API externe ou d’un environnement de déploiement. Un bon outil d’observabilité doit relier les données de ces systèmes, afin que les développeurs n’aient pas à comparer les horodatages ni à parcourir plusieurs tableaux de bord pour comprendre ce qui s’est passé. Cela s’avère particulièrement utile pour les organisations qui travaillent avec plusieurs plateformes ou environnements CI/CD.<br />
<br />
Selon l’enquête « State of Developer Ecosystem Survey 2026 », 22 % des personnes interrogées trouvent la gestion de plusieurs environnements difficile, tandis que 12 % sont confrontées à la difficulté liée au nombre trop élevé d’outils, de consoles ou de tableaux de bord distincts. Un outil d’observabilité doit rassembler ces informations plutôt que d’ajouter un nouveau tableau de bord isolé.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679571d1793008241/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/7.jpg/" border="0" alt="Nom : 7.jpg
Affichages : 384
Taille : 52,4 Ko"  style="float: CONFIG" /></div><br />
<b>3. Configuration et facilité d’utilisation</b><br />
<br />
Les différents outils d’observabilité nécessitent des niveaux de configuration variables. Un tableau de bord CI/CD intégré peut fonctionner immédiatement, tandis que les outils externes doivent être connectés au pipeline et configurés pour collecter, stocker et afficher les données pertinentes. Le traçage distribué peut nécessiter des modifications supplémentaires du pipeline lui-même. Une configuration plus complexe peut s’avérer utile si elle fournit à votre équipe les informations dont elle a besoin. Cependant, vous devez évaluer la charge de travail que représentera la mise en place et la maintenance de l’outil.<br />
<br />
L’outil doit également être facile à utiliser pour les développeurs. Ce sont généralement eux les premiers à détecter une défaillance du pipeline. S’ils ne peuvent pas comprendre les données sans l’aide de l’équipe chargée de la plateforme, l’outil n’aura qu’une valeur limitée dans le cadre des analyses quotidiennes.<br />
<br />
<b>4. Sécurité et modèle de déploiement</b><br />
<br />
Les données collectées à partir des pipelines CI/CD peuvent inclure des détails sur les dépôts et les commits, des noms d’utilisateur, des adresses d’infrastructure et des informations sur les environnements de build. Les journaux de build peuvent également contenir des mots de passe, des jetons ou d’autres informations confidentielles si les données sensibles ne sont pas correctement masquées.<br />
<br />
Il ne s’agit pas d’un problème mineur : la sécurité, les autorisations et le contrôle d’accès ont été classés parmi les principaux défis liés au cloud par 36 % des personnes interrogées. Avant de choisir un outil, renseignez-vous sur l’emplacement de stockage de vos données, la manière dont elles sont protégées lors de leur transfert, les personnes autorisées à y accéder et la durée de leur conservation. Votre organisation peut également avoir besoin de contrôles d’accès, de journaux d’activité, d’un chiffrement, d’un choix de région de stockage des données ou de la possibilité d’exécuter l’outil sur sa propre infrastructure.<br />
<br />
<b>5. Coût, maintenance et portabilité</b><br />
<br />
Le prix de l’abonnement ou de la licence ne représente qu’une partie du coût total. La collecte de grandes quantités de métriques détaillées, de journaux et de traces peut augmenter les coûts de stockage et de traitement. Un outil auto-hébergé peut réduire les frais d’abonnement, mais votre équipe devra tout de même fournir l’infrastructure, installer les mises à jour, gérer les sauvegardes et assurer la maintenance du système.<br />
<br />
Vous devez également vous demander s’il serait facile de transférer vos données vers un autre outil. 10 % des personnes interrogées ont cité la dépendance vis-à-vis d’un fournisseur et la portabilité comme des défis liés à l’utilisation des services cloud. Les normes ouvertes ne peuvent pas rendre une migration sans effort, mais elles peuvent réduire la quantité de données à collecter et la configuration des pipelines à reconstruire.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7149" target="_blank">Essayez TeamCity gratuitement</a><br />
<br />
<br />
<b><font size="3">Open source, géré, ou une combinaison des deux ?</font></b><br />
<br />
On parle souvent des plateformes open source par opposition aux plateformes commerciales comme s’il s’agissait d’un choix binaire. Mais la plupart des équipes ont, pour ainsi dire, « un pied dans chaque camp ». Prometheus, Grafana, OpenSearch et OpenTelemetry vous offrent un contrôle total sur l’hébergement, les données et leur conservation. C’est vous qui décidez où elles sont stockées et combien de temps elles y restent. En contrepartie, c’est également à vous qu’il revient de les faire fonctionner et d’en assurer la sécurité.<br />
<br />
Les plateformes commerciales vous déchargent de cette tâche. Vous obtenez plus rapidement des données utiles, mais vous payez des frais d’abonnement et d’ingestion, et vous confiez à un tiers le choix de l’emplacement de stockage de vos données. En réalité, la plupart des équipes ne choisissent pas vraiment leur camp. Une configuration type utilise OpenTelemetry pour collecter les données, Prometheus pour les métriques d’infrastructure, et une plateforme gérée pour le stockage et l’analyse de l’ensemble.<br />
<br />
Faites votre choix en fonction de ce que votre équipe sait déjà gérer et des questions auxquelles vous avez réellement besoin de réponses, et non en fonction du fait qu’une plateforme donnée soit open source ou commerciale.<br />
<br />
<b><font size="3">Comparaison des outils d’observabilité des pipelines CI/CD</font></b><br />
<br />
L’enquête « State of Developer Ecosystem Survey 2026 » a regroupé les outils d’observabilité par type. Cela signifie que les résultats montrent l’ampleur de l’adoption de chaque approche, mais pas l’utilisation de produits individuels. Par exemple, 14 % des répondants utilisent une plateforme d’observabilité commerciale, mais l’enquête ne précise pas comment ce pourcentage se répartit entre Datadog, New Relic et Dynatrace.<br />
<br />
C’est pourquoi la comparaison ci-dessous reprend les mêmes catégories d’outils que l’enquête et évalue chacune d’entre elles à l’aune de notre cadre de sélection.<br />
<br />
<b><font size="3">Tableaux de bord CI/CD intégrés</font></b><br />
<br />
<b>Modèle</b> : inclus dans une plateforme CI/CD cloud ou auto-hébergée.<br />
<b>Signaux et contexte CI</b> : exécutions de pipeline, étapes, journaux de build, tests, modifications, temps d’attente et informations sur les agents ou les runners.<br />
<b>Configuration</b> : généralement disponible par défaut, avec des graphiques, des rapports, des API ou des exportations de métriques supplémentaires selon la plateforme.<br />
<br />
Les tableaux de bord intégrés constituent généralement le meilleur premier niveau d’observabilité des pipelines. Un test échoué, une étape de staging lente, des builds en file d’attente et les commits déclencheurs sont présentés comme des éléments liés d’une même exécution plutôt que comme des enregistrements de télémétrie distincts.<br />
<br />
- <b>Idéal pour</b> : les analyses quotidiennes lorsque la plupart des équipes utilisent la même plateforme CI/CD.<br />
- <b>Points forts</b> : contexte CI natif solide, effort de configuration réduit et accès direct à partir du résultat du build.<br />
- <b>Limite</b> : la visibilité inter-systèmes est souvent restreinte. Le tableau de bord peut indiquer qu’une étape a ralenti sans préciser si la cause est liée à l’infrastructure, au stockage, au réseau ou à un service externe.<br />
<br />
Lors de l’évaluation d’un tableau de bord intégré, privilégiez l’analyse des tendances historiques, de l’historique des tests, de la file d’attente et de la charge de travail des agents plutôt que de vous concentrer uniquement sur la dernière exécution.<br />
<br />
TeamCity fournit des statistiques sur les builds et les projets, l’historique des tests, les journaux, des informations sur la charge de travail des agents et des visualisations du pipeline. Notre article sur le dépannage des builds à l’aide des tableaux de bord TeamCity montre comment ces sources peuvent être combinées lors d’une analyse.<br />
<br />
<b><font size="3">Prometheus et Grafana</font></b><br />
<br />
<b>Modèle</b> : Open source et généralement autogéré, avec des services Grafana gérés également disponibles.<br />
<b>Signaux et contexte CI</b> : métriques de séries chronologiques, étiquettes, tableaux de bord et alertes ; le contexte CI dépend des métriques exportées.<br />
<b>Configuration</b> : configuration de la collecte de données par Prometheus et règles d’alerte, généralement au format YAML ; tableaux de bord et sources de données Grafana.<br />
<br />
<div style="text-align: center;"><div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679572d1793008248/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/8.jpg/" border="0" alt="Nom : 8.jpg
Affichages : 381
Taille : 96,8 Ko"  style="float: CONFIG" /></div><i>Tableau de bord Grafana de l'équipe d'infrastructure JetBrains IntelliJ</i></div><br />
Prometheus collecte et interroge les données de séries chronologiques, tandis que Grafana fournit les tableaux de bord et la visualisation. Ensemble, ils constituent l’approche basée sur les métriques la plus courante dans l’enquête, choisie par 29 % des personnes interrogées.<br />
<br />
- <b>Idéal pour</b> : la surveillance de l’infrastructure CI, de la capacité, de l’utilisation et des tendances de performances.<br />
- <b>Points forts</b> : requêtes et tableaux de bord flexibles, forte corrélation au niveau de l’infrastructure et contrôle du stockage des données.<br />
- <b>Limite</b> : les métriques peuvent indiquer où et quand un comportement a changé, mais peuvent ne pas contenir suffisamment de détails pour expliquer la cause exacte. Les équipes doivent également gérer la pile et contrôler la cardinalité des métriques.<br />
<br />
La qualité du résultat dépend fortement des libellés des métriques. Le contexte du pipeline, de l’étape, du résultat, du projet et du pool d’agents rend l’agrégation utile. Les identifiants de build individuels et les hachages de commit doivent être traités avec soin pour éviter une cardinalité inutilement élevée.<br />
<br />
TeamCity expose les métriques du serveur au format Prometheus. Notre guide sur la surveillance de l’état de santé du serveur TeamCity avec Prometheus et Grafana couvre les files d’attente de build, les agents, la charge du serveur, l’état de santé de la JVM et les connexions à la base de données.<br />
<br />
<b><font size="3">Elastic Stack et OpenSearch</font></b><br />
<br />
<b>Modèle</b> : logiciel open source ou « open-core » proposant des options de déploiement autogérées et gérées.<br />
<b>Signaux et contexte CI </b>: principalement des journaux et des événements consultables, avec prise en charge des métriques et des traces selon la pile.<br />
<b>Configuration</b> : collecteurs, pipelines d’analyse et d’ingestion, schémas, index, tableaux de bord et politiques de conservation.<br />
<br />
Elastic Stack et OpenSearch représentent la catégorie de l’agrégation des journaux, utilisée par 18 % des personnes interrogées. Ils s’avèrent utiles lorsqu’une enquête repose sur des informations détaillées issues des étapes du pipeline, des agents, de l’infrastructure ou de services externes.<br />
<br />
- <b>Idéal pour</b> : les organisations menant des enquêtes impliquant un volume important de journaux ou disposant d’une plateforme de journalisation centralisée existante.<br />
- <b>Points forts</b> : recherche parmi de grands volumes d’événements liés aux pipelines et à l’infrastructure.<br />
- <b>Limite</b> : la centralisation des logs ne préserve pas automatiquement la structure du pipeline. Les volumes d’ingestion et de stockage peuvent également entraîner des coûts élevés.<br />
<br />
Collecter davantage de logs ne suffit pas. Chaque entrée de log doit indiquer à quel exécution de pipeline, à quelle étape, à quel référentiel et à quel agent de build elle appartient. Les informations sensibles contenues dans les résultats de build doivent également être masquées avant le stockage des logs.<br />
<br />
Elastic documente une architecture d’observabilité CI/CD basée sur OpenTelemetry, tandis qu’OpenSearch prend en charge l’exploration des journaux, des métriques et des traces. La richesse du contexte du pipeline dépend toujours de la manière dont le système CI/CD est instrumenté.<br />
<br />
<b><font size="3">OpenTelemetry</font></b><br />
<br />
<b>Modèle</b> : norme d’instrumentation open source et indépendante des fournisseurs ; nécessite un backend distinct.<br />
<b>Signaux et contexte CI</b> : métriques, journaux et traces, avec des conventions sémantiques pour la télémétrie CI/CD.<br />
<b>Configuration</b> : instrumentation ou intégrations CI, exportateurs OTLP et, généralement, un collecteur OpenTelemetry.<br />
<br />
OpenTelemetry est utilisé par 17 % des personnes interrogées. Il ne s’agit pas d’un outil d’observabilité complet doté de son propre stockage et de ses propres tableaux de bord. Il fournit plutôt un moyen standard de collecter les données de pipeline et de les envoyer vers un autre système d’observabilité.<br />
<br />
Par exemple, OpenTelemetry peut enregistrer un pipeline sous la forme d’une séquence connectée de tâches, d’étapes, de tests, de transferts d’artefacts et d’appels vers des services externes. Ces données peuvent ensuite être stockées et analysées à l’aide d’une plateforme open source ou commerciale.<br />
<br />
- <b>Idéal pour</b> : les pipelines complexes couvrant plusieurs outils ou services, en particulier lorsque la portabilité est importante.<br />
- <b>Points forts</b> : traçage intersystèmes et collecte indépendante des fournisseurs de métriques, de journaux et de traces.<br />
- <b>Limite</b> : OpenTelemetry ne fournit ni stockage, ni tableaux de bord, ni expérience d’investigation complète. L’instrumentation peut nécessiter un travail important.<br />
<br />
Les conventions sémantiques d’OpenTelemetry pour le CI/CD couvrent les spans, les métriques et les journaux. L’OpenTelemetry Collector peut traiter et acheminer ces signaux vers un ou plusieurs backends.<br />
<br />
Lors de l’évaluation de cette approche, vérifiez quelles parties du pipeline sont instrumentées automatiquement. Une trace ne contenant que des noms de pipeline et de tâches n’apporte guère plus que l’interface CI/CD native. Sa valeur augmente lorsqu’elle relie l’activité du pipeline à des processus, des agents, des appels réseau ou des systèmes de déploiement.<br />
<br />
<b><font size="3">Plateformes d’observabilité commerciales</font></b><br />
<br />
<b>Modèle</b> : principalement du SaaS géré, avec des options de collecte de données et d’hébergement variant selon les fournisseurs.<br />
<b>Signaux et contexte CI</b> : métriques, journaux, traces, événements, tests et données de pipeline, selon l’intégration.<br />
<b>Configuration</b> : intégrations natives, agents, plugins, API ou collecteurs OpenTelemetry.<br />
<br />
Les plateformes d’observabilité commerciales ont été choisies par 14 % des personnes interrogées. L’enquête a regroupé Datadog, New Relic et Dynatrace ; ce chiffre ne doit donc pas être interprété comme une donnée d’adoption individuelle pour l’une ou l’autre de ces plateformes.<br />
<br />
- <b>Idéal pour</b> : les organisations utilisant déjà une plateforme d’observabilité commerciale et souhaitant ajouter des données CI/CD au même environnement.<br />
- <b>Points forts</b> : stockage et analyse gérés, corrélation intersystèmes, assistance fournisseur et intégrations prêtes à l’emploi.<br />
- <b>Limites</b> : les coûts d’abonnement, d’ingestion et de conservation peuvent augmenter en cas de journaux détaillés et de données de test volumineuses. Le niveau d’intégration CI/CD, la portabilité et la localisation des données varient selon les fournisseurs.<br />
<br />
L’évaluation doit se concentrer sur l’intégration CI/CD spécifique plutôt que sur la liste générale des fonctionnalités de la plateforme. Vérifiez si les utilisateurs peuvent passer d’une régression de pipeline à l’étape, au test, au journal, à la métrique d’agent et au commit correspondants sans avoir à reconstruire manuellement ce contexte.<br />
<br />
Par exemple, Datadog Pipeline Visibility fournit des données au niveau du pipeline pour les fournisseurs CI pris en charge, tandis que New Relic peut recevoir des informations CI/CD via des intégrations et le suivi des modifications.<br />
<br />
Les utilisateurs de TeamCity peuvent également connecter leurs données de build à Datadog CI Visibility lorsque Datadog fait déjà partie de leur pile d’observabilité.<br />
<br />
<b><font size="3">Observabilité interne personnalisée</font></b><br />
<br />
<b>Modèle</b> : généralement auto-hébergé et développé en interne.<br />
<b>Signaux et contexte CI</b> : définis par l’organisation, allant des événements de pipeline normalisés aux données personnalisées sur les coûts et l’infrastructure.<br />
<b>Configuration</b> : collecteurs personnalisés, API, schémas, stockage, tableaux de bord et contrôles d’accès.<br />
<br />
Douze pour cent des personnes interrogées utilisent une solution sur mesure. Cette approche est plus courante lorsqu’une organisation exploite plusieurs systèmes CI/CD, une infrastructure propriétaire, du matériel inhabituel ou des processus de livraison que les outils génériques ne modélisent pas correctement.<br />
<br />
- <b>Idéal pour</b> : les grandes organisations ou les organisations spécialisées dont les besoins ne peuvent être satisfaits par les intégrations existantes.<br />
- <b>Points forts</b> : contrôle total sur le modèle de données, l’hébergement, le contexte CI et l’analyse spécifique à l’organisation.<br />
- <b>Limite</b> : l’organisation est responsable de l’ensemble du cycle de vie, y compris l’instrumentation, la sécurité, les mises à jour, la documentation et l’expérience utilisateur.<br />
<br />
En général, les équipes n’ont pas besoin de créer un système d’observabilité complet à partir de zéro. Elles peuvent utiliser des outils existants pour collecter et stocker les données du pipeline, puis développer uniquement les rapports et fonctionnalités personnalisés dont leur organisation a besoin.<br />
<br />
<br />
<br />
<b><font size="3">Comment évaluer les options d’observabilité des pipelines</font></b><br />
<br />
La plupart des équipes n’ont pas besoin d’un outil unique pour gérer tous les aspects de l’observabilité des pipelines. Commencez par le tableau de bord intégré à votre plateforme CI/CD. Si vous avez besoin de plus d’informations sur les files d’attente de build, les agents disponibles ou l’état de santé des serveurs, ajoutez un outil de métriques. Si vous devez rechercher des informations détaillées provenant de plusieurs systèmes, rassemblez les journaux pertinents en un seul endroit. Le traçage est particulièrement utile lorsque vous devez suivre ce qui se passe à l’intérieur de pipelines complexes et de services externes.<br />
<br />
Lorsque vous comparez des outils, testez-les à l’aide de problèmes auxquels votre équipe a réellement été confrontée, tels qu’une compilation lente, un test instable ou un agent de compilation surchargé. Vérifiez à quelle vitesse un développeur peut identifier l’exécution du pipeline concernée, comprendre où le problème s’est produit et rassembler suffisamment d’éléments pour l’expliquer.<br />
<br />
Tenez également compte du travail nécessaire à la mise en place et à la maintenance de chaque outil, ainsi que du volume de données qu’il stockera. Estimez le coût en vous basant sur un mois type d’activité des pipelines plutôt que sur un petit projet test. Choisissez un outil qui aide votre équipe à comprendre et à résoudre rapidement les problèmes de pipeline sans ajouter de complexité inutile.<br />
<br />
<b><font size="3">Conclusion</font></b><br />
<br />
Une configuration efficace de l’observabilité des pipelines permet de relier les informations provenant des différentes étapes du processus de livraison. Cela permet aux équipes de voir quel commit a déclenché une compilation, quel agent a exécuté une étape et si un ralentissement était lié à l’infrastructure disponible.<br />
<br />
Commencez par les questions auxquelles votre configuration actuelle ne peut pas répondre. Utilisez le cadre présenté dans cet article pour identifier les fonctionnalités manquantes, puis testez les outils potentiels à l’aide de problèmes réels de pipeline et de volumes de données typiques. Une configuration adaptée devrait aider votre équipe à comprendre ce qui s’est passé et à en trouver la cause plus rapidement.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7148" target="_blank">Apprenez-en plus sur TeamCity</a><br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7149" target="_blank">Essayez TeamCity gratuitement</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679565d1793008173/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679566d1793008182/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679567d1793008190/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679568d1793008202/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679569d1793008229/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/5.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679570d1793008235/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/6.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679571d1793008241/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/7.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679572d1793008248/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/8.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>JetBrains</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186303/environnements-developpement/autres-edi/jetbrains/outils-d-observabilite-pipelines-cd-choisir-bonne-configuration/</guid>
		</item>
		<item>
			<title>Assurance qualité logicielle : outils et conseils pour les développeurs</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186260&amp;goto=newpost</link>
			<pubDate>Tue, 20 Oct 2026 15:11:51 GMT</pubDate>
			<description>*Assurance qualité logicielle...</description>
			<content:encoded><![CDATA[<div><b><font size="4">Assurance qualité logicielle : outils et conseils pour les développeurs pour intégrer la qualité à l'ensemble du cycle de développement logiciel</font></b><br />
<br />
Qodana est un outil d'analyse de la qualité du code qui utilise l'analyse statique pour aider les utilisateurs à réaliser des revues de code, à mettre en place des contrôles de qualité et à appliquer les directives relatives à la qualité du code. Lancé officiellement en juillet 2023, il est compatible avec les EDI de l'écosystème JetBrains, s'intègre aux pipelines CI/CD et prend en charge l'analyse de code dans plus de 60 langages de programmation.<br />
<br />
Tester les applications avant leur mise en production ne suffit plus à garantir la qualité des logiciels dans le contexte actuel du développement. Il faut une approche plus dynamique, qui fasse de l’assurance qualité une composante à part entière du processus continu. Selon l’enquête 2025 menée auprès des développeurs par Stack Overflow, 84 % d’entre eux utilisent ou prévoient d’utiliser des outils d’IA dans leurs processus de développement. Cette utilisation croissante de code généré par IA requiert des vérifications de qualité plus rigoureuses et plus fréquentes.<br />
<br />
L’émergence de techniques telles que l’analyse shift-left fait également évoluer les pratiques de développement logiciel moderne en permettant d’effectuer les contrôles qualité plus tôt dans le cycle de développement logiciel (SDLC). Aujourd’hui, l’assurance qualité des logiciels implique d’intégrer des vérifications à chaque étape afin de garantir la fiabilité et des standards élevés.  Plusieurs outils d’automatisation et d’assurance qualité pour les logiciels rendent cela possible. Mais ils ne peuvent pas y arriver seuls. Vous devez également comprendre quelles sont les techniques efficaces et les mettre en œuvre pour identifier les problèmes plus tôt et réduire les risques et les coûts associés.<br />
<br />
Dans cet article, nous explorons l’importance de l’assurance qualité des logiciels, les outils à utiliser à chaque étape du développement et les bonnes pratiques pour intégrer la qualité à l’ensemble du cycle de développement logiciel.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679457d1792574798/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 4768
Taille : 46,7 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Qu’est-ce que l’assurance qualité logicielle ?</font></b><br />
<br />
L’assurance qualité logicielle (SQA) est un processus de vérifications en continu qui garantit le respect des exigences et normes opérationnelles tout au long du cycle de développement logiciel. Elles sont essentielles pour s’assurer que le produit final fonctionne, qu’il soit sécurisé et qu’il respecte les normes de l’entreprise et du secteur.<br />
<br />
L’assurance qualité logicielle (SQA) vise à détecter, corriger et prévenir les défauts le plus tôt possible, pour éviter qu’ils ne passent inaperçus et n’atteignent la production. L’assurance qualité logicielle moderne adopte une approche proactive pour vérifier que l’ensemble des exigences fonctionnelles, de performance et de fiabilité sont respectées. Elle se distingue du contrôle qualité traditionnel, qui est davantage axé sur le produit et plus réactif, et qui se limite souvent à tester le logiciel avant sa mise en production. <br />
<br />
En détectant et en éliminant les bugs plus tôt, l’assurance qualité logicielle permet d’accélérer les mises en production, de renforcer la sécurité et de réduire la dette technique. <br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679458d1792574805/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 204
Taille : 41,4 Ko"  style="float: CONFIG" /></div><br />
<b>L’automatisation et l’IA dans le domaine de l’assurance qualité logicielle</b><br />
<br />
L’automatisation et le recours à l’IA dans le domaine de l’assurance qualité logicielle se généralisent afin d’accélérer les processus et de libérer des ressources pour d’autres priorités. Toutefois, l’automatisation complète (en particulier lorsqu’elle repose sur l’IA) comporte des risques liés à l’utilisation de données d’entraînement et à la possibilité que des erreurs passent inaperçues. Un équilibre entre révisions de code automatisées et manuelles pour valider les résultats reste essentiel pour garantir une assurance qualité efficace.<br />
<br />
<b><font size="3">Pourquoi les outils d’assurance qualité logicielle sont si importants</font></b><br />
<br />
L’assurance qualité manuelle a toujours sa place. Mais à elle seule, elle ne suffit plus à suivre le rythme actuel du développement logiciel. Dans les cycles de développement logiciel actuels, les délais de livraison sont passés de plusieurs mois à quelques jours, et avec les pipelines de CI/CD modernes, le code passe souvent de la validation d’un commit à la mise en production avec une intervention humaine minimale. <br />
<br />
Les outils d’assurance qualité logicielle modernes sont conçus pour suivre le rythme plus rapide de ces cycles de développement. À mesure que les bases de code se complexifient, avec des dépendances multiples, des microservices et des intégrations tierces, les outils d’assurance qualité logicielle (SQA) permettent de détecter des défauts cachés qui pourraient facilement échapper à l’œil humain lors des revues de code.<br />
<br />
S’ils ne sont pas détectés, ces problèmes potentiels peuvent entraîner des erreurs et des coûts financiers considérables. Selon le Consortium for Information &amp; Software Quality (CISQ), la mauvaise qualité des logiciels coûte au moins 2,41 billions de dollars par an aux États-Unis. La philosophie du shift-left, qui consiste à détecter les problèmes dès l’écriture du code, répond à cet enjeu.<br />
<br />
<b>L’assurance qualité logicielle face aux défis du développement moderne</b><br />
<br />
Divers outils d’assurance qualité logicielle répondent directement à plusieurs des enjeux actuels du développement, notamment :<br />
<br />
- Les analyseurs statiques, qui détectent les bugs et les failles de sécurité avant la fusion du code.<br />
- Les frameworks de tests automatisés, qui vérifient le comportement en continu.<br />
- Les outils de performance et de couverture, qui détectent les régressions au plus tôt.<br />
<br />
Aucun outil ne couvre à lui seul tous les aspects de l’assurance qualité tout au long du cycle de développement logiciel. Il est donc essentiel de combiner plusieurs outils complémentaires pour répondre aux différents enjeux de qualité et garantir un processus d’assurance qualité logicielle aussi rigoureux que possible. <br />
<br />
<b><font size="3">Les différentes étapes de l’assurance qualité logicielle</font></b><br />
<br />
L’assurance qualité continue est intégrée à chaque étape du processus de développement, avec des contrôles qualité effectués tout au long du cycle, et non uniquement lors de la phase de test finale. Les approches traditionnelles considèrent l’assurance qualité comme une étape de validation avant la mise en production. Les défauts sont donc souvent découverts après que de nombreux développements ont été réalisés sur la base d’un code défectueux, entraînant des retards coûteux dans la livraison du logiciel. <br />
<br />
Trouver et corriger un bug juste avant la mise en production s’avère bien plus coûteux et perturbateur que de le détecter tôt. Répartir les contrôles qualité tout au long du cycle de vie du développement logiciel (SDLC) permet aux développeurs de détecter les problèmes au plus près de leur origine, de refactoriser le code plus rapidement et d’éviter l’accumulation de défauts susceptibles de retarder la livraison et de réduire la satisfaction des clients. <br />
<br />
Certains outils conviennent à des étapes spécifiques de l’assurance qualité logicielle, les objectifs et les exigences de chaque étape étant différents.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679459d1792574811/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 197
Taille : 191,2 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Outils essentiels pour l’assurance qualité logicielle</font></b><br />
<br />
L’utilisation d’outils d’assurance qualité implique de choisir les outils les mieux adaptés à chaque processus de test. C’est important, car l’analyse statique, les tests de performance, les scans de sécurité et les tests fonctionnels permettent de détecter des problèmes différents.<br />
<br />
Passons en revue quelques outils d’assurance qualité logicielle essentiels, à utiliser pour chaque processus.<br />
<br />
<b>1. Analyse statique du code</b><br />
<br />
L’analyse statique du code examine le code source sans l’exécuter. Elle analyse le code en cours de développement afin de détecter les bugs, les failles de sécurité et les violations des normes de codage. Elle opère directement sur le code et signale les problèmes dès le stade de l’écriture, souvent dans l’IDE. Cette approche permet de détecter les problèmes plus tôt dans le cycle de développement et de gagner du temps, plutôt que d’attendre qu’une exécution des tests ou une revue de code les mette en évidence.<br />
<br />
Cela évite ainsi aux développeurs de découvrir un risque de pointeur nul ou une vulnérabilité à l’injection SQL lors des tests d’intégration ou en production. Les corrections sont plus simples et moins coûteuses lorsque le contexte est encore en mémoire. L’analyse statique permet également de garantir la cohérence au sein d’une base de code et d’une équipe. Les violations des règles de style, les variables inutilisées et les fonctions trop complexes sont détectées, même lorsqu’elles échappent à une revue de code manuelle.  <br />
<br />
Qodana est un outil d’analyse statique du code et d’assurance qualité qui vient compléter, plutôt que remplacer, les autres types de tests. Il permet d’éliminer de nombreux défauts évitables dès la phase de développement et de maintenir un niveau de qualité élevé tout au long du cycle de développement logiciel (SDLC).<br />
<br />
<b>2. Tests unitaires</b><br />
<br />
Les tests unitaires restent un pilier de l’assurance qualité logicielle, même avec le recours croissant à l’IA et à l’automatisation. Ils renforcent la stabilité du logiciel et aident à produire du code facile à maintenir grâce à une détection précoce des erreurs, en testant chaque composant et chaque fonction de façon isolée pour vérifier que chaque unité fonctionne comme prévu.<br />
<br />
Voici quelques exemples courants d’outils de tests unitaires pour l’assurance qualité :<br />
<br />
- JUnit est le standard par défaut pour les tests unitaires en Java.<br />
- Jest offre d’excellentes performances pour le développement JavaScript et TypeScript.<br />
- PyTest est un framework de tests en Python.<br />
- NUnit est un framework fiable et flexible pour les équipes C# et .NET.<br />
<br />
<b>3. Tests d’intégration</b><br />
<br />
Les outils de tests d’intégration valident la façon dont les différents composants, services et API interagissent. Cela permet de détecter les erreurs dans les flux de données et les communications qui affectent le fonctionnement du logiciel, afin de les corriger et de garantir sa qualité.<br />
<br />
La validation de l’intégration revêt une importance particulière dans les architectures distribuées et les microservices. Les interactions entre les composants sont souvent sources de problèmes. Vérifier qu’elles fonctionnent comme prévu permet donc de garantir un niveau de qualité élevé.<br />
<br />
Parmi les outils de test d’intégration figure Postman, spécialisé dans les tests d’intégration d’API et permettant de créer et d’exécuter des tests d’API. SoapUI propose également une prise en charge complète de SOAP et REST, ce qui en fait un outil idéal pour les services web d’entreprise et les intégrations complexes entre services.<br />
<br />
<b>4. Tests fonctionnels et d’interface utilisateur</b><br />
<br />
Les outils de tests fonctionnels et de bout en bout simulent les interactions réelles des utilisateurs, comme cliquer sur des boutons, remplir des formulaires et naviguer entre les pages. Ils vérifient le comportement d’une application du point de vue de l’utilisateur et sur l’ensemble des workflows. Cela va au-delà du code lui-même, pour détecter les problèmes qui n’apparaissent que lorsque les composants interagissent dans un environnement réel.<br />
<br />
Les tests de navigateur automatisés sont un élément central des tests fonctionnels et d’interface utilisateur. C’est particulièrement important pour les tests de régression, dans lesquels les équipes doivent s’assurer que les nouvelles modifications n’altèrent pas les fonctionnalités existantes.<br />
<br />
Des outils comme Playwright, Cypress et Selenium permettent aux équipes de scripter les parcours utilisateurs une fois et de les exécuter de manière répétée sur différents navigateurs et à chaque nouvelle version du logiciel. Ils transforment ainsi des vérifications manuelles fastidieuses en tests d’assurance qualité rapides, reproductibles et fiables.<br />
<br />
<b>5. Tests de performances</b><br />
<br />
Validez le comportement d’une application face à des niveaux de trafic attendus ou inattendus grâce aux outils de test des performances. Ils révèlent les problèmes de qualité, notamment les goulots d’étranglement, les fuites de mémoire et les requêtes lentes sous forte charge, afin de corriger les bugs avant qu’ils n’affectent les utilisateurs finaux.<br />
<br />
Cela permet de s’assurer que le logiciel peut faire face à des situations de forte sollicitation, au-delà de la simple vérification du bon fonctionnement des fonctionnalités. Ces outils mesurent les temps de réponse face à l’augmentation de la charge, la capacité du système à se remettre des pics de trafic, ainsi que les points où les limites de l’infrastructure se font sentir.<br />
<br />
Des outils comme JMeter, LoadRunner et k6 testent les performances en simulant des schémas de trafic réalistes, allant d’une charge de base stable à des pics soudains. JMeter convient aux plans de tests complexes et impliquant plusieurs protocoles, tandis que k6 propose une approche scriptable, pensée pour les développeurs, qui cible l’intégration dans les pipelines de CI/CD et la validation continue des performances.<br />
<br />
<b>6. Tests de sécurité</b><br />
<br />
La sécurité est un élément essentiel de l’assurance qualité logicielle, compte tenu du coût élevé des vulnérabilités découvertes tardivement dans le cycle de développement.<br />
<br />
Plusieurs types d’outils de tests de sécurité peuvent être combinés pour couvrir différents aspects :<br />
<br />
- L’analyse statique de sécurité des applications (SAST) analyse le code source pour y détecter les schémas de vulnérabilité connus.<br />
- L’analyse de la composition logicielle (SCA) et l’analyse des dépendances vérifient si les bibliothèques tierces présentent des vulnérabilités et expositions courantes (CVE).<br />
- Les tests dynamiques de sécurité des applications (DAST) recherchent les failles de sécurité exploitables dans les applications en cours d’exécution.<br />
- La détection des secrets permet de repérer les identifiants d’accès ou les clés API accidentellement ajoutés au dépôt de code.<br />
<br />
Des outils de tests de sécurité comme Qodana intègrent directement ces vérifications dans le workflow de développement. Cela met en évidence les vulnérabilités ainsi que les problèmes de qualité du code au cours du développement, plutôt que lors d’une vérification de sécurité distincte plus en aval. Cela renforce l’approche shift-left dans l’ensemble du domaine des tests de sécurité.<br />
<br />
<b><font size="3">Comment choisir les bons outils d’assurance qualité logicielle</font></b><br />
<br />
Le choix des outils d’assurance qualité les plus adaptés dépend de votre processus de développement et des exigences propres à votre activité. Les stratégies les plus efficaces combinent plusieurs outils de test d’assurance qualité pour une couverture complète, plutôt que de s’appuyer sur un seul outil.<br />
<br />
Voici les principaux facteurs à prendre en compte pour comparer et sélectionner vos outils d’assurance qualité logicielle :<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679460d1792574821/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 196
Taille : 49,9 Ko"  style="float: CONFIG" /></div><br />
- <b>Intégration au pipeline de CI/CD</b> : un bon outil d’assurance qualité doit s’intégrer directement à votre pipeline de CI/CD. Cela permet de lancer des vérifications automatiques à chaque commit ou build, sans déclenchement manuel.<br />
<br />
- <b>Prise en charge des langages</b> : votre outil d’assurance qualité doit prendre entièrement en charge les langages de programmation et les frameworks de votre base de code, afin d’éviter une analyse incomplète ou imprécise.<br />
<br />
- <b>Automatisation</b> : choisissez des outils qui automatisent les tâches de tests répétitives, réduisent l’effort manuel et permettent des retours plus rapides et plus cohérents tout au long du développement.<br />
Évolutivité : vos outils doivent accompagner la croissance des bases de code, du volume de tests et des équipes, sans nuire aux performances ni à la facilité d’utilisation.<br />
<br />
- <b>Rapports</b> : un outil d’assurance qualité doit fournir des rapports clairs et exploitables pour aider les développeurs à comprendre les problèmes et à prioriser les correctifs.<br />
<br />
- <b>Sécurité</b> : l’outil lui-même doit respecter des pratiques de sécurité rigoureuses et être capable d’identifier les vulnérabilités présentes dans votre code ou vos dépendances.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7143" target="_blank">Apprenez-en plus sur Qodana</a><br />
<br />
<b><font size="3">Bonnes pratiques pour intégrer la qualité dans votre workflow de développement</font></b><br />
<br />
S’il est essentiel de choisir des outils efficaces, il est également nécessaire de les mettre en œuvre correctement pour garantir la qualité à chaque étape. Quels que soient les outils que vous utilisez, appliquez ces techniques pour intégrer une assurance qualité fiable à votre workflow de développement :<br />
<br />
- <b>Approche shift-left</b> : effectuez les contrôles qualité au début du développement, de préférence au moment de l’écriture du code. Cela permet de détecter les défauts au moment où ils sont les plus simples et les moins coûteux à corriger. Le contexte est encore présent à l’esprit, ce qui évite des corrections coûteuses après la mise en production, susceptibles de nuire à la réputation de l’entreprise.<br />
<br />
- <b>Automatisation des contrôles qualité répétitifs.</b> Les vérifications manuelles de routine entraînent souvent des erreurs humaines et sont difficiles à effectuer à grande échelle. L’automatisation de ces tests libère du temps et des ressources. Votre équipe peut ainsi se concentrer sur des tests complexes et exploratoires qui nécessitent un jugement humain et en bénéficient.<br />
<br />
- <b>Intégration des tests dans les pipelines de CI/CD.</b> Exécutez automatiquement les contrôles qualité à chaque commit ou build, plutôt que comme une étape manuelle distincte. Préservez la rapidité de la boucle de rétroaction et évitez que les problèmes ne s’accumulent sans être détectés.<br />
<br />
- <b>Surveillance la dette technique.</b> Effectuez un suivi de la complexité du code, de la duplication et de la couverture des tests au fil des versions. Cela permet de détecter et de corriger rapidement les régressions de qualité.<br />
<br />
- <b>Traitement de la sécurité comme une partie intégrante du développement.</b> Intégrez l’analyse de la sécurité et la détection des vulnérabilités dans votre processus d’assurance qualité habituel, plutôt que de les traiter comme une préoccupation secondaire. Traitez les vulnérabilités dès qu’elles apparaissent, sans attendre l’audit préalable à la mise en production.<br />
<br />
<b><font size="3">Construire une stratégie d’assurance qualité logicielle complète avec Qodana</font></b><br />
<br />
L’assurance qualité logicielle couvre l’ensemble du cycle de vie du développement logiciel. Ce n’est pas qu’une simple action de test final. Combiner plusieurs outils pour répondre aux besoins de qualité propres à chaque étape est une exigence incontournable à l’heure où rapidité, complexité et intégration continue sont devenues des enjeux majeurs.<br />
<br />
L’automatisation de l’analyse statique du code dans les pipelines de développement à l’aide d’outils tels que Qodana renforce l’assurance qualité. Détecter les bugs et les vulnérabilités dès l’écriture du code permet de garantir un développement de haute qualité et des performances fiables.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7144" target="_blank">Essayez Qodana gratuitement</a><br />
<br />
<b>Qu’est-ce que l’assurance qualité logicielle ?</b><br />
<br />
L’assurance qualité logicielle (SQA) est le processus continu visant à garantir que le logiciel répond à des normes définies en matière de qualité, de fiabilité, de sécurité et de fonctionnement tout au long du cycle de développement logiciel. Contrairement au contrôle qualité traditionnel, qui tend à se concentrer sur la détection des problèmes dans le produit fini, l’assurance qualité logicielle vise à empêcher et à détecter les défauts tout au long du développement.<br />
<br />
<b>Que sont les outils d’assurance qualité logicielle ?</b><br />
<br />
Les outils d’assurance qualité logicielle aident les équipes de développement à automatiser et à gérer les activités qui améliorent la qualité des logiciels tout au long du cycle de développement logiciel. Ils comprennent les outils d’analyse statique de code, les frameworks de tests unitaires et d’intégration, les outils de tests fonctionnels, les outils de tests de performance, les scanners de sécurité et les contrôles qualité du pipeline de CI/CD.<br />
<br />
<b>Quels sont les principaux types d’outils d’assurance qualité logicielle ?</b><br />
<br />
Parmi les outils couramment utilisés pour l’assurance qualité logicielle, on trouve :<br />
<br />
- Outils d’analyse statique du code<br />
- Frameworks de tests unitaires<br />
- Outils de tests d’intégration<br />
- Outils de tests fonctionnels et d’interface utilisateur<br />
- Outils de tests de performance<br />
- Outils de tests de sécurité, notamment SAST, SCA, DAST et détection des secrets<br />
<br />
Chacun couvre un aspect différent de la qualité logicielle, c’est pourquoi les organisations combinent généralement plusieurs outils plutôt que de compter sur une seule solution<br />
<br />
<b>Comment l’intégration continue et le déploiement continu (CI/CD) améliorent-ils l’assurance qualité logicielle ?</b><br />
<br />
L’intégration d’outils d’assurance qualité dans les pipelines de CI/CD permet d’exécuter automatiquement les contrôles de qualité et de sécurité à chaque modification du code. Cela permet aux développeurs d’obtenir un retour plus rapide, d’éviter l’accumulation de problèmes et d’intégrer l’assurance qualité en continu au processus de développement, plutôt que d’en faire une étape distincte avant la mise en production.<br />
<br />
<b>Quel est l’impact du code généré par IA sur l’assurance qualité logicielle ?</b><br />
<br />
L’IA peut accroître le volume de code produit par les développeurs, ce qui rend les contrôles qualité automatisés et capables de passer à l’échelle toujours plus indispensables. Elle peut également contribuer aux activités d’assurance qualité, mais les résultats qu’elle génère doivent toujours être validés de manière appropriée. Associer l’analyse et les tests automatisés à la revue humaine permet aux équipes de maintenir un niveau de qualité élevé à mesure que l’IA prend une place croissante dans le développement logiciel.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7143" target="_blank">Apprenez-en plus sur Qodana</a><br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7144" target="_blank">Essayez Qodana gratuitement</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679457d1792574798/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679460d1792574821/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679458d1792574805/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679459d1792574811/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/3.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>JetBrains</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186260/environnements-developpement/autres-edi/jetbrains/assurance-qualite-logicielle-outils-conseils-developpeurs/</guid>
		</item>
		<item>
			<title>Optimisez votre pipeline : les 6 meilleures intégrations CI/CD pour Qodana</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2186255&amp;goto=newpost</link>
			<pubDate>Tue, 20 Oct 2026 13:17:14 GMT</pubDate>
			<description>*Optimisez votre pipeline :...</description>
			<content:encoded><![CDATA[<div><b><font size="4">Optimisez votre pipeline : les 6 meilleures intégrations de développement logiciel continu CI/CD pour Qodana, l'outil d'analyse de la qualité du code de JetBrains</font></b><br />
<br />
Qodana est un outil d'analyse de la qualité du code qui utilise l'analyse statique pour aider les utilisateurs à réaliser des revues de code, à mettre en place des contrôles de qualité et à appliquer les directives relatives à la qualité du code. Lancé officiellement en juillet 2023, il est compatible avec les EDI de l'écosystème JetBrains, s'intègre aux pipelines CI/CD et prend en charge l'analyse de code dans plus de 60 langages de programmation. En génie logiciel, le terme « CI/CD » ou « CICD » désigne l'ensemble des pratiques d'intégration continue (CI) et de livraison continue (CD) ou, plus rarement, de déploiement continu. Ces pratiques sont parfois désignées collectivement sous les termes de « développement continu » ou de « développement logiciel continu ».<br />
<br />
Votre pipeline CI/CD s’exécute rapidement, mais le fait-il correctement ? Alors que vos builds et déploiements automatisés gèrent les aspects techniques de la livraison logicielle, la détection des problèmes de qualité du code repose souvent sur des revues manuelles qui, bien que très utiles, peuvent parfois passer à côté de problèmes plus subtils. C’est là que Qodana change la donne en intégrant directement la puissance du moteur d’inspection d’IntelliJ IDEA à votre workflow grâce à des intégrations CI/CD.<br />
<br />
Qodana s’intègre de manière transparente à plusieurs grandes plateformes CI/CD, étendant ainsi l’analyse intelligente du code à laquelle vous faites confiance dans votre IDE à chaque commit et pull request. Vous pouvez automatiser des contrôles de qualité qui empêchent le code problématique d’atteindre la production, quelle que soit la plateforme préférée de votre équipe. Cette compatibilité vous permet de respecter les normes de codage sans perturber les workflows existants ni avoir à apprendre de nouveaux outils.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679442d1792504568/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 10104
Taille : 31,3 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Pourquoi intégrer l’analyse statique du code aux pipelines CI/CD ?</font></b><br />
<br />
L’intégration de l’analyse statique du code en CI/CD transforme la manière dont votre équipe aborde la qualité du code. Au lieu de découvrir des problèmes après le déploiement (lorsqu’ils sont coûteux à corriger), vous pouvez les repérer immédiatement dans le cadre de votre flux de travail de développement existant. C’est là l’essence même de l’approche « shift-left », qui consiste à avancer les contrôles de qualité plus tôt dans le cycle de vie, afin que les développeurs obtiennent un retour plus rapide et que les équipes passent moins de temps à retravailler le code.<br />
<br />
L’application automatisée des normes de qualité garantit que chaque membre de l’équipe respecte les mêmes normes de codage, quels que soient son niveau d’expérience ou ses préférences en matière d’outils. Lorsque Qodana s’exécute à chaque commit, vous obtenez un retour cohérent qui contribue à maintenir la qualité du code sur l’ensemble de votre base de code.<br />
<br />
Votre pipeline CI/CD devient alors bien plus qu’un simple outil de déploiement. Il agit comme un garant de la qualité, bloquant le code problématique avant qu’il ne puisse avoir un impact sur vos utilisateurs. <br />
<br />
Mais quelles sont les meilleures intégrations CI/CD pour Qodana ? Nous allons passer en revue quelques-unes des meilleures solutions et discuter de la manière dont vous devriez les intégrer à vos workflows, ainsi que des raisons de le faire.<br />
<br />
<b><font size="3">1. GitHub Actions</font></b><br />
<br />
GitHub Actions propose une automatisation CI/CD basée sur le cloud qui s’intègre directement à vos dépôts GitHub. Il prend en charge tous les principaux langages de programmation et systèmes d’exploitation, et dispose d’une vaste boutique proposant des actions GitHub prêtes à l’emploi.<br />
<br />
Cette plateforme excelle également dans les workflows de pull request et offre des options de runners flexibles pour les dépôts publics comme privés.<br />
<br />
<b>Intégration de Qodana à GitHub Actions</b><br />
<br />
Qodana s’intègre à GitHub Actions via l’Action officielle de la marketplace, ce qui simplifie la configuration grâce à un simple fichier de workflow. L’Action v2025.2 actuelle offre des capacités d’analyse complètes et s’intègre de manière transparente au système de pull requests de GitHub.<br />
<br />
Vous devrez configurer votre QODANA_TOKEN en tant que secret de dépôt et créer un fichier de workflow dans votre répertoire .github/workflows.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679443d1792504573/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 492
Taille : 69,3 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">2. GitLab</font></b><br />
<br />
GitLab propose une plateforme DevOps complète dotée de capacités CI/CD intégrées, disponible aussi bien en cloud qu’en déploiement sur site. Elle prend en charge plus de 60 langages de programmation et offre des fonctionnalités complètes de gestion de projet en plus de ses fonctionnalités CI/CD. La force de GitLab réside dans son approche « tout-en-un » des workflows de développement logiciel.<br />
<br />
<b>Intégration de Qodana à GitLab</b><br />
<br />
L’intégration à GitLab a été révolutionnée grâce au nouveau composant CI/CD natif de GitLab introduit dans la version 2025.1, qui remplace l’ancienne approche reposant exclusivement sur Docker. Cette intégration native du composant élimine la complexité tout en offrant des fonctionnalités améliorées. Le composant s’intègre directement à l’interface utilisateur des demandes de fusion de GitLab, affichant des rapports sur la qualité du code parallèlement à votre processus de révision de code existant.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679444d1792504578/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 461
Taille : 70,0 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">3. TeamCity</font></b><br />
<br />
TeamCity est le serveur de CI de JetBrains destiné aux entreprises, proposant à la fois des options sur site et dans le cloud. Il offre une prise en charge multiplateforme avec des capacités avancées de gestion des builds conçues pour l’évolutivité. En tant que produit JetBrains, il offre des possibilités d’intégration approfondie avec d’autres outils JetBrains et workflows de développement.<br />
<br />
<b>Intégration de Qodana à TeamCity</b><br />
<br />
TeamCity offre l’intégration la plus simplifiée de Qodana grâce à son exécuteur de builds natif, ce qui évite d’avoir recours à des conteneurs Docker ou à des configurations YAML complexes. Cette intégration native propose une configuration via une interface graphique et des fonctionnalités de reporting intégrées. Vos résultats d’analyse s’affichent directement dans l’interface de TeamCity, avec une visualisation complète et un suivi historique.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679445d1792504585/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 444
Taille : 50,3 Ko"  style="float: CONFIG" /><br />
<img src="https://www.developpez.net/forums/attachments/p679446d1792504592/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/5.jpg/" border="0" alt="Nom : 5.jpg
Affichages : 452
Taille : 51,9 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">4. Jenkins</font></b><br />
<br />
Jenkins est le principal serveur d’automatisation open source ; il dispose d’un vaste écosystème de plugins et d’un modèle de déploiement auto-hébergé. Il prend en charge toutes les principales plateformes et offre une flexibilité de personnalisation maximale grâce à ses capacités de script de pipeline. Jenkins excelle dans les environnements d’entreprise complexes où les workflows personnalisés sont essentiels.<br />
<br />
<b>Intégration de Qodana à Jenkins</b><br />
<br />
L’intégration à Jenkins repose sur un déploiement basé sur Docker via la configuration d’un Jenkinsfile, offrant ainsi une grande flexibilité pour répondre à des exigences complexes en matière de pipelines. Elle prend en charge les contrôles de qualité, les comparaisons par rapport à des références et les workflows de reporting personnalisés. Vous configurerez Qodana en tant qu’agent Docker au sein de votre pipeline, ce qui permettra une orchestration sophistiquée des builds.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679447d1792504598/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/6.jpg/" border="0" alt="Nom : 6.jpg
Affichages : 488
Taille : 60,5 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">5. Azure Pipelines</font></b><br />
<br />
Azure Pipelines est le service CI/CD cloud de Microsoft, prenant en charge Windows, Linux et macOS au sein de l’écosystème plus large d’Azure DevOps. Il offre des fonctionnalités de niveau entreprise avec une forte intégration aux services de développement et cloud de Microsoft. La plateforme est particulièrement adaptée aux organisations ayant déjà investi dans les technologies Microsoft. Il s’agit également de l’un des premiers pipelines dans lesquels Qodana a pu s’intégrer – cette intégration a été introduite dès 2022.<br />
<br />
<b>Intégration de Qodana à Azure Pipelines</b><br />
<br />
Azure Pipelines utilise la tâche QodanaScan@2025, enrichie des fonctionnalités de la version 2025.1 qui améliorent considérablement l’expérience des développeurs. L’intégration à Azure Pipelines affiche désormais les résultats dans l’onglet « Extensions » plutôt que d’encombrer les journaux de build. Cela permet d’obtenir des rapports plus clairs et une meilleure visibilité sur les indicateurs de qualité du code.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679448d1792504603/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/7.jpg/" border="0" alt="Nom : 7.jpg
Affichages : 471
Taille : 72,5 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">6. CircleCI</font></b><br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679449d1792504610/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/8.jpg/" border="0" alt="Nom : 8.jpg
Affichages : 459
Taille : 87,7 Ko"  style="float: CONFIG" /></div><br />
CircleCI est une plateforme CI/CD native du cloud dotée d'une architecture axée sur les conteneurs et d'un modèle de tarification par crédits. Elle excelle dans les workflows Docker et offre des performances prévisibles grâce à son infrastructure optimisée pour les conteneurs. La plateforme est particulièrement avantageuse pour les équipes qui privilégient les pratiques de développement conteneurisées.<br />
<br />
<b>Intégration de Qodana à CircleCI</b><br />
<br />
L'intégration à CircleCI offre une exécution optimisée pour les conteneurs avec d'excellentes performances. La configuration consiste à déclarer l'orb dans votre fichier .circleci/config.yml.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p679450d1792504616/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/9.jpg/" border="0" alt="Nom : 9.jpg
Affichages : 459
Taille : 61,8 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Intégrez la qualité du code à votre workflow grâce à l’analyse statique du code en CI/CD</font></b><br />
<br />
Ces intégrations CI/CD garantissent que des contrôles de qualité du code cohérents et automatisés font partie intégrante de votre processus de développement, plutôt que d’être une étape ajoutée après coup. En choisissant l’intégration qui correspond à votre workflow existant, votre équipe peut faire respecter les normes de codage sans nuire à la productivité ni nécessiter de formation approfondie.<br />
<br />
Qodana intègre directement dans votre pipeline la même analyse intelligente qui alimente IntelliJ IDEA, quelle que soit la plateforme privilégiée par votre équipe. Commencez dès aujourd’hui avec votre outil CI/CD préféré et faites de la qualité du code une étape automatisée de chaque commit effectué par votre équipe.<br />
<br />
Commencez un essai gratuit et découvrez comment Qodana peut vous aider à améliorer votre base de code.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7142" target="_blank">Essayez Qodana gratuitement</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p679444d1792504578/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679450d1792504616/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/9.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679449d1792504610/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/8.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679448d1792504603/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/7.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679447d1792504598/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/6.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679446d1792504592/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/5.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679445d1792504585/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679443d1792504573/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p679442d1792504568/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/1.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>JetBrains</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2186255/environnements-developpement/autres-edi/jetbrains/optimisez-pipeline-6-meilleures-integrations-cd-qodana/</guid>
		</item>
		<item>
			<title>Couverture de code : comment la mesurer, comprendre les indicateurs et améliorer vos tests</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2184897&amp;goto=newpost</link>
			<pubDate>Wed, 29 Jul 2026 14:10:03 GMT</pubDate>
			<description>*Couverture de code : comment...</description>
			<content:encoded><![CDATA[<div><b><font size="4">Couverture de code : comment la mesurer, comprendre les indicateurs et améliorer vos tests, avec Qodana, l'outil d'analyse de la qualité du code de JetBrains</font></b><br />
<br />
JetBrains est une société à responsabilité limitée internationale spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux développeurs et aux chefs de projet. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter dans une machine virtuelle Java (JVM).<br />
<br />
Qodana est un outil d'analyse de la qualité du code qui utilise l'analyse statique pour aider les utilisateurs à réaliser des revues de code, à mettre en place des contrôles de qualité et à appliquer les directives relatives à la qualité du code. Lancé officiellement en juillet 2023, il est compatible avec les EDI de l'écosystème JetBrains, s'intègre aux pipelines CI/CD et prend en charge l'analyse de code dans plus de 60 langages de programmation.<br />
<br />
La couverture de code (Code coverage) fait partie de ces indicateurs dont toutes les équipes de développement parlent, mais que peu exploitent pleinement. Que vous lanciez un produit SaaS ou que vous assuriez la maintenance d’une application monolithique héritée, comprendre ce que vos tests couvrent réellement – et ce qu’ils laissent de côté – peut faire la différence entre une mise en production en toute confiance et une alerte d’incident à 2 heures du matin.<br />
<br />
Cet article vous présente les indicateurs de couverture essentiels, vous explique comment les mesurer à l’aide d’outils modernes et vous propose des mesures concrètes pour améliorer la couverture de code sans gaspiller d’efforts sur des tests inutiles. Les rapports de couverture de code sont disponibles avec les licences Qodana Ultimate et Qodana Ultimate Plus. Pour en savoir plus sur les licences Qodana disponibles, consultez la page Options d’abonnement et tarifs. Vous pouvez également demander une démonstration.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677899d1785340378/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/0.jpg/" border="0" alt="Nom : 0.jpg
Affichages : 6050
Taille : 28,2 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">En bref</font></b><br />
<br />
- La couverture de code est un indicateur de test logiciel qui mesure le pourcentage de code source exécuté par vos tests automatisés. Elle a un impact direct sur la qualité du logiciel et la confiance dans le déploiement.<br />
<br />
- Pour mesurer la couverture de code, il faut commencer par choisir les bons indicateurs (couverture par ligne, par branche, par condition et par chemin) et utiliser des outils tels que Qodana, JaCoCo, Istanbul/NYC, Coverage.py ou Jest pour générer des rapports de couverture dans votre pipeline d’intégration continue (CI).<br />
<br />
- Viser une couverture de code de 80 % est généralement considéré comme un bon objectif pour la logique métier critique, mais atteindre une couverture de code de 100 % est souvent irréalisable et coûteux.  Une couverture élevée ne garantit jamais un logiciel exempt de bogues.<br />
<br />
- Pour améliorer la couverture de code, utilisez les rapports de couverture afin d’identifier les parties du code non testées, de hiérarchiser les modules à risque et d’intégrer des vérifications de couverture dans votre workflow CI/CD.<br />
<br />
- Pour mieux comprendre comment la couverture s’intègre aux vérifications structurelles et stylistiques, consultez notre guide dédié à l’analyse statique du code.<br />
<br />
<b><font size="3">Qu’est-ce que la couverture de code ?</font></b><br />
<br />
La couverture de code mesure le pourcentage de code exécuté lors des tests. Si votre base de code comporte 1 000 lignes de code exécutables et que votre suite de tests en exécute 900, vous obtenez une couverture de 90 %. Elle est généralement exprimée en pourcentage et sert de métrique d’exécution — ce qui signifie qu’elle suit ce qui s’exécute réellement, et non ce qui pourrait poser problème sur la seule base de la structure.<br />
<br />
Cela la distingue de l’analyse statique du code, qui inspecte le code source sans exécution pour signaler la complexité, les problèmes de style ou les indices de vulnérabilité. Les deux sont complémentaires : l’analyse statique vous indique où des problèmes pourraient se cacher, et la couverture de code vous indique si vos tests atteignent réellement ces zones.<br />
<br />
Il convient de clarifier la différence entre la couverture de code et ce que l’on appelle parfois la couverture de test :<br />
<br />
- <b>La couverture de code</b> se concentre sur la quantité de code source exécutée lors de l’exécution d’une suite de tests : lignes, branches, conditions.<br />
<br />
- <b>La couverture de test</b> est plus large. Elle cherche à savoir si les exigences métier et les comportements des utilisateurs ont été validés, même si toutes les lignes pertinentes ont été exécutées.<br />
<br />
Par exemple, une suite de tests peut exécuter 95 % des lignes d’un module de paiement, ce qui donne une couverture de ligne élevée. Mais si aucun test ne vérifie qu’un paiement échoue correctement en cas de solde négatif, les mesures de couverture de test pour ce comportement sont incomplètes.<br />
<br />
La couverture de code identifie le code non testé, ce qui permet aux développeurs d’améliorer leurs efforts de test, en particulier dans les parties critiques telles que l’authentification, les couches d’accès aux données et la gestion des erreurs. Mesurer la couverture de code aide à découvrir des chemins non testés et des cas limites qui pourraient masquer des régressions ou des problèmes de sécurité.<br />
<br />
Voici un exemple rapide en JavaScript :<br />
<br />
<div class="bbcode_container">
	<div class="bbcode_description">Code:</div>
	<hr /><code class="bbcode_code"><table cellspacing="0" cellpadding="0"><tr><td valign="top" width="33"><div style="border: 1px dashed gray; padding-left: 5px; padding-right: 5px; margin-right: 5px; text-align: right; font-family: monospace">1<br />2<br />3<br />4<br />5<br />6<br />7<br />8<br />9<br />10<br />11<br /></div></td><td valign="top"><pre style="margin: 0">function foo(a, b) {

let c = 42

if (a &gt; 0 &amp;&amp; b &gt; 0)

c = c + a * b

return c

}</pre></td></tr></table></code><hr />
</div><br />
<br />
Si votre seul test appelle foo(1, 1), toutes les lignes s'exécutent, mais la branche « else » n'est jamais testée. La couverture de ligne semble complète ; la couverture de branche révèle cette lacune.<br />
<br />
<b><font size="3">Indicateurs et critères de couverture du code de base</font></b><br />
<br />
Les critères de couverture sont des règles formelles permettant de déterminer le degré d’exhaustivité de l’exécution de votre code lors des tests. Plutôt que de chercher à atteindre tous les indicateurs simultanément, les équipes obtiennent de meilleurs résultats en sélectionnant un petit ensemble d’indicateurs de couverture principaux et en concentrant leurs efforts sur ceux-ci. Voici les types de couverture courants que vous rencontrerez.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677900d1785340384/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 810
Taille : 113,4 Ko"  style="float: CONFIG" /></div><br />
La couverture de ligne et la couverture d’instruction sont souvent présentées sous la forme d’un pourcentage unique par la plupart des outils, ce qui en fait les indicateurs de référence les plus simples. Cependant, une couverture de ligne élevée ne signifie pas nécessairement que les autres indicateurs affichent des scores élevés. Par exemple, si nous avions 5 fonctions, dont 4 comportent 1 ligne et la dernière 100 lignes dans son corps, et que les tests ne couvraient que cette dernière, la couverture du code serait de près de 100 %, mais la couverture des fonctions ne serait que de 20 %.<br />
<br />
La couverture des conditions va plus loin. Pour une expression composée telle que <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">if (a &amp;&amp; b || c)</span>, la couverture des conditions exige que chaque sous-expression booléenne <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">(a, b, c)</span> soit évaluée à la fois comme vraie et comme fausse dans l’ensemble de vos cas de test. Cela peut révéler des tests manquants que la couverture des branches seule pourrait masquer.<br />
<br />
La couverture complète des chemins est pratiquement impossible pour les applications non triviales en raison de l’explosion combinatoire : les boucles et les branches imbriquées multiplient les chemins de code de manière exponentielle. Elle ne reste utile que pour des algorithmes particulièrement critiques.<br />
<br />
Dans les domaines où la sécurité est critique, des critères plus avancés tels que la couverture conditionnelle/décisionnelle modifiée (MC/DC) sont obligatoires. La norme DO-178C, par exemple, exige la couverture conditionnelle/décisionnelle modifiée (MC/DC) pour les logiciels avioniques de niveau A, démontrant ainsi que chaque condition influence indépendamment le résultat de chaque décision.<br />
<br />
<b><font size="3">Comment mesurer la couverture de code dans la pratique</font></b><br />
<br />
Voici comment mesurer la couverture de code en quatre étapes :<br />
<br />
<b>1. Instrumentez votre code</b> – Instrumentez votre code en introduisant des hooks qui permettent aux outils de couverture d’observer l’exécution. Cela peut se faire par instrumentation du code source, du bytecode ou en temps d’exécution.<br />
<br />
<b>2. Exécutez vos tests automatisés</b> – tests unitaires, tests d’intégration ou tests de couverture de bout en bout.<br />
<br />
<b>3. Collectez les données de couverture</b> – enregistrez les lignes, les branchements et les conditions qui ont été exécutés.<br />
<br />
<b>4. Générez des rapports de couverture</b> – tableaux de bord HTML, résumés en terminal ou formats lisibles par machine (Cobertura XML, LCOV).<br />
<br />
<b>Exécution de la couverture en pratique</b><br />
<br />
Qodana prend en charge les rapports de couverture générés par toute une gamme d’outils courants, notamment :<br />
<br />
- JaCoCo (Java/Kotlin)<br />
- Jest et Istanbul/nyc (JavaScript/TypeScript)<br />
- pytest-cov (Python)<br />
- Coverlet (.NET)<br />
- PHPUnit (PHP)<br />
- go test (Go)<br />
<br />
Consultez la documentation de Qodana pour obtenir des instructions de configuration spécifiques à chaque langage.<br />
<br />
<b>Métriques de couverture</b><br />
<br />
La couverture est généralement exprimée en pourcentage des éléments de code exécutés lors des tests :<br />
<br />
- <b>Couverture en lignes</b> = nombre de lignes exécutables exécutées ÷ nombre total de lignes exécutables.<br />
- <b>Couverture des branches</b> = nombre de branches exécutées ÷ nombre total de branches.<br />
<br />
Différentes métriques offrent différents niveaux de confiance. La couverture de ligne indique quel code a été exécuté, tandis que la couverture de branche révèle si chaque chemin de décision a été testé.<br />
<br />
La mesure de la couverture de code implique l’utilisation d’outils qui analysent les parties exécutées du code source, puis affichent ces résultats là où les développeurs peuvent en tirer parti : dans les commentaires des pull requests, les plugins d’EDI ou les tableaux de bord d’intégration continue (CI). Les calculs exacts de la couverture peuvent varier légèrement d’un outil à l’autre et d’un langage à l’autre, mais la couverture de ligne et la couverture de branche sont les métriques les plus couramment utilisées.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677901d1785340389/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 779
Taille : 51,1 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Comprendre les pourcentages de couverture et ce qu’est une « bonne » couverture de code</font></b><br />
<br />
Les chiffres de couverture présentés en tête d’affiche peuvent être trompeurs s’ils sont considérés isolément. Un projet présentant une couverture de ligne de 85 % peut tout de même n’avoir qu’une couverture de branche de 55 %, laissant ainsi une logique complexe insuffisamment testée. Les métriques de couverture fournissent des informations sur l’exécution des tests plutôt que sur leur qualité. Un test qui exécute chaque ligne mais ne vérifie rien donne un faux sentiment de sécurité.<br />
<br />
Alors, qu’est-ce qui constitue une bonne couverture ? Voici quelques recommandations pratiques :<br />
<br />
- Google considère qu’une couverture de code de 60 % est acceptable et de 90 % exemplaire pour l’ensemble de ses projets.<br />
- Le consensus parmi les développeurs suggère de viser une couverture de 70 % à 80 % afin de trouver un équilibre entre qualité et évitement de la suringénierie.<br />
- Une étude a révélé une couverture de code moyenne de 74 à 76 % sur 47 projets, ce qui suggère que la plupart des équipes se situent dans une fourchette similaire.<br />
- UJET a maintenu une exigence de couverture de code de 85 % en utilisant un outil permettant d’assurer la visibilité et le suivi des tendances.<br />
<br />
Pour beaucoup, viser une couverture de 80 % constitue une norme saine du secteur pour la logique métier critique. Cependant, une couverture de code de 100 % ne garantit pas un code exempt de bogues : cela signifie simplement que chaque ligne a été testée, et non que chaque comportement a été validé.<br />
<br />
<b>Définissez des seuils en fonction du niveau de risque :</b><br />
<br />
- Modules de transactions financières, flux d’authentification &#8594; 85 à 90 %<br />
- Logique métier générale &#8594; 70 à 80 %<br />
- Code généré ou standard &#8594; à exclure totalement des seuils<br />
<br />
Considérez la couverture comme un indicateur de tendance dans le temps (d’une semaine à l’autre, d’un sprint à l’autre) plutôt que comme un objectif ponctuel. Une couverture élevée met en évidence les risques liés au code hérité ou non testé lorsque les chiffres commencent à baisser. Les tableaux de bord qui visualisent cette tendance aident les équipes à repérer les régressions avant qu’elles ne s’aggravent.<br />
<br />
<b><font size="3">Comment améliorer la couverture de code sans sacrifier la qualité</font></b><br />
<br />
Pour améliorer la couverture de code de manière significative, considérez-la comme un guide pratique et non comme un objectif abstrait. Voici une approche étape par étape qui place la qualité logicielle au premier plan.<br />
<br />
<b>1. Commencez par vos rapports de couverture.</b> Utilisez-les pour identifier les sections de code non testées, en vous concentrant sur les zones à haut risque et à faible couverture de code, telles que les services métier clés, le traitement des paiements et les couches d’accès aux données. N’essayez pas d’augmenter uniformément le pourcentage global de couverture.<br />
<br />
<b>2. Écrivez d’abord des tests unitaires ciblés.</b> Les tests unitaires permettent d’augmenter rapidement la couverture de code, car ils ciblent des fonctions isolées et pures, ainsi que de petits composants. Utilisez des frameworks tels que JUnit 5, pytest ou Jest pour écrire des tests supplémentaires autour des fonctions ayant le plus grand impact métier.<br />
<br />
<b>3. Ciblez les branches et les conditions non couvertes.</b> La couverture par ligne reste la méthode la plus courante pour mesurer la part du code exercée par les tests automatisés. Cependant, vous pouvez aller au-delà. Rédigez des cas de test qui explorent les chemins d’erreur, la logique de réessai, la gestion des délais d’expiration et les cas limites dans une logique complexe. Cela augmentera la couverture du code au niveau des branches et des conditions, là où les bogues se cachent le plus souvent.<br />
<br />
<b>4. Refactorisez le code trop complexe.</b> Les fonctions présentant une complexité cyclomatique très élevée sont difficiles à tester et à couvrir. Les diviser en unités plus petites et testables améliore à la fois les chiffres de couverture et les résultats de l’analyse statique.<br />
<br />
<b>5. Gérez le code difficile à tester.</b> Pour les intégrations tierces, les modules hérités ou le code impliquant de nombreuses opérations d’E/S, utilisez l’injection de dépendances, la simulation (mocking), les doubles de test et les tests de contrat. Ces stratégies permettent d’écrire des tests sans avoir besoin d’environnements externes complets.<br />
<br />
<b>6. Intégrez des contrôles de couverture dans la CI.</b> Intégrez des outils de couverture de code dans votre pipeline de CI et fixez-vous un objectif de 80 %, puis suivez vos progrès. Imposez la règle « aucune régression significative de la couverture par pull request » à l’aide de contrôles d’état de couverture sur GitHub, GitLab ou Azure DevOps.<br />
<br />
<b>7. Fixez des objectifs de couverture réalistes en fonction de la criticité du projet.</b> Tous les fichiers ne méritent pas le même objectif. Définissez des objectifs de couverture par module plutôt que de manière globale.<br />
<br />
<div class="bbcode_container">
	<div class="bbcode_description">Citation:</div>
	<div class="bbcode_quote printable">
		<hr />
		
			Évitez d’écrire des tests superficiels dans le seul but d’augmenter le pourcentage de couverture. Les tests utiles doivent vérifier des comportements significatifs, des cas limites et des conditions d’erreur – et non pas simplement exécuter des lignes de code.
			
		<hr />
	</div>
</div>La couverture de code améliore la fiabilité du code en vérifiant les chemins critiques et la logique, mais uniquement lorsque les tests eux-mêmes sont pertinents. La couverture de code renforce l’assurance qualité en mesurant l’exhaustivité des tests, et non en gonflant les chiffres.<br />
<br />
<b><font size="3">Intégration de la couverture de code aux workflows d’analyse statique et de CI/CD</font></b><br />
<br />
La combinaison d’outils de couverture avec des plateformes d’analyse statique de code vous offre une vision plus complète de la santé du code : des métriques d’exécution en temps réel ainsi que des vérifications structurelles et stylistiques sur plusieurs langages de programmation.<br />
<br />
<b><font size="3">Présentation du rapport&#65279;</font></b><br />
<br />
Une fois le projet préparé et l'analyse de couverture de code exécutée, vous pouvez consulter les rapports de couverture de code dans Qodana Cloud ou via votre EDI.<br />
<br />
<b>Qodana Cloud&#65279;</b><br />
<br />
Les statistiques de couverture de code s'affichent dans le coin supérieur droit de l'interface utilisateur des rapports Qodana. Elles indiquent également la liste des inspections utilisées par la fonctionnalité.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677902d1785340398/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 797
Taille : 62,8 Ko"  style="float: CONFIG" /></div><br />
<b>EDI</b><br />
&#65279;<br />
Vous pouvez consulter les rapports de couverture de code à l'aide des IDE IntelliJ IDEA, WebStorm, PhpStorm, PyCharm et GoLand. Cette fonctionnalité est disponible pour les rapports récupérés depuis Qodana Cloud après mise en relation, ou pour les rapports provenant du stockage local.<br />
<br />
<div class="bbcode_container">
	<div class="bbcode_description">Citation:</div>
	<div class="bbcode_quote printable">
		<hr />
		
			Actuellement, la vue d'ensemble de la couverture de code n'est pas disponible pour les rapports au format XML générés par les rapports de couverture .NET.
			
		<hr />
	</div>
</div><b>Ouvrir des rapports depuis Qodana Cloud&#65279;</b><br />
<br />
1. Dans votre EDI, accédez à Outils | Qodana | Se connecter à Qodana<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677903d1785340404/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 784
Taille : 38,2 Ko"  style="float: CONFIG" /></div><br />
2. Dans la boîte de dialogue « Paramètres », cliquez sur « Se connecter ».<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677904d1785340413/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/5.jpg/" border="0" alt="Nom : 5.jpg
Affichages : 774
Taille : 44,2 Ko"  style="float: CONFIG" /></div><br />
Vous serez alors redirigé vers la page d'authentification.<br />
<br />
3. Dans la boîte de dialogue Paramètres, recherchez le projet auquel vous souhaitez vous connecter.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677906d1785340437/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/6.jpg/" border="0" alt="Nom : 6.jpg
Affichages : 774
Taille : 27,0 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Afficher les rapports de couverture dans l'EDI</font></b>&#65279;<br />
<br />
Vous pouvez consulter les rapports de couverture de code en local à l'aide des EDI JetBrains.<br />
<br />
Dans votre EDI, accédez à Exécuter | Afficher les données de couverture et ouvrez le fichier contenant un rapport de couverture de code.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677907d1785340445/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/7.jpg/" border="0" alt="Nom : 7.jpg
Affichages : 776
Taille : 54,4 Ko"  style="float: CONFIG" /></div><br />
Dans la fenêtre d'outils Couverture, vous pouvez consulter le rapport de couverture des tests. Ce rapport indique le pourcentage du code qui a été exécuté ou couvert par les tests.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677908d1785340454/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/8.jpg/" border="0" alt="Nom : 8.jpg
Affichages : 779
Taille : 32,0 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Présentation du rapport&#65279;</font></b><br />
<br />
L’EDI met en évidence la couverture de test du code à l’aide d’un marquage couleur. Par défaut, la couleur verte indique qu’une ligne donnée a été couverte, tandis que la couleur rouge signale une ligne de code non couverte.<br />
<br />
<div class="bbcode_container">
	<div class="bbcode_description">Citation:</div>
	<div class="bbcode_quote printable">
		<hr />
		
			Si les résultats de couverture de code vous semblent incomplets, vous devrez probablement reconfigurer votre outil de couverture de code et générer un nouveau rapport de couverture de code.
			
		<hr />
	</div>
</div><div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677909d1785340463/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/9.jpg/" border="0" alt="Nom : 9.jpg
Affichages : 766
Taille : 33,8 Ko"  style="float: CONFIG" /></div><br />
Le rapport indique la couverture des lignes qui implémentent la logique d’une méthode, d’une fonction ou d’une classe, mais pas celle de la déclaration de la fonction, de la méthode ou de la classe. L’image ci-dessous montre que la couverture de code ne s’applique pas à la ligne 7, tandis que la ligne 8 n’est pas couverte.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677910d1785340470/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/10.jpg/" border="0" alt="Nom : 10.jpg
Affichages : 768
Taille : 14,6 Ko"  style="float: CONFIG" /></div><br />
Avec Qodana, vous pouvez consulter la couverture de code dans votre tableau de bord Insights.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677911d1785340476/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/11.jpg/" border="0" alt="Nom : 11.jpg
Affichages : 799
Taille : 54,5 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Pièges courants et idées reçues concernant une couverture de code élevée</font></b><br />
<br />
Une couverture de code élevée peut donner un faux sentiment de sécurité. Prenons l’exemple d’une suite de tests présentant une couverture de code de 100 % au niveau des lignes : si les assertions sont faibles ou font totalement défaut, des bogues graves peuvent passer inaperçus. L’exécution seule ne constitue pas une validation.<br />
<br />
<b>Pièges à éviter :</b><br />
<br />
- <b>Ignorer complètement les autres types de couverture.</b> Qodana prend en charge à la fois la couverture globale des lignes et la couverture des nouvelles lignes, ce qui permet aux équipes de s’assurer que le code nouvellement ajouté ou modifié est correctement testé, tout en améliorant progressivement la couverture du reste de la base de code. Cependant, nous vous encourageons à explorer d’autres types de couverture au fil du temps, tels que la couverture des branches.<br />
<br />
- <b>Utiliser la couverture comme indicateur de performance.</b> Lorsqu’un pourcentage de couverture global unique devient un indicateur clé de performance (KPI) de l’équipe, cela incite à maintenir des tests superficiels — juste assez pour atteindre le chiffre visé. Cela peut ralentir le processus de développement sans apporter de bénéfice significatif.<br />
<br />
- <b>Imposer la couverture à du code non testable.</b> Le code généré, les getters/setters triviaux et le code de liaison des frameworks ne nécessitent légitimement pas de tests. Tenter d’imposer une couverture dans ces cas-là représente un gaspillage d’efforts. Excluez-les des seuils.<br />
<br />
- <b>Oublier ce que la couverture ne mesure pas.</b> Les outils de couverture n’évaluent pas si toutes les exigences métier, les parcours utilisateurs ou les aspects non fonctionnels (performances, sécurité, ergonomie) sont correctement testés. Ils indiquent uniquement quel code a été exécuté.<br />
<br />
Microsoft Research a examiné plus de 100 grands projets Java open source et a constaté une corrélation négligeable entre une couverture élevée et un nombre réduit de défauts post-lancement au niveau des fichiers. Cela confirme que la couverture est nécessaire mais non suffisante : il faut la mettre en balance avec les tendances en matière de défauts, les analyses rétrospectives des incidents, les avertissements d’analyse statique et la surveillance en production.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7123" target="_blank">Essayez Qodana gratuitement</a><br />
<br />
<b><font size="3">FAQ</font></b><br />
<br />
<b>Une couverture de code à 100 % est-elle parfois requise dans des projets concrets ?</b><br />
<br />
Oui, dans les domaines critiques pour la sécurité. Les logiciels aérospatiaux soumis à la norme DO-178C et les systèmes automobiles soumis à la norme ISO 26262 peuvent exiger une couverture proche de 100 % au niveau des instructions, des branchements et des conditions de gestion (MC/DC), en fonction d’un ou plusieurs critères liés aux niveaux d’intégrité de sécurité. Pour la plupart des applications web et mobiles commerciales, une couverture de code de 80 % est généralement considérée comme un bon objectif pour les modules centraux, les gains devenant décroissants au-delà de ce seuil. La qualité des tests et une approche axée sur les risques priment sur la recherche d’une couverture à 100 % sur l’ensemble de la base de code.<br />
<br />
<b>À quelle fréquence dois-je effectuer une analyse de couverture dans mon projet ?</b><br />
<br />
Effectuez une analyse de couverture sur chaque pull request dans les dépôts actifs afin que les régressions soient détectées immédiatement. Pour les grands projets logiciels dont l’intégration est plus lente et qui disposent déjà de tests de bout en bout, programmez une tâche de couverture complète chaque nuit ou chaque semaine. Utilisez les données de tendance pour orienter les investissements en refactorisation et déterminer où des tests supplémentaires sont les plus nécessaires.<br />
<br />
<b>Quelle métrique de couverture dois-je privilégier en premier : la couverture de ligne, la couverture de branche ou autre chose ?</b><br />
<br />
Commencez par la couverture de ligne, qui constitue une base de référence simple et facile à communiquer aux parties prenantes. Une fois que votre équipe est à l’aise avec cette approche, introduisez la couverture de branche comme métrique principale pour la logique métier non triviale. La couverture de condition et la couverture de chemin sont particulièrement utiles dans les vérifications d’autorisation de code très complexes et à haut risque, les moteurs de tarification ou tout programme comportant des structures de contrôle profondément imbriquées ; elles peuvent être adoptées de manière sélective plutôt qu’à l’échelle du projet.<br />
<br />
<b>En quoi l’analyse statique du code et la couverture de code se complètent-elles ?</b><br />
<br />
L’analyse statique signale les problèmes potentiels sans exécuter le code, notamment le code mort, les déréférencements de valeurs nulles et les indices de failles de sécurité. La couverture de code montre quelles parties du code source sont réellement exécutées par les tests. Ensemble, elles créent une boucle de rétroaction : l’analyse statique identifie les zones complexes ou à risque, les rapports de couverture révèlent si elles sont suffisamment couvertes, et les développeurs hiérarchisent en conséquence la création de nouveaux tests ou les refactorisations.<br />
<br />
<b>Puis-je utiliser la couverture de code pour des tests manuels ou uniquement pour des tests automatisés ?</b><br />
<br />
Les outils de couverture fonctionnent par défaut avec les tests automatisés, mais ils peuvent également collecter des données lors de l’exécution de tests exploratoires manuels sur une application instrumentée. Cela s’avère utile pendant les phases de consolidation préalables à la mise en production pour confirmer quelles fonctionnalités ont été exécutées. Les scénarios manuels les plus pertinents peuvent ensuite être convertis en tests automatisés afin de préserver cette couverture au fil du temps dans l’ensemble de vos projets logiciels.<br />
<br />
<b>Remarque</b> : bien que les exemples présentés dans cet article utilisent des outils de couverture spécifiques, Qodana n’est lié à aucune solution particulière. Tout outil produisant un format de rapport de couverture pris en charge peut être utilisé.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7123" target="_blank">Essayez Qodana gratuitement</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p677899d1785340378/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/0.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677911d1785340476/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/11.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677910d1785340470/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/10.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677909d1785340463/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/9.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677908d1785340454/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/8.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677907d1785340445/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/7.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677904d1785340413/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/5.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677903d1785340404/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677902d1785340398/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677901d1785340389/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677900d1785340384/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677906d1785340437/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/6.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>JetBrains</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2184897/environnements-developpement/autres-edi/jetbrains/couverture-code-mesurer-comprendre-indicateurs-ameliorer-vos-tests/</guid>
		</item>
		<item>
			<title>ReSharper 2026.2 : agents IA « Freedom » dans Visual Studio, débogage .NET pour VS Code</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2184890&amp;goto=newpost</link>
			<pubDate>Wed, 29 Jul 2026 06:19:25 GMT</pubDate>
			<description>*JetBrains ReSharper 2026.2,...</description>
			<content:encoded><![CDATA[<div><b><font size="4">JetBrains ReSharper 2026.2, l'extension Visual Studio destinée aux développeurs .NET, est disponible, apportant un écosystème d'IA ouvert pour les développeurs .NET et l'agent IA Junie en version preview</font></b><br />
<br />
JetBrains est une société spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux programmeurs (développeurs de logiciels) et aux chefs de projet. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, Rider, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter sur une machine virtuelle Java (JVM)<br />
<br />
ReSharper est une extension de Visual Studio destinée aux développeurs .NET, lancée pour la première fois en 2004. Il s'agit du produit commercial le plus ancien de JetBrains. ReSharper fournit une analyse de la qualité du code en temps réel pour les langages C#, VB.NET, XAML, ASP.NET, JavaScript, TypeScript, CSS, HTML et XML. Parmi ses fonctionnalités, on trouve la refactorisation du code, la complétion de code, la navigation, la recherche d'occurrences et la mise en forme du code. L'extension propose plus de 2 200 inspections de code en temps réel, plus de 60 refactorisations et 450 actions contextuelles.<br />
<br />
La dernière version de l'extension, ReSharper 2026.2, est désormais disponible. ReSharper 2026.2 fait un premier pas vers la prise en charge des agents basés sur l’ACP dans Visual Studio, en commençant par Junie en version Preview. C'est le début d'un écosystème d'IA ouvert pour les développeurs .NET : vous pouvez choisir vos agents et vos modèles, connectés via un protocole unique, associés à l'intelligence de code qui fait la réputation de ReSharper. Cette version étend également le moteur de débogage de ReSharper aux éditeurs compatibles avec VS Code, affine l'analyse et la refactorisation C# de base, et élargit la prise en charge des outils en mode hors processus.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677877d1785308774/environnements-developpement/autres-edi/jetbrains/resharper-2026-2-agents-ia-freedom-visual-studio-debogage-net-vs-code/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 1566
Taille : 56,1 Ko"  style="float: CONFIG" /></div><br />
Concernant la principale nouveauté de cette version, voici l'annonce de JetBrains :<br />
<br />
<div class="bbcode_container">
	<div class="bbcode_description">Citation:</div>
	<div class="bbcode_quote printable">
		<hr />
		
			<b>Notre vision : n’importe quel agent, votre choix, aucune dépendance</b><br />
<br />
Le paysage de l’IA évolue rapidement, et nous pensons que les développeurs .NET ne devraient pas être contraints de s’enfermer dans un écosystème unique pour mener à bien leur travail. Notre objectif pour l’IA dans Visual Studio est simple : aucune dépendance vis-à-vis d’un fournisseur, aucun choix imposé, juste la liberté d’utiliser les agents et les modèles qui vous conviennent le mieux.<br />
<br />
Cette liberté repose sur l’Agent Client Protocol (ACP), une norme ouverte permettant de connecter des agents de codage à l’EDI. Nous intégrons l’ACP à ReSharper afin que vous puissiez bientôt :<br />
<br />
- Découvrir des agents locaux, distants et internes.<br />
- Les connecter tous via la même interface.<br />
- Passer d’un agent à l’autre pour choisir le plus adapté à chaque tâche.<br />
- Rester à jour à mesure que de nouveaux modèles sont publiés.<br />
<br />
Cette initiative est au cœur de notre stratégie 2026 en matière d’IA dans les EDI JetBrains. Nous sommes fermement convaincus que les workflows assistés par l’IA et vos routines de codage classiques doivent coexister harmonieusement, sans jamais se gêner mutuellement. En adoptant des protocoles ouverts comme l’ACP et en privilégiant l’absence totale de dépendance vis-à-vis d’un fournisseur, nous garantissons que, tandis que les agents vous aident à développer plus rapidement, votre EDI reste le lieu par excellence pour réviser, comprendre et maîtriser le code que vous déployez.
			
		<hr />
	</div>
</div>Voici les autres améliorations de cette version :<br />
<br />
<b><font size="3">Découvrez Junie dans Visual Studio (version préliminaire)</font></b><br />
<br />
Cette version préliminaire présente Junie, la première étape vers la prise en charge complète de l’ACP dans ReSharper au sein de Visual Studio. Junie est un agent indépendant du modèle de langage (LLM) : vous n’avez pas besoin d’attendre que le registre complet soit disponible pour vous lancer – choisissez votre modèle et commencez dès maintenant. Dans la fenêtre d’outils « Assistant IA », sélectionnez Junie dans la liste déroulante des agents disponibles pour passer du mode « Chat IA » au mode « Agent ».<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677878d1785308778/environnements-developpement/autres-edi/jetbrains/resharper-2026-2-agents-ia-freedom-visual-studio-debogage-net-vs-code/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 340
Taille : 39,6 Ko"  style="float: CONFIG" /></div><br />
À partir de là, Junie peut :<br />
<br />
- <b>Écrire et modifier du code</b> : transformer une invite en texte brut en logique complexe, ou laisser Junie détecter et corriger de lui-même le code sous-optimal.<br />
<br />
- <b>Refactoriser de manière autonome</b> : confier-lui les tâches fastidieuses, comme le fractionnement d’une classe massive et complexe en modules logiques distincts.<br />
<br />
- <b>Exécuter des commandes dans le terminal</b> : créer ou supprimer des fichiers et exécuter des commandes sans jamais ouvrir de ligne de commande.<br />
<br />
- <b>Gérer les workflows Git</b> : initialiser des dépôts, travailler avec des branches, préparer des modifications et rédiger des messages de commit directement depuis le chat.<br />
<br />
- <b>Explorer et conseiller</b> : poser des questions spécifiques au projet, décrypter des algorithmes hérités complexes et obtenir des suggestions d’architecture.<br />
<br />
Junie étant indépendante du modèle LLM utilisé, vous n’êtes pas lié à un modèle en particulier. Choisissez ou modifiez le modèle sur lequel elle s’exécute dans <i>Extensions | ReSharper | Options | AI Assistant | Junie</i>. Veillez à sélectionner le plugin AI Assistant lorsque vous installez ou mettez à jour ReSharper. Junie est intégrée à ce plugin ; sans lui, le mode Agent n’apparaîtra pas dans la fenêtre d’outils AI Assistant.<br />
<br />
<b>Licence</b><br />
<br />
Les interactions IA de Junie puisent dans votre quota JetBrains AI, qui est déjà inclus dans dotUltimate, un pack « All Products » ou un abonnement JetBrains AI distinct. Vous ne disposez encore d’aucun de ces abonnements ? Un essai gratuit est disponible, ce qui vous permet de tester le mode Agent avant de vous engager.<br />
<br />
<b><font size="3">Le mode hors processus est désormais activé par défaut</font></b><br />
<br />
Le mode hors processus (Out-of-Process, OOP) de ReSharper est désormais activé par défaut. Ce changement architectural déplace l’analyse de code de ReSharper hors du processus Visual Studio, ce qui élimine les blocages de l’interface utilisateur, garantit une saisie fluide et assure la stabilité de votre EDI. L’impact sur la réactivité est considérable. Le mode OOP réduit de six fois le nombre de pauses perceptibles dans le thread de l’interface utilisateur, ramène l’impact de ReSharper au démarrage à moins d’une seconde et améliore considérablement la latence de saisie. <br />
<br />
<b>Ce que cela signifie pour vous</b> : si vous n’avez pas explicitement désactivé le mode « Out-of-Process » par le passé, ReSharper 2026.2 s’exécutera désormais en mode OOP. Les utilisateurs ayant explicitement basculé vers le mode « In-Process » conserveront leur paramètre actuel. Vous pouvez vérifier le mode actuel et basculer d’un mode à l’autre à tout moment via l’indicateur de la barre d’état, le menu ReSharper ou la page d’options <i>Environment | Products &amp; Features</i>.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677879d1785308782/environnements-developpement/autres-edi/jetbrains/resharper-2026-2-agents-ia-freedom-visual-studio-debogage-net-vs-code/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 345
Taille : 24,1 Ko"  style="float: CONFIG" /></div><br />
<b>Limitations actuelles </b>: certaines fonctionnalités ne sont pas encore prises en charge en mode OOP. Veuillez consulter notre documentation pour obtenir la liste la plus récente.<br />
<br />
<b><font size="3">Débogage pour les éditeurs compatibles avec VS Code</font></b><br />
<br />
La fonctionnalité ReSharper la plus demandée pour VS Code est enfin disponible. Cette version introduit la première implémentation du débogage pour les éditeurs compatibles avec VS Code, notamment VS Code, Cursor, EDI Google Antigravity, Devin Desktop et Kiro. Reposant sur le même moteur central que celui de JetBrains Rider, elle offre :<br />
<br />
- La gestion des points d'arrêt, y compris les points d'arrêt conditionnels, à nombre de survenances défini, dépendants et de trace.<br />
- L'inspection en temps réel des variables et des expressions.<br />
- La navigation pas à pas complète.<br />
- Prise en charge de « Launch-and-attach », directement dans votre éditeur.<br />
<br />
Ensemble, ces fonctionnalités font de ReSharper l’extension .NET la plus complète disponible pour les éditeurs compatibles avec VS Code. Pour en savoir plus sur cette version, consultez l’article de blog dédié.<br />
<br />
<b><font size="3">Analyse et refactorisation C# plus pointues</font></b><br />
<br />
- <b>Davantage de cas d’expressions de collection.</b> De nouvelles inspections suggèrent des expressions de collection dans des scénarios supplémentaires, vous aidant ainsi à conserver un code concis et, dans certains cas, à éviter la création de collections intermédiaires. La prise en charge des futures fonctionnalités du langage C# 15 est également en cours de développement, une compréhension complète du langage étant prévue pour la prochaine version majeure.<br />
<br />
- <b>Fonctionnalité « Extract Method » améliorée.</b> « <i>Extract Method</i> » détecte désormais les doublons exacts et paramétrés du code sélectionné au sein d’un fichier et vous permet de choisir les occurrences à remplacer, afin que vous puissiez regrouper la logique répétitive en une seule méthode bien nommée sans avoir à nettoyer chaque doublon à la main.<br />
<br />
- <b>Intégration de <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">.editorconfig</span> et de l’analyseur Roslyn</b>. Ajustez les paramètres <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">.editorconfig</span> relatifs aux avertissements du compilateur directement depuis le menu <b>Alt+Entrée</b> dès l’apparition des avertissements, et bénéficiez d’une gestion plus précise de la configuration de l’analyseur Roslyn, y compris les paramètres <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">.editorconfig</span> et les règles de suppression <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">#pragma</span>.<br />
<br />
- <b>Fenêtre contextuelle « Importer les références manquantes » plus fluide.</b> La fenêtre contextuelle a été repensée avec un meilleur emplacement, sans scintillement, et un design qui ne vous gêne pas pendant que vous tapez.<br />
<br />
<b><font size="3">Mises à jour C++</font></b><br />
<br />
ReSharper 2026.2 ajoute une prise en charge initiale de la réflexion C++26, jetant ainsi les bases d’une métaprogrammation de nouvelle génération à la compilation, ainsi que l’évaluation constexpr pour les allocations de mémoire et les exceptions, une prise en charge de premier ordre de l’éditeur ISPC, une indexation nettement plus rapide d’Unreal Engine pour le code C++ et de nouvelles inspections de code.<br />
<br />
<b><font size="3">Autres points forts de cette version</font></b><br />
<br />
- <b>Outils de profilage et de couverture intégrés.</b> Les outils de profilage des performances, de profilage de la mémoire et de couverture de code sont désormais installés automatiquement avec ReSharper et prêts à l’emploi dans Visual Studio, sans téléchargement supplémentaire. Vous préférez une configuration allégée ? Vous pouvez les désactiver à tout moment sous <i>Options | Products and Features</i>, ou continuer à utiliser les applications autonomes dotTrace, dotMemory et dotCover.<br />
<br />
- <b>Prise en charge étendue des outils « Out-of-Process ».</b> dotTrace, dotMemory et l’outil Monitoring fonctionnent désormais lorsque ReSharper s’exécute en mode « Out-of-Process ».<br />
<br />
- <b>L’analyse dynamique des programmes (DPA) a été retirée.</b> La fonctionnalité de surveillance étant désormais disponible en mode « Out-of-Process », la transition annoncée dans la version précédente est achevée : la DPA sera supprimée dans la version 2026.2, et ses fonctionnalités principales sont intégrées à la nouvelle expérience de surveillance.<br />
<br />
- <b>Performances.</b> Le traitement des fichiers .cshtml et .razor est plus rapide et plus économe en mémoire grâce à la mise en cache des arbres syntaxiques analysés, ce qui améliore des fonctionnalités telles que « Find Usages » et les refactorisations ; de plus, la réduction des allocations de mémoire accélère l’indexation au démarrage.<br />
<br />
- <b>Mise à jour du programme d’installation hors ligne dotUltimate pour Windows.</b> Le programme d’installation hors ligne est désormais fourni sous forme d’archive <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">.ZIP</span> au lieu d’un fichier <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">.EXE</span> autonome. Extrayez l’archive et exécutez le programme d’installation inclus, en veillant à conserver ensemble le fichier exécutable du programme d’installation et son fichier <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">.dat</span> associé (qui contient les binaires de Rider). Les scripts de déploiement devront peut-être tenir compte de cette étape d’extraction supplémentaire.<br />
<br />
ReSharper 2026.2 marque le début d’une approche plus ouverte de l’IA pour .NET dans Visual Studio, tout en apportant de réels gains en matière de débogage, d’analyse et d’outillage. Téléchargez la dernière version et essayez le mode « Junie’s Agent ».<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7122" target="_blank">Téléchargez ReSharper 2026.2</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p677877d1785308774/environnements-developpement/autres-edi/jetbrains/resharper-2026-2-agents-ia-freedom-visual-studio-debogage-net-vs-code/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677878d1785308778/environnements-developpement/autres-edi/jetbrains/resharper-2026-2-agents-ia-freedom-visual-studio-debogage-net-vs-code/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677879d1785308782/environnements-developpement/autres-edi/jetbrains/resharper-2026-2-agents-ia-freedom-visual-studio-debogage-net-vs-code/3.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2184890/environnements-developpement/autres-edi/jetbrains/resharper-2026-2-agents-ia-freedom-visual-studio-debogage-net-vs-code/</guid>
		</item>
		<item>
			<title>ReSharper C++ 2026.2 : réflexion C++26, prise en charge du langage ISPC, et bien plus encore</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2184883&amp;goto=newpost</link>
			<pubDate>Tue, 28 Jul 2026 14:28:38 GMT</pubDate>
			<description>*JetBrains ReSharper C++...</description>
			<content:encoded><![CDATA[<div><b><font size="4">JetBrains ReSharper C++ 2026.2, l'extension Visual Studio pour le développement C++, est disponible, avec la prise en charge de la réflexion C++26 et la prise en charge du langage ISPC</font></b><br />
<br />
JetBrains est une société spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux programmeurs (développeurs de logiciels) et aux chefs de projet. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, Rider, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter sur une machine virtuelle Java (JVM)<br />
<br />
ReSharper est une extension de Visual Studio destinée aux développeurs .NET, lancée pour la première fois en 2004. Il s'agit du produit commercial le plus ancien de JetBrains. ReSharper fournit une analyse de la qualité du code en temps réel pour les langages C#, VB.NET, XAML, ASP.NET, JavaScript, TypeScript, CSS, HTML et XML. ReSharper C++ est l'extension Visual Studio pour le développement C++.<br />
<br />
ReSharper C++ 2026.2 est désormais disponible et apporte une première prise en charge de la réflexion C++26, l’ajout le plus attendu au langage C++ ces dernières années. Cette version introduit également la prise en charge des agents ACP dans ReSharper, avec Junie comme premier agent disponible, ajoute la prise en charge du langage ISPC et accélère considérablement l’indexation dans les projets Unreal Engine. Parmi les autres points forts, citons les mises à jour de l’évaluateur <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">constexpr</span>, de nouvelles inspections de code et des améliorations en matière de refactorisation.<br />
<br />
Voici les changements et améliorations les plus importants dans cette version :<br />
<br />
<font size="3"><b>Prise en charge du C++</b></font><br />
<br />
<b>Réflexion C++26</b><br />
<br />
La fonctionnalité phare de cette version est la réflexion C++26, un ajout tant attendu au langage qui permet l’introspection et la génération de code à la compilation. Grâce à cette mise à jour, ReSharper C++ reconnaît les primitives de réflexion de base :<br />
<br />
- L’opérateur <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">^^</span> (reflect), qui produit une valeur <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">std::meta::info</span> représentant l’entité réfléchie.<br />
<br />
- La syntaxe <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">[: ... :]</span> (splice), qui reconvertit une valeur de réflexion en une construction du langage.<br />
<br />
- Les requêtes à la compilation sur les types, membres, énumérateurs et autres entités reflétés.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677866d1785301613/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 362
Taille : 76,2 Ko"  style="float: CONFIG" /></div><br />
Parmi les principaux compilateurs C++, seul GCC 16 prend actuellement en charge la réflexion C++26. Pour tester dès maintenant la réflexion C++26 dans Visual Studio, vous pouvez notamment créer un projet C++ sous Linux et le compiler à l’aide de WSL sur une distribution Linux incluant GCC 16, comme Fedora 44.<br />
<br />
<b>Fonctionnalités C++26 associées</b><br />
<br />
La prise en charge de la réflexion est complétée par deux fonctionnalités linguistiques C++26 associées :<br />
<br />
- ReSharper C++ prend désormais en charge les <b>blocs</b> <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">consteval { ... }</span> qui sont évalués à la compilation et peuvent injecter des déclarations dans la portée englobante. Les blocs <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">consteval</span> offrent un moyen propre de déclencher des effets secondaires à la compilation, ce qui les rend particulièrement utiles pour la métaprogrammation pratique avec la réflexion.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677867d1785301617/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 245
Taille : 56,9 Ko"  style="float: CONFIG" /></div><br />
- Des <b>annotations</b> définies par l’utilisateur peuvent désormais être associées à des déclarations et interrogées via l’API de réflexion, ce qui permet une génération de code personnalisée pilotée par des métadonnées.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677868d1785301621/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 253
Taille : 81,2 Ko"  style="float: CONFIG" /></div><br />
<b>Évaluation <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">constexpr</span>.</b><br />
<br />
L'équipe de JetBrains a également mis à jour l’évaluateur <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">constexpr</span> en y ajoutant deux fonctionnalités importantes :<br />
<br />
- L’évaluateur prend désormais en charge l’allocation dynamique de mémoire lors de l’évaluation des constantes – une fonctionnalité introduite dans C++20. Cela permet une évaluation correcte du code <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">constexpr</span> utilisant <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">new</span>/<span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">delete</span> ou des conteneurs standard tels que <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">std::vector</span> et <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">std::string</span>.<br />
<br />
- L’évaluateur prend désormais en charge les exceptions <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">constexpr</span> de C++26 et gère les expressions <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">try</span>/<span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">catch</span> et <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">throw</span> lors de l’évaluation des constantes.<br />
<br />
<b><font size="3">Prise en charge du langage ISPC</font></b><br />
<br />
Ils ont ajouté la prise en charge d’ISPC (Intel SPMD Program Compiler), un langage conçu pour la programmation parallèle haute performance sur les processeurs. ISPC repose sur le modèle de programmation SPMD, dans lequel vous écrivez du code qui ressemble à un programme série standard, mais où, lors de l’exécution, plusieurs instances du programme s’exécutent en parallèle sur le matériel cible. ISPC est largement utilisé dans les moteurs de jeux, les systèmes de rendu et le calcul scientifique, notamment dans les projets Unreal Engine.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677869d1785301625/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 237
Taille : 24,7 Ko"  style="float: CONFIG" /></div><br />
ReSharper C++ propose désormais la coloration syntaxique, l’analyse de code, la navigation et l’aide à la programmation pour les fichiers ISPC, offrant ainsi à votre code ISPC la même qualité de prise en charge que celle que vous attendez pour le C++.<br />
<br />
<b><font size="3">Unreal Engine</font></b><br />
<br />
<b>Performances</b><br />
<br />
Cette version apporte des améliorations majeures en termes de performances lors du démarrage des projets Unreal Engine. ReSharper C++ utilise désormais les informations de projet provenant de <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">UnrealBuildTool</span> pour accélérer l’indexation initiale en analysant uniquement les fichiers inclus dans le modèle de projet Unreal Engine. Combiné à d’autres optimisations, notamment des améliorations de l’indexation multithread, cela se traduit par un gain de vitesse significatif.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677870d1785301629/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/5.jpg/" border="0" alt="Nom : 5.jpg
Affichages : 249
Taille : 28,0 Ko"  style="float: CONFIG" /></div><br />
D’après les mesures effectuées sur la solution d’exemple Lyra :<br />
<br />
- L’indexation initiale du code C++ est jusqu’à 55 % plus rapide.<br />
- Le chargement des caches C++ lors d’un démarrage à chaud est jusqu’à 35 % plus rapide.<br />
<br />
Vous pouvez désactiver ce nouveau comportement d’indexation en décochant l’option <i>Index only files in Unreal Engine project model</i>  sur la page de paramètres <i>Code Editing | C/C++ | Unreal Engine.</i><br />
<br />
<b>Prise en charge des Blueprints</b><br />
<br />
La prise en charge des Blueprints a également fait l’objet d’une refonte majeure, ce qui se traduit par une réduction significative du temps d’indexation. Sur la solution d’exemple Lyra, l’indexation des Blueprints est jusqu’à 40 % plus rapide, mais le gain de vitesse exact dans votre projet dépend de la structure de vos ressources. ReSharper C++ détecte désormais également les utilisations des balises de gameplay au sein des ressources Blueprint et les affiche dans <i>Code Vision</i> et dans <i>Find usages</i>, vous offrant ainsi une vue d’ensemble complète des emplacements où vos balises de gameplay sont utilisées dans l’ensemble du projet.<br />
<br />
<b><font size="3">Analyse du code</font></b><br />
<br />
<b>Liaison interne</b><br />
<br />
La nouvelle fonctionnalité d’inspection <i>Entity can have internal linkage</i> détecte les fonctions, variables et classes qui ne sont pas utilisées en dehors de leur unité de traduction. Vous pouvez utiliser les corrections proposées pour marquer ces entités comme <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">static</span> ou les déplacer dans un espace de noms anonyme, ce qui aide le compilateur à optimiser le code et évite les conflits de liaison indésirables.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677871d1785301633/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/6.gif/" border="0" alt="Nom : 6.gif
Affichages : 252
Taille : 160,0 Ko"  style="float: CONFIG" /></div><br />
<b>Initialiseurs désignés dans l’initialisation d’agrégats</b><br />
<br />
ReSharper C++ suggère désormais d’ajouter des désignateurs aux listes d’initialiseurs entre accolades dans l’initialisation d’agrégats. Les initialiseurs désignés, disponibles depuis C++20 et C99, indiquent explicitement à quel membre correspond chaque initialiseur, ce qui améliore la lisibilité du code et réduit le risque d’erreurs en cas de réorganisation des membres. Une action contextuelle correspondante est également disponible et peut être utilisée même lorsque l’inspection est désactivée.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677872d1785301638/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/7.gif/" border="0" alt="Nom : 7.gif
Affichages : 248
Taille : 57,7 Ko"  style="float: CONFIG" /></div><br />
<b>Appels à des fonctions de base redéfinies</b><br />
<br />
Une autre nouvelle inspection détecte les appels qualifiés à des fonctions virtuelles de base qui sont redéfinies dans une classe dérivée. Appeler directement une fonction virtuelle de la classe de base plutôt que via un dispatch virtuel peut être source de bogues subtils, et cette inspection permet de détecter de tels cas.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677873d1785301642/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/8.gif/" border="0" alt="Nom : 8.gif
Affichages : 257
Taille : 61,8 Ko"  style="float: CONFIG" /></div><br />
<b>Attribut</b> <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">[[jetbrains::used_implicitly]]</span>.<br />
<br />
ReSharper C++ reconnaît désormais l’attribut <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">[[jetbrains::used_implicitly]]</span>, qui peut être appliqué à des symboles afin de désactiver les inspections qui suggéreraient autrement de modifier leur signature ou leur liaison. Cela s’avère utile pour les symboles utilisés via la réflexion, la génération de code ou d’autres mécanismes invisibles à l’analyse statique.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677874d1785301647/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/9.jpg/" border="0" alt="Nom : 9.jpg
Affichages : 237
Taille : 31,8 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Aide au codage</font></b><br />
<br />
<b>Améliorations de la refactorisation</b><br />
<br />
Deux améliorations apportées à la refactorisation facilitent la restructuration du code :<br />
<br />
- L’appel de la fonction <i>Inline Function</i> sur une déclaration de fonction intègre désormais toutes les utilisations de la fonction dans l’ensemble du code, et pas seulement celle située sous le curseur.<br />
<br />
- La refactorisation <i>Extract Method</i> est désormais disponible à l’intérieur des corps de lambda, ce qui vous permet d’extraire des parties d’un lambda pour les placer dans une fonction distincte.<br />
<br />
<b>Actions contextuelles</b><br />
<br />
De nouvelles actions contextuelles facilitent les tâches quotidiennes :<br />
<br />
- Une nouvelle action contextuelle vous permet d’activer ou de désactiver facilement le qualificateur <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">const</span> sur une fonction membre.<br />
<br />
- Vous pouvez désormais insérer rapidement une directive <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">#pragma clang diagnostic ignored</span> pour supprimer un diagnostic Clang spécifique sur la ligne actuelle.<br />
<br />
- Dans les projets Unreal Engine, vous pouvez désormais copier le chemin d’inclusion du fichier d’en-tête actuellement ouvert à partir du menu <i>Copy Code Reference</i>, ce qui facilite le collage de la directive <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">#include</span> correcte.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7121" target="_blank">Téléchargez ReSharper C++ 2026.2</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p677870d1785301629/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/5.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677874d1785301647/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/9.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677873d1785301642/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/8.gif/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677872d1785301638/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/7.gif/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677871d1785301633/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/6.gif/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677869d1785301625/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677868d1785301621/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677867d1785301617/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677866d1785301613/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/1.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2184883/environnements-developpement/autres-edi/jetbrains/resharper-cpp-2026-2-reflexion-cpp26-prise-charge-langage-ispc-bien-plus/</guid>
		</item>
		<item>
			<title>Rider 2026.2 : intelligence de l’EDI pour les agents IA, performances accrues</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2184870&amp;goto=newpost</link>
			<pubDate>Tue, 28 Jul 2026 07:59:22 GMT</pubDate>
			<description><![CDATA[*La dernière version de l'EDI...]]></description>
			<content:encoded><![CDATA[<div><b><font size="4">La dernière version de l'EDI JetBrains pour le développement .NET Rider 2026.2 est disponible, avec l'intelligence de l'EDI pour les agents IA et des mises à jour pour le développement de jeux</font></b><br />
<br />
JetBrains est une société spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux programmeurs (développeurs de logiciels) et aux chefs de projet. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, Rider, WebStorm et CLion. JetBrains Rider est l'EDI pour le développement .NET (principalement en C# et F#) et le développement de jeux avec Unity (C#) et Unreal Engine (C++).<br />
<br />
JetBrains annonce que Rider 2026.2 est disponible et met l’intelligence propre à l’EDI au service de vos agents de codage IA, afin qu’ils puissent s’appuyer sur une connaissance réelle du projet plutôt que de devoir la reconstituer à partir de fichiers et de la sortie du terminal. Un nouvel ensemble de compétences pour les agents couvre les tests, le profilage, la refactorisation et les workflows officiels Microsoft .NET, et GitHub Copilot rejoint désormais la gamme en tant qu’agent intégré en natif. Cette version apporte également une série d’améliorations de performances qui rendent l’IDE plus réactif tant pour le développement .NET que pour le développement de jeux vidéo.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677849d1785229488/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/0.jpg/" border="0" alt="Nom : 0.jpg
Affichages : 3327
Taille : 45,7 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Mettez l’intelligence de Rider au service de vos agents IA</font></b><br />
<br />
Rider 2026.2 connecte directement les agents de codage aux données de couverture de l’EDI, aux informations du profileur, au moteur de refactorisation et aux conseils spécifiques au framework, ce qui leur permet de cerner plus rapidement le contexte et d’apporter des modifications plus sûres, en réduisant les conjectures et le gaspillage de jetons. Les compétences intégrées sont fournies avec l’EDI sous forme de workflows intégrés, aidant les agents à gérer des tâches spécifiques sans avoir à élaborer eux-mêmes chaque étape. D’autres compétences peuvent être ajoutées via le gestionnaire de compétences des agents.<br />
<br />
Voici quelques-unes des compétences qui se démarquent dans cette version :<br />
<br />
- <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">dottrace-analyze</span> est une compétence intégrée capable de lire un instantané dotTrace <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">.dtp</span> que vous lui fournissez, d’identifier où le processeur a réellement été sollicité et de retracer le chemin d’accès le plus fréquent dans votre code. <br />
<br />
- <b>Les hooks de vérification de la qualité du code pour Claude Code</b> valident chaque modification effectuée par un agent avant qu’il ne puisse continuer, bloquant les erreurs et renvoyant des avertissements à titre de retour d’information.<br />
<br />
- <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">finding-tests</span> utilise les données dotCover pour indiquer à votre agent où placer de nouveaux tests et comment les formater pour respecter vos conventions.<br />
<br />
- <b>Des compétences Unreal Engine adaptées aux jeux</b> pour la création en UE C++, le débogage en direct et la création de tests.<br />
<br />
Outre les compétences propriétaires de JetBrains Rider, cette dernière version prend également en charge les compétences officielles Microsoft .NET, Aspire et Azure, qui sont faciles à trouver et à installer directement depuis l’EDI. Vous pouvez consulter la liste complète des compétences d’agent disponibles dans <i>Settings/Preferences | Tools | AI Assistant | Skills</i>. Les hooks de vérification de la qualité du code se trouvent et se configurent sous <i>Tools | AI Agent Hooks</i>.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677850d1785229492/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 401
Taille : 123,6 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Plus de choix en matière d’IA : Copilot intégré, ainsi que vos propres modèles pour la complétion de code</font></b><br />
<br />
<b>GitHub Copilot est désormais un agent intégré en natif</b>, fruit d’un partenariat direct entre JetBrains et Microsoft. Copilot est disponible dès l’installation depuis le sélecteur d’agents dans le chat IA, avec une connexion via OAuth et sans configuration du registre ACP requise (un abonnement Copilot actif est nécessaire).<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677851d1785229496/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 406
Taille : 31,2 Ko"  style="float: CONFIG" /></div><br />
<b>La complétion IA prend désormais en charge les fournisseurs tiers.</b> Outre les modèles entraînés par JetBrains, disponibles d’emblée pour tous les utilisateurs de l’IA JetBrains, vous pouvez désormais connecter votre propre modèle de complétion, configuré indépendamment de votre fournisseur d’agent. Les options prises en charge incluent des points de terminaison compatibles OpenAI tels que LM Studio ou <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">llama.cpp</span>, ainsi que Mercury d’Inception Labs.<br />
<br />
<b><font size="3">Gains de performances pour .NET et Unreal Engine</font></b><br />
<br />
Rider 2026.2 réduit les temps d’attente qui interrompent votre flux de travail. Sous Windows, le lancement du débogueur est environ 2,8 secondes plus rapide pour les applications .NET, le changement de branche dans les solutions basées sur Roslyn est généralement 2 à 3 fois plus rapide, et les processus backend utilisent environ 7 à 8 % de mémoire en moins. Pour les projets Unreal Engine volumineux ouverts via le fichier .sln généré, l’indexation C++ s’effectue environ deux fois plus vite que dans la version 2026.1.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677852d1785229501/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/3.jpg/" border="0" alt="Nom : 3.jpg
Affichages : 397
Taille : 44,9 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Rechargement à chaud pour WPF</font></b><br />
<br />
L’un des plus grands gains de productivité .NET de cette version : le rechargement à chaud WPF vous permet de modifier votre code XAML pendant que l’application s’exécute sous le débogueur Rider et de voir les modifications enregistrées s’appliquer instantanément. Modifiez les mises en page, les styles, les modèles et les ressources sans avoir à recompiler, redémarrer ou revenir à l’écran sur lequel vous vous trouviez. Associé au « C# Hot Reload » existant de Rider, cette fonctionnalité transforme l’itération de l’interface utilisateur en une boucle serrée et ininterrompue.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677853d1785229513/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/4.jpg/" border="0" alt="Nom : 4.jpg
Affichages : 398
Taille : 69,1 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Développement de jeux</font></b><br />
<br />
Le développement de jeux est une priorité à chaque nouvelle version, et la version 2026.2 apporte des avancées sur trois fronts : l’accélération de l’indexation Unreal, les compétences des agents IA adaptés aux jeux, et un débogage de premier ordre grâce à la prise en charge de base de Natvis sur Linux et macOS (y compris le chemin d’accès recommandé <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">godot-cpp.natvis</span> pour les types Godot).<br />
<br />
Le développement sous Godot semble également plus abouti, grâce à un nouveau formateur GDScript configurable, à la possibilité de glisser-déposer des nœuds de scène dans le code sous forme de chemins d’accès ou de variables <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">@onready</span>/<span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">@export</span>, à l’extension officielle d’intégration JetBrains Rider disponible sur le Godot Asset Store, ainsi qu’à une résolution plus précise des Autoloads et des références <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">uid://</span>.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677854d1785229518/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/5.jpg/" border="0" alt="Nom : 5.jpg
Affichages : 399
Taille : 47,9 Ko"  style="float: CONFIG" /></div><br />
Du côté d’Unreal, la navigation dans UInterface et l’utilisation des balises de gameplay sont désormais disponibles à la fois en C++ et dans les Blueprints, et ISPC bénéficie d’une prise en charge de premier ordre dans l’éditeur.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677855d1785229527/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/6.jpg/" border="0" alt="Nom : 6.jpg
Affichages : 393
Taille : 54,4 Ko"  style="float: CONFIG" /></div><br />
<b><font size="3">Prise en charge des derniers langages</font></b><br />
<br />
- <b>C#</b> : Rider intègre les dernières mises à jour de ReSharper pour l’analyse, la refactorisation et la prise en charge des langages. <br />
<br />
- <b>C++</b> : prise en charge initiale de la <b>réflexion C++26</b> (l’opérateur <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">^^</span>, le splicing et les blocs consteval), ainsi qu’un évaluateur constexpr qui gère désormais les allocations dynamiques et les exceptions. <br />
<br />
- <b>F#</b> : une nouvelle action pour désactiver et rétablir les avertissements du compilateur, des importations de symboles plus fiables à partir des erreurs, une interopérabilité C# 14 plus fluide et des corrections supplémentaires pour le débogage.<br />
<br />
<b><font size="3">Autres points forts de cette version</font></b><br />
<br />
- <b>Modèles d’applications C# basés sur des fichiers</b> : créez, modifiez et exécutez des scripts C# à fichier unique, des utilitaires de dépôt et des aides à l’intégration continue sans avoir à créer un projet complet.<br />
<br />
- <b>Prise en charge de TypeScript 7</b> : le compilateur basé sur Go réduit considérablement le temps de chargement des projets ; lors de nos tests sur le code source de Kibana, ce temps est passé d’environ 12 secondes à environ 3 secondes.<br />
<br />
- <b>Azure Functions intégrées</b> : créez, exécutez, déboguez et conteneurisez des projets Functions localement sans avoir besoin du plugin Azure Toolkit séparé.<br />
<br />
- <b>Demandes de modification (pull requests) Azure DevOps</b> : répertoriez, filtrez, examinez, votez et créez des PR depuis une nouvelle fenêtre d’outils, sans quitter Rider.<br />
<br />
- <b>Aperçus des intentions</b> : visualisez les différences qu’une correction rapide ou une action contextuelle va générer avant de l’appliquer.<br />
<br />
- <b>Fenêtre d’outils NuGet repensée</b> : la navigation, les paquets installés et les mises à jour disposent désormais de chemins d’accès distincts et plus ciblés.<br />
<br />
- <b>Débogage plus intelligent</b> : commande « Step Into » plus prévisible et valeurs de retour plus claires pour C#/F#, ainsi qu’un débogage plus fiable des générateurs de code source sous Linux et macOS.<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7120" target="_blank">Téléchargez Rider 2026.2</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p677849d1785229488/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/0.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677850d1785229492/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677851d1785229496/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677852d1785229501/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/3.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677853d1785229513/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/4.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677854d1785229518/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/5.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677855d1785229527/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/6.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2184870/environnements-developpement/autres-edi/jetbrains/rider-2026-2-intelligence-l-edi-agents-ia-performances-accrues/</guid>
		</item>
		<item>
			<title>Présentation de JetBrains Context : l’intelligence de référentiel pour les agents de codage</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2184868&amp;goto=newpost</link>
			<pubDate>Tue, 28 Jul 2026 06:34:37 GMT</pubDate>
			<description>*JetBrains présente JetBrains...</description>
			<content:encoded><![CDATA[<div><b><font size="4">JetBrains présente JetBrains Context, une nouvelle couche d’intelligence de référentiel pour les agents de codage IA, permettant aux agents IA de travailler plus efficacement</font></b><br />
<br />
JetBrains est une société spécialisée dans le développement de logiciels, qui conçoit des outils destinés aux programmeurs (développeurs de logiciels) et aux chefs de projet. JetBrains propose divers environnements de développement intégrés (EDI), tels que IntelliJ IDEA, PyCharm, Rider, WebStorm et CLion. Elle a également créé en 2011 le langage de programmation Kotlin, qui peut s'exécuter sur une machine virtuelle Java (JVM).<br />
<br />
Récemment, JetBrains a lancé JetBrains Context, une nouvelle couche d’intelligence de référentiel qui aide les agents de codage à travailler plus efficacement et à produire des résultats de meilleure qualité sur des bases de code complexes. Dans le cadre du déploiement de JetBrains AI for Teams and Organizations, JetBrains Context est désormais disponible en accès anticipé sans frais supplémentaires avec votre abonnement JetBrains AI. Il s’intègre à Claude Code, Codex CLI et Junie CLI, et peut être utilisé depuis les EDI JetBrains, Air, VS Code et d’autres éditeurs pris en charge.<br />
<br />
JetBrains s’est toujours attaché à améliorer l’efficacité des développeurs, même lorsqu’ils travaillent sur les bases de code les plus complexes. Historiquement, cela s’est traduit par la mise à disposition de fonctionnalités intelligentes telles que l’autocomplétion, l’analyse de code et la navigation. Avec cette annonce, l'équipe de JetBrains étend cette même productivité aux agents IA en leur fournissant les informations de référentiel dont ils ont besoin pour écrire, valider et réviser efficacement le code. Vlad Tankov, Directeur technique du département JetBrains Agent Systems a déclaré : « <i>Nous avons passé des décennies à aider les développeurs à se familiariser avec des bases de code complexes. Il s’avère que les agents IA ont besoin d’une aide similaire lorsqu’ils travaillent sur un projet qui ne leur est pas familier.</i> »<br />
<br />
Dans les bases de code d’entreprise, le contexte est essentiel. C’est ce qui fait la différence entre des résultats médiocres nécessitant une révision minutieuse et des retouches, et un codage efficace par les agents qui comprend votre base de code, vos API, vos dépendances, vos modèles d’implémentation et vos conventions d’ingénierie. Tout comme les développeurs, les agents n’ont pas besoin d’être pris par la main sur des projets de validation de concept à petite échelle, mais ils ont besoin d’un contexte supplémentaire : ce savoir institutionnel tacite et ces connaissances qui leur permettent de travailler efficacement avec de grandes bases de code.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677839d1785222305/environnements-developpement/autres-edi/jetbrains/presentation-jetbrains-context-l-intelligence-referentiel-agents-codage/0.jpg/" border="0" alt="Nom : 0.jpg
Affichages : 1088
Taille : 33,9 Ko"  style="float: CONFIG" /></div><br />
<b>La nouvelle réalité pour les agents</b><br />
<br />
L'investissement de JetBrains dans le contexte fait écho à un besoin croissant chez les développeurs de perfectionner leurs agents. Alors que les développeurs se contentaient auparavant de pratiquement n’importe quel résultat généré par l’IA, la « phase de lune de miel » touche désormais à sa fin et les choses se compliquent. Les attentes envers les développeurs augmentent, et le champ d’application de l’IA s’élargit à mesure que les développeurs s’efforcent de répondre aux nouvelles exigences. La demande de retour sur investissement de l’IA se traduit par des délais raccourcis pour les équipes et l’apparition de quotas d’IA. Cela signifie que nous ne pouvons plus dépenser des jetons sans limite pour résoudre les problèmes par la force brute en faisant tourner les meilleurs modèles. Les exigences de la réalité rattrapent rapidement les nouveaux superpouvoirs des agents.<br />
<br />
Ce qui n’était autrefois qu’un simple inconvénient se transforme peu à peu en goulot d’étranglement. La plupart des tâches de résolution de problèmes et de développement de fonctionnalités exigent des agents qu’ils effectuent une exploration approfondie du code pour comprendre l’état actuel ou obtenir une référence pour les modifications prévues. Dans la pratique, cela implique d’effectuer des recherches, de lancer des agents d’exploration et de lire des fichiers – des activités qui consomment souvent du temps et des jetons. Même avec les modèles les plus performants d’aujourd’hui, un contexte et une visibilité sur le dépôt limités peuvent empêcher les agents de trouver le bon code, de repérer de bons exemples d’implémentation ou d’identifier des modèles existants méritant d’être réutilisés. Le résultat est simple : moins les agents passent de temps à explorer les dépôts, plus ils peuvent se consacrer à la tâche à accomplir. C’est exactement le problème que JetBrains Context a été conçu pour résoudre.<br />
<br />
<b>Qu’est-ce que JetBrains Context ?</b><br />
<br />
JetBrains Context est une couche d’intelligence de référentiels destinée aux agents de codage tels que Claude Agent, OpenAI Codex et JetBrains Junie. Il construit de manière incrémentielle un index sémantique de vos référentiels et offre une recherche sémantique, aidant ainsi les agents à accéder aux connaissances pertinentes des référentiels au lieu de rechercher et de lire des fichiers à plusieurs reprises. Au lieu de s’appuyer uniquement sur des recherches par mots-clés et l’exploration répétée de fichiers, il peut poser directement n’importe quelle question ou rechercher des termes ou concepts associés. Pour que cela fonctionne, nous nous appuyons sur deux composants principaux : un backend qui indexe progressivement le dépôt et des outils de recherche sémantique qui permettent aux agents d’interroger ces données.<br />
<br />
L’une des fonctionnalités importantes que nous sommes ravis de déployer est la recherche multi-dépôts. Au lieu d’être limités au dépôt actuel, les agents peuvent découvrir du code pertinent dans l’ensemble de la base de code de votre organisation, y compris dans les dépôts qui ne sont pas extraits localement. Cela les aide à valider les API et les dépendances, à comprendre l’impact des modifications ou à localiser du code réutilisable dans des projets distants. Au final, cela permet de maintenir un niveau de qualité du code plus élevé, d’éviter le travail superflu et d’améliorer la cohérence architecturale au sein de la base de code.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677840d1785222309/environnements-developpement/autres-edi/jetbrains/presentation-jetbrains-context-l-intelligence-referentiel-agents-codage/1.jpg/" border="0" alt="Nom : 1.jpg
Affichages : 786
Taille : 90,9 Ko"  style="float: CONFIG" /></div><br />
<b>C’est à l’usage que l’on juge (ou, devrions-nous dire, aux tests)</b><br />
<br />
L'équipe de JetBrains rapporte avoir validé JetBrains Context sur 205 tâches open source SWE-bench, 175 tâches de monorepo de production et 1 953 tâches de localisation de code. Sur l’ensemble de ces benchmarks, JetBrains Context a réduit le nombre de tours d’agent jusqu’à 68 %, la latence jusqu’à 59 % et le coût d’exécution jusqu’à 48 %.<br />
<br />
Il n’est pas facile d’évaluer les systèmes d’IA de manière cohérente. Les agents de codage modernes sont intrinsèquement probabilistes ; c’est pourquoi nous avons conçu notre évaluation autour de benchmarks reconnus du secteur et de référentiels à l’échelle de production. Grâce à ces évaluations, nous avons réussi à améliorer cette technologie au point de pouvoir affirmer avec certitude qu’elle apporte une différence considérable en termes de temps, de coûts et de qualité du code pour les bases de code volumineuses.<br />
<br />
<div style="text-align: center;"><img src="https://www.developpez.net/forums/attachments/p677841d1785222313/environnements-developpement/autres-edi/jetbrains/presentation-jetbrains-context-l-intelligence-referentiel-agents-codage/2.jpg/" border="0" alt="Nom : 2.jpg
Affichages : 780
Taille : 69,4 Ko"  style="float: CONFIG" /></div><br />
Voici un extrait de l'annonce de JetBrains :<br />
<br />
<b>L’accès anticipé à JetBrains Context est déjà inclus dans votre abonnement !</b><br />
<br />
Suivez les instructions sur notre page d’accueil pour commencer :<br />
<br />
1. Installez l’interface de ligne de commande (CLI) à l’aide d’une simple requête <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">GET</span>.<br />
<br />
2. Authentifiez-vous à l’aide de la commande CLI <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">jbcontext login</span>. Vos identifiants fonctionneront tels quels. Une licence JetBrains AI est requise, mais JetBrains Context ne consommera aucun quota.<br />
<br />
3. Accédez au dossier de votre projet et configurez JetBrains Context pour votre agent de codage préféré à l’aide de la commande <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">jbcontext setup-agent</span>. Vous pouvez également effectuer cette configuration de manière globale au niveau de l’utilisateur.<br />
<br />
4. JetBrains Context indexera automatiquement votre code via les hooks de l’agent, mais vous pouvez également le faire explicitement en appelant la commande <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">jbcontext index</span>. Votre code source n’est pas stocké sur les serveurs de JetBrains Context.<br />
<br />
Désormais, au fur et à mesure que vous codez normalement, vous constaterez que l’agent est doté de nouvelles fonctionnalités d’intelligence de référentiel qui le rendent bien plus productif.<br />
<br />
Après avoir testé JetBrains Context, si vous n’êtes pas certain que cela vous aide ou non, vous pouvez consulter nos nouvelles analyses intégrées ! Il vous suffit de taper <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">jbcontext analyze</span> pour voir les économies de coûts et de temps réalisées sur la base de vos données en temps réel.<br />
<br />
Nous serions ravis de connaître votre avis. Partagez vos commentaires, posez vos questions ou racontez-nous votre expérience dans les commentaires ci-dessous. Vous pouvez également utiliser la commande  <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">jbcontext send-feedback</span> directement depuis l’interface de ligne de commande (CLI).<br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7119" target="_blank">Commencez à utiliser JetBrains Context</a></div>


	<div style="padding:10px">

	

	
		<fieldset class="fieldset">
			<legend>Images attachées</legend>
				<div style="padding:10px">
				<img class="attach" src="https://www.developpez.net/forums/attachments/p677840d1785222309/environnements-developpement/autres-edi/jetbrains/presentation-jetbrains-context-l-intelligence-referentiel-agents-codage/1.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677841d1785222313/environnements-developpement/autres-edi/jetbrains/presentation-jetbrains-context-l-intelligence-referentiel-agents-codage/2.jpg/" alt="" />&nbsp;<img class="attach" src="https://www.developpez.net/forums/attachments/p677839d1785222305/environnements-developpement/autres-edi/jetbrains/presentation-jetbrains-context-l-intelligence-referentiel-agents-codage/0.jpg/" alt="" />&nbsp;
			</div>
		</fieldset>
	

	

	

	</div>
]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2184868/environnements-developpement/autres-edi/jetbrains/presentation-jetbrains-context-l-intelligence-referentiel-agents-codage/</guid>
		</item>
		<item>
			<title>JetBrains annonce la disponibilité de PyCharm 2026.2</title>
			<link>https://www.developpez.net/forums/showthread.php?t=2184795&amp;goto=newpost</link>
			<pubDate>Thu, 23 Jul 2026 02:16:48 GMT</pubDate>
			<description>*JetBrains annonce la...</description>
			<content:encoded><![CDATA[<div><b><font size="4">JetBrains annonce la disponibilité de PyCharm 2026.2, la dernière version de l'EDI destiné à la programmation en Python, apportant un nouveau plugin Rust pour créer des extensions Python</font></b><br />
<br />
PyCharm est un environnement de développement intégré (EDI) destiné à la programmation en Python. Il offre des fonctionnalités d'analyse de code, un débogueur graphique, un outil de test unitaire intégré, une intégration avec les systèmes de contrôle de version, et prend en charge le développement web avec Django. PyCharm est développé par JetBrains et repose sur sa plateforme IntelliJ. PyCharm est multiplateforme et fonctionne sous Microsoft Windows, macOS et Linux. <br />
<br />
PyCharm 2026.2, la dernière version de l'EDI, est désormais disponible. Dans PyCharm 2026.2, vous pouvez créer des extensions Python avec le nouveau plugin Rust et les déboguer avec debugpy, qui est désormais le moteur par défaut. L’exécution des utilitaires externes est désormais gérée via une interface de paramètres repensée pour uvx, tandis que les configurations multi-projets sont prises en charge nativement pour les espaces de travail uv, Poetry et Hatch. Cette version introduit également une minimap dans l’éditeur, intègre le moteur Pyrefly pour accélérer l’analyse des types, ajoute la génération de projets par IA et bien plus encore.<br />
<br />
<div style="text-align: center;">
<div class="video-container"><iframe class="restrain" title="YouTube video player" width="560" height="315" allowfullscreen src="//www.youtube.com/embed/pQNecZTlyq4?wmode=transparent&amp;fs=1" frameborder="0"></iframe></div>
</div><br />
Voici les principales améliorations de cette version :<br />
<br />
<b>Développement d’extensions Python avec le plugin Rust [Bêta][Pro]</b> : Travaillez en toute fluidité sur des projets Python qui utilisent des modules Rust pour accélérer les composants les plus critiques en matière de performances.<br />
<br />
<b>debugpy en tant que débogueur par défaut</b> : Suite à son introduction en tant que backend optionnel avec la version 2026.1, debugpy est désormais activé par défaut pour tous les projets Python et les notebooks Jupyter en utilisant le protocole Debug Adapter (DAP).<br />
<br />
<b>Prise en charge des outils gérés par uv et <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">uvx</span></b> : PyCharm s’appuie désormais sur la chaîne d’outils uv pour simplifier l’exécution de vos utilitaires de développement externes, éliminant ainsi les installations manuelles de paquets qui encombrent votre environnement local.<br />
<br />
<b>Prise en charge des projets multiples uv, Poetry et Hatch, ainsi que des espaces de travail uv [Bêta]</b> : Précédemment disponible en tant que fonctionnalité optionnelle dans PyCharm 2026.1.1, cette fonctionnalité est activée par défaut dans la version 2026.2. Elle simplifie la gestion de vos sous-projets et fournit des informations plus riches sur les dépendances, directement dans vos fichiers de configuration. <br />
<br />
<b>Mini-carte de l’éditeur</b> : Naviguez parmi des fichiers source et des notebooks complexes plus efficacement avec la mini-carte officielle de l’éditeur. Elle offre une vue d’ensemble visuelle de la structure de votre document pour tous les types de fichiers pris en charge, tout en proposant une présentation spécialement conçue pour les notebooks Jupyter.<br />
<br />
<b>Intégration du moteur de type Pyrefly</b> : Utilisez Pyrefly comme moteur de typage externe pour accélérer de façon significative les fonctionnalités d’analyse de code pour les bases de code Python de grande envergure.<br />
<br />
<b>Commencez de nouveaux projets avec l’IA</b> : Si vous disposez d’une licence JetBrains AI, vous pouvez désormais générer des projets entièrement configurés et exécutables en utilisant des instructions génératives (prompt) en langage naturel directement depuis l’écran d’accueil.<br />
<br />
<b>Gestionnaire des compétences des agents</b> : L’utilité des agents d’IA dépend directement du contexte dont ils disposent. Si vous ne leur indiquez pas les frameworks, les conventions et les outils utilisés, vous devrez tout réexpliquer dans chaque nouvelle fenêtre de chat.<br />
<br />
Les compétences d’agents corrigent cela. Il suffit de les installer une fois dans PyCharm pour que vos agents utilisent cette connaissance du domaine pour chaque projet et session, automatiquement. Parcourez et gérez les compétences directement depuis l’EDI, enrichissez la bibliothèque intégrée avec des registres externes tels que des référentiels GitHub publics, ou laissez PyCharm importer les compétences que vous avez déjà configurées pour Claude Code ou Codex. <br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7117" target="_blank">Découvrez toutes les nouveautés</a><br />
<br />
:fleche: <a href="https://www.developpez.com/redirect/7118" target="_blank">Téléchargez PyCharm 2026.2</a></div>

]]></content:encoded>
			<category domain="https://www.developpez.net/forums/f2279/environnements-developpement/autres-edi/jetbrains/">JetBrains</category>
			<dc:creator>Jade Emy</dc:creator>
			<guid isPermaLink="true">https://www.developpez.net/forums/d2184795/environnements-developpement/autres-edi/jetbrains/jetbrains-annonce-disponibilite-pycharm-2026-2-a/</guid>
		</item>
	</channel>
</rss>
