GitLab Duo : optimiser les suggestions de code de l'IA

GitLab Duo, notre suite de fonctionnalités alimentées par l'IA, offre une occasion unique d'optimiser vos workflows DevSecOps. Pour en tirer pleinement parti, rien ne vaut la pratique et l'apprentissage collaboratif en situation réelle. Ce tutoriel se concentre sur les suggestions de code de GitLab Duo. Il fournit des conseils et des bonnes pratiques ainsi que quelques bonus (notamment comment combiner les suggestions de code avec nos autres fonctionnalités d'IA pour gagner encore en efficacité). Vous découvrirez également comment l'IA améliore considérablement l'expérience développeur.

Les bonnes pratiques, conseils et exemples présentés dans cet article ont été conçus sur mesure par l'équipe Developer Relations de GitLab. Ils sont intégrés à la documentation dédiée à GitLab Duo ainsi qu'au projet GitLab Duo Prompts associé. N'hésitez pas à ajouter cette page à vos favoris et revenez-y dès que vous en ressentirez le besoin.

Pourquoi utiliser les suggestions de code de GitLab Duo ?

Prenons comme exemple deux scénarios :

1. En tant que développeur senior, vous maîtrisez différents langages de programmation pour pouvoir écrire du nouveau code source, réviser celui de vos pairs, concevoir des architectures résilientes et lancer de nouveaux projets. Cependant, se former sur les nouvelles fonctionnalités des langages de programmation nécessite du temps, des recherches et un réel effort d'adaptation. Alors, comment apprendre rapidement celles qui pourraient rendre votre code encore plus performant ou utiliser les ressources de manière plus durable ?

   • Personnellement, j'ai appris la norme C++03, puis adopté C++11 sans jamais vraiment m'approprier les versions C++14/17/20/23. Entre-temps, de nouveaux langages tels que Rust sont apparus, et ils offrent une expérience développeur bien plus moderne. Que faire dans ce contexte ?

2. En tant qu'ingénieur junior, il peut être difficile d'appréhender de nouveaux projets, d'apprendre un nouveau langage de programmation, de comprendre certains algorithmes spécifiques et de trouver la documentation sur les structures, les interfaces et d'autres composants techniques. Le tout, souvent sous pression, ce qui augmente le risque d'erreurs et entraîne des blocages. Le temps manque pour se pencher sur les bonnes pratiques.

   • Moi-même, je n'ai jamais réellement appris le développement frontend. J'ai quelques notions en HTML, CSS et JavaScript acquises en autodidacte. Et après dix ans, j'ai du mal à m'adapter à des frameworks frontend tels que VueJS. Et le temps pour apprendre se fait rare.

Ces scénarios illustrent à quel point il est difficile de suivre l'évolution constante des langages de programmation, bonnes pratiques et autres informations importantes. Mais les suggestions de code de GitLab Duo peuvent vous aider : elles prédisent et complètent vos blocs de code, définissent la logique de vos fonctions, génèrent des tests automatisés et proposent du code courant, comme des motifs regex, le tout directement dans votre environnement de développement. Alimentée par l'IA, cette fonctionnalité vous aide à approfondir vos connaissances sans quitter votre workflow.

Commencer avec des prompts simples, puis les affiner

J'ai commencé mon parcours d'adoption de GitLab Duo par des prompts simples tenant sur une ligne, souvent avec des résultats peu convaincants.

# Generate a webserver

// Create a database backend

/* Use multi-threaded data access here */

Après avoir testé différents contextes et styles de rédaction de prompts, j'ai rapidement constaté que la génération de code était beaucoup plus pertinente à partir de requêtes affinées.

# Generate a webserver, using the Flask framework. Implement the / URL endpoint with example output.

// Create a database backend. Abstract data handlers and SQL queries into function calls.

/* Use multi-threaded data access here. Create a shared locked resource, and focus on supporting Linux pthreads. */

Cependant, les prompts et commentaires seuls ne suffisent pas. Explorons d'autres bonnes pratiques.

Pratiquer continuellement

Dans vos workflows quotidiens, identifiez des cas d'utilisation et des défis spécifiques, et utilisez exclusivement GitLab Duo pour les traiter. Bien qu'il soit tentant d'ouvrir des onglets de recherche dans votre navigateur, vous pouvez souvent résoudre le problème directement dans votre IDE avec GitLab Duo. Voici quelques exemples :

1. Corrigez des dépendances manquantes, souvent responsables d'échecs lors de la compilation ou de l'exécution.
2. Laissez les suggestions de code compléter automatiquement les appels de fonction lorsque le contexte de journalisation est manquant, y compris les instructions print.
3. Générez des méthodes et des attributs courants pour les design patterns orientés objet (par exemple, les accesseurs/mutateurs getter/setter, les méthodes toString(), les opérateurs de comparaison d'objets, l'héritage d'objets, et bien plus encore).
4. Identifiez la fonction à l'origine de plantages aléatoires et implémentez-en une nouvelle avec un algorithme différent à l'aide des suggestions de code.
5. En cas d'erreur cryptique empêchant la compilation ou l'exécution, demandez à GitLab Duo Chat de vous aider.
6. Analysez le code (hérité) existant et les stratégies pour documenter et refactoriser le code vers des bibliothèques modernes. Lancez une version v2 de l'application avec un nouveau framework ou langage afin de réduire la dette technique.
7. Prévenez les problèmes d'opérations et de sécurité dans l'historique Git en les détectant en amont (performances, plantages, failles de sécurité).

Enfin, pensez à la tâche de codage la plus ennuyeuse (voire celle que vous détestez le plus) et ajoutez-la à cette liste. Personnellement, je redoute les tâches impliquant les accesseurs/mutateurs getter/setter d'attributs dans les classes C++ (comme le montre la vidéo ci-dessous), juste avant les expressions régulières d'analyse du format des adresses e-mail.

Structurer la requête comme une histoire

La génération de code est un art. Formulez votre demande sous forme d'une histoire et GitLab Duo, alimenté par l'IA, pourra vous aider.

L'exemple suivant vise à implémenter un magasin clé-valeur en mémoire en Go, à la manière de Redis. Commencez par rédiger un commentaire descriptif, puis passez à la ligne suivante et appuyez sur Entrée pour déclencher les suggestions de code.

// Create an in-memory key value store, similar to Redis 
// Provide methods to
// set/unset keys
// update values
// list/print with filters

Soyez explicite et précisez : quelles sont les méthodes nécessaires pour manipuler les données ? Demandez aux suggestions de code de générer des méthodes pour définir des clés, mettre à jour des valeurs et répertorier toutes les données stockées.

// Create an in-memory key value store, similar to Redis 
// Provide methods to
// set/unset keys
// update values
// list/print with filters

Acceptez les suggestions à l'aide de la touche Tab. Ensuite, demandez aux suggestions de code de créer une fonction main accompagnée de code de test.

// Create a main function and show how the code works

Si les données de test ne suffisent pas, affinez le code généré en vous concentrant sur les scénarios de test extrêmes.

Astuce : vous pouvez utiliser la même méthode pour affiner les prompts et générer des tests avec GitLab Duo Chat via /tests focus on extreme test cases.

// Add more random test data, focus on extreme test cases

L'exemple complet, y compris les dépendances corrigées, se trouve dans le projet gitlab-duo-prompts dans le répertoire code-suggestions/go/key-value-store. Mettez à jour le fichier main.go, puis compilez et exécutez le code à l'aide de la commande suivante :

go build
./key-value-store

Cette première itération consiste à créer un binaire autonome et à tester différentes stratégies de mise en œuvre pour les magasins clé-valeur. Validez le code fonctionnel et passez à l'étape suivante de votre parcours d'adoption de GitLab Duo.

Astuce : les nouveaux projets tirent parti de la génération de code, mais requièrent de la pratique et des techniques avancées pour exploiter efficacement les commentaires de code en tant que prompts. Cette approche peut aussi optimiser les workflows des développeurs expérimentés. Les études de faisabilité, l'intégration de nouvelles bibliothèques ou les itérations ne sont pas toujours compatibles avec le framework ou le projet existant. Les développeurs expérimentés optent alors pour créer des projets temporaires en isolant ou simplifiant la portée de certaines fonctionnalités, par exemple, pour tester une nouvelle couche backend de base de données en comparant ses performances à celles de l'environnement de production. Ou pour remplacer une bibliothèque présentant des failles de sécurité ou des problèmes de licence par une alternative plus sûre ou une fonctionnalité intégrée au code.

Accélérer les itérations avec la génération de code

Comme le dirait un développeur expérimenté : « Il existe forcément déjà une bibliothèque clé-valeur en Go, alors inutile de réinventer la roue. » Heureusement, Go est un langage de programmation mature doté d'un écosystème riche. Des projets comme la collection awesome-go — par exemple avelino/awesome-go — recensent de nombreuses bibliothèques d'exemples, ce qui facilite grandement la recherche de solutions existantes. Remarque : cette option n'est pas forcément applicable à tous les langages de programmation et doit être évaluée au cas par cas.

Vous pouvez également poser la question à GitLab Duo Chat : Quelles bibliothèques Go utiliser pour un stockage clé-valeur ?:

Ensuite, affinez le prompt des suggestions de code pour utiliser spécifiquement les bibliothèques suggérées, par exemple BoltDB.

// Create an in-memory key value store, similar to Redis 
// Provide methods to
// set/unset keys
// update values
// list/print with filters
+// Use BoltDB as external library

Répétez le schéma ci-dessus : générez les fonctions du code, demandez à GitLab Duo de créer une fonction « main » avec des données de test, puis compilez le code. La principale différence réside dans les bibliothèques externes, qui doivent d'abord faire l'objet d'un pull à l'aide de la commande go get.

go get
go build

En cas d'échec de la compilation due à des dépendances manquantes, comme fmt, profitez-en pour vous entraîner à nouveau avec GitLab Duo : placez le curseur sur l'instruction import et attendez la suggestion ajoute les dépendances nécessaires. Vous pouvez ajouter un commentaire tel que Import all libraries.

Vous pouvez également enrichir les tests avec de nouvelles données afin de vérifier le comportement des fonctions : // Add more random test data, focus on extreme test cases. Dans l'exemple suivant, une clé vide provoque un arrêt brutal du programme.

Cet exemple est une excellente préparation pour les scénarios de test ultérieurs.

Appliquer la génération de code à des cas concrets : observabilité cloud-native

Imaginez une application cliente en Go, chargée de répertorier l'état des conteneurs, pods et services dans un cluster Kubernetes, comme la ligne de commande kubectl get pods. Le projet Kubernetes fournit des bibliothèques Go permettant d'interagir par programmation avec les API, les interfaces et les structures d'objets Kubernetes.

Ouvrez votre IDE et créez un nouveau projet Go.

Astuce : vous pouvez demander à GitLab Duo Chat de vous expliquer la procédure à suivre avec ce prompt : How to start a Go project? Please show CLI command examples.

Commencez par rédiger un commentaire simple en haut du fichier main.go qui décrit l'objectif de l'application : observabilité dans Kubernetes.

// Create a client for Kubernetes observability

Réfléchissez aux principales exigences : accéder à Kubernetes, définir un contexte et un espace de nommage, et inspecter l'état des ressources. En outre, demandez aux suggestions de code d'importer les paquets nécessaires et de créer un paquet « main » dans le fichier main.go.

Première itération :

// Create a client for Kubernetes observability
// Inspect container, pod, service status and print an overview

Vous pourriez obtenir des résultats inattendus, comme le codage en dur des identifiants d'accès, des contextes manquants ou l'échec de la compilation.

Deuxième itération :

// Create a client for Kubernetes observability
// Create a function that
// Read the kubernetes configuration file from the KUBECONFIG env var
// Inspect container, pod, service status and print an overview

L'absence de contextes ou d'espaces de nommage Kubernetes connus peut entraîner l'échec de la compilation ou des comportements inattendus.

Troisième itération :

// Create a client for Kubernetes observability
// Create a function that
// Read the kubernetes configuration file from the KUBECONFIG env var
// Create kubernetes context, namespace default
// Inspect container, pod, service status and print an overview

Cet exemple code en dur le contexte Kubernetes et l'espace de nommage par défaut pour générer une base initiale. Les itérations ultérieures peuvent lire la valeur de l'espace de nommage à partir d'un paramètre de ligne de commande ou d'un fichier de configuration.

Le dernier exemple peut ressembler à ce qui suit. En plus de la fonctionnalité de l'application, il demande également aux suggestions de code d'importer toutes les dépendances et de générer le paquet main dans main.go.

// Create a client for Kubernetes observability
// Create a function that
// Read the kubernetes configuration file from the KUBECONFIG env var
// Create kubernetes context, namespace default
// Inspect container, pod, service status and print an overview
// Import necessary packages
// Create main package

package main

import (
	"context"
	"fmt"
	"os"

	"k8s.io/client-go/kubernetes"
	"k8s.io/client-go/tools/clientcmd"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func main() {
	kubeconfig := os.Getenv("KUBECONFIG")
	config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
	if err != nil {
		panic(err)
	}

	clientset, err := kubernetes.NewForConfig(config)
	if err != nil {
		panic(err)
	}

	pods, err := clientset.CoreV1().Pods("").List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		panic(err)
	}
	fmt.Printf("There are %d pods in the cluster
", len(pods.Items))

	// Additional code to inspect services, containers, etc
}

Exemple de données de sortie :

Exercice asynchrone : complétez le projet avec du code pour vérifier les services, les conteneurs, etc., puis exportez les résultats vers OpenTelemetry.

Astuce : entraînez-vous avec les cas d'utilisation de GitLab Duo : utilisez les prompts de génération de code dans la documentation ou envoyez des merge requests contenant vos propres prompts fonctionnels.

Alors que nous enregistrions une courte démonstration vidéo illustrant la génération de code, une variante plus aboutie du code a été générée. N'hésitez pas à comparer les différences dans cette validation et tirer parti des deux versions.

Tirer parti de toutes les fonctionnalités de GitLab Duo

Combiner GitLab Duo Chat avec les suggestions de code

Utilisées avec GitLab Duo Chat, les suggestions de code deviennent encore plus efficaces. Le workflow suivant illustre l'efficacité de cette synergie entre IA et développement logiciel :

Écrivez et générez du code à l'aide des suggestions de code. Le code source sera ensuite vérifié par le biais de l'automatisation CI/CD, de tests de qualité du code et d'un scanning de sécurité. Mais qu'en est-il des connaissances du développeur ?

1. Dans votre IDE, sélectionnez les portions de code générées et utilisez la commande slash /explain dans le prompt de GitLab Duo Chat. Vous pouvez même affiner le prompt en ajoutant /explain with focus on algorithms ou d'autres domaines utiles pour une explication centrée spécifiquement sur les problèmes de sécurité potentiels ou de performance, etc.

   • Continuez à écrire et à maintenir votre code, mais gardez à l'esprit qu'à un certain stade, la qualité peut se dégrader et rendre la refactorisation plus complexe. Demandez de l'aide à GitLab Duo Chat.

2. Dans votre IDE, sélectionnez le code source concerné et utilisez la commande slash /refactor dans le prompt de GitLab Duo Chat. Là encore, vous pouvez affiner le prompt pour cibler des design patterns spécifiques (fonctions, classes orientées objet, etc.), comme /refactor into testable functions._

   • Après avoir rendu le code plus lisible, vous devez rédiger des tests. Quels sont les scénarios extrêmes ou les exemples de données aléatoires à utiliser pour les tests unitaires ? Ce type de recherche et la mise en œuvre dans différents frameworks peuvent prendre du temps.

3. Dans votre IDE, sélectionnez le code source et utilisez la commande slash /tests dans le prompt de GitLab Duo Chat. Vous pouvez affiner le prompt pour vous concentrer sur des frameworks de test, des scénarios, des méthodes fondées sur les données d'entrée spécifiques, etc.

   • Une fois la qualité du code et la couverture des tests assurées, vous pouvez à nouveau vous concentrer sur l'optimisation de vos workflows DevSecOps avec les suggestions de code.

Découvrez d'autres scénarios dans la documentation présentant les cas d'utilisation de GitLab Duo.

Générer des configurations de compilation avec GitLab Duo Chat

Les recherches nécessaires au démarrage d'un nouveau projet sont souvent fastidieuses. Entre les multiples approches possibles et les frameworks alternatifs, il est facile de se retrouver avec une charge de travail bien plus importante que prévue. Certains langages modernes comme Rust imposent une approche unifiée avec un seul outil (Cargo), tandis que d'autres comme Java ou C++ proposent plusieurs méthodes avec des langages de configuration supplémentaires comme Kotlin DSL ou CMake DSL, etc.

Avec GitLab Duo, demandez comment démarrer un projet, générez des configurations adaptées à vos outils de compilation (p. ex. Please show a gradle.build example for Spring Boot), et accélérez les premières étapes de développement, de compilation et de test du code source. Voici quelques exemples de prompts utiles :

1. Java, Gradle, Spring Boot : Please show a gradle.build example for Spring Boot
2. C++, CMake, clang : Please show a basic CMake configuration file for C++17, using clang as compiler.
3. Python : Please show how to initialize and configure a Python project on the CLI
4. Rust : Please show how to initialize and configure a Rust project., suivi d'une question pour affiner le prompt telle que : Explain the structure of Cargo.toml.
5. Golang : Please show how to initialize and configure a Go project.

Demander des explications sur les vulnérabilités à GitLab Duo Chat

Supposons qu'un code PHP a été généré pour créer un formulaire web. Il peut présenter des failles de sécurité potentielles.

<?php 
// Create a feedback form for user name, email, and comments
// Render a HTML form

$name = $_POST['name'];
$email = $_POST['email'];
$comments = $_POST['comments'];

echo '<form method="post">';
echo '<label for="name">Name:</label>';
echo '<input type="text" id="name" name="name">';

echo '<label for="email">Email:</label>';
echo '<input type="email" id="email" name="email">';

echo '<label for="comments">Comments:</label>';
echo '<textarea id="comments" name="comments"></textarea>';

echo '<input type="submit" value="Submit">'; 
echo '</form>';

?>

Sélectionnez-le dans votre IDE, puis demandez à GitLab Duo Chat d'expliquer le problème, en utilisant un prompt affiné tel que /explain why this code is vulnerable to bad security actors

Astuce : les vérifications et l'apprentissage s'effectuent dans l'environnement de développement local, ce qui permet d'identifier et de corriger les vulnérabilités en amont, avant même que le code ne fasse l'objet d'un push et qu'une merge request ne déclenche un scanning de sécurité capable d'identifier et de tracer les failles. Mieux comprendre les failles de sécurité contribue à améliorer l'expérience développeur.

Combiner la résolution des vulnérabilités avec les suggestions de code

Prenons un nouvel exemple avec une vulnérabilité simulée, et voyons si les suggestions de code peuvent nous aider à la corriger efficacement. Le projet associé a été préconfiguré avec un test statique de sécurité des applications (SAST). Vous pouvez suivre ces étapes pour configurer le SAST GitLab à l'aide du composant SAST CI/CD du fichier de configuration CI/CD .gitlab-ci.yml.

include:
  # Security: SAST (for vulnerability resolution)
  - component: gitlab.com/components/sast/[email protected]

Après avoir examiné le tableau de bord et les détails de la vulnérabilité, vous pouvez utiliser la fonctionnalité d'explication des vulnérabilités pour mieux comprendre le contexte et les risques potentiels. La fonctionnalité de résolution des vulnérabilités, quant à elle, génère une merge request contenant une proposition de correction du code source pour la faille de sécurité détectée.

Parfois, il peut être nécessaire d'affiner le code suggéré. Accédez alors à la MR générée, puis copiez le chemin d'accès de la branche Git pour exécuter la commande git fetch en local, ou ouvrez directement le Web IDE à partir du bouton Edit pour continuer dans le navigateur. Accédez aux sections du code source contenant les correctifs et modifiez-les si besoin en ajoutant un commentaire :

// refactor using safe buffers, null byte termination

Vous pouvez également ouvrir GitLab Duo Chat, sélectionner le code source et utiliser la commande slash /refactor.

Découvrez un exemple complet dans la documentation présentant les cas d'utilisation de GitLab Duo.

Voici un enregistrement de cet exemple :

Conseils supplémentaires

Vérifier la qualité et la sécurité du code

La génération accrue de code implique davantage d'efforts en matière de qualité, de tests et de sécurité. Profitez de toutes les fonctionnalités qu'offre une plateforme DevSecOps complète :

1. Composants CI/CD et efficacité des pipelines
2. Qualité du code
3. Couverture des tests
4. Sécurité applicative
5. Observabilité

Apprendre en équipe et comprendre l'impact de l'IA

Organisez des sessions collaboratives ciblées pour tester et itérer et enregistrez-les afin que d'autres équipes puissent s'en inspirer par la suite. Vous pouvez également suivre la playlist GitLab Duo Coffee Chat sur YouTube.

Découvrez les indicateurs d'impact de l'IA dans nos articles, notamment celui intitulé Utiliser l'IA générative dans votre environnement DevSecOps et GitLab Duo : mesurer le ROI de l’IA avec le tableau de bord d'analyse d'impact. Consultez notre page dédiée au Centre pour la transparence de l'IA pour en savoir plus sur l'utilisation des données, la transparence et l'éthique de l'IA chez GitLab.

Adopter une vision à long terme du développement

Les suggestions de code peuvent parfois prendre plus de temps à charger que les fonctionnalités d'auto-complétion locales. Mettez à profit ce temps pour réfléchir à l'algorithme ou au problème que vous essayez de résoudre. Prendre un moment de recul permet de faire émerger des idées plus claires. Ou bien profitez-en pour savourer une gorgée de votre boisson préférée, puis reprenez le travail avec un regard neuf.

Certains algorithmes sont particulièrement complexes ou nécessitent des dépendances de code qui ne peuvent pas être résolues par auto-complétion. Le code propriétaire ou confidentiel offre souvent moins de contexte exploitable aux grands modèles de langage. Il peut donc être utile d'enrichir les commentaires pour améliorer la qualité des suggestions de code. Avancez à votre propre rythme et selon votre propre stratégie, et utilisez les suggestions de code là où elles apportent le plus de valeur, notamment pour générer des modèles standards ou des fonctions d'assistance.

Astuce : découvrez Repository X-Ray pour obtenir davantage de contexte sur les suggestions de code et tester des fonctionnalités expérimentales, par exemple, la prise en charge élargie à d'autres langages dans VS Code. Vous trouverez plus d'informations dans l'epic pour dédiée à l'amélioration du taux d'acceptation des suggestions de code.

Comment contribuer à GitLab Duo

Utilisez GitLab Duo pour contribuer à des projets open source en tirant parti des suggestions de code, de la refactorisation du code, de la génération de tests et de la documentation automatisée avec des explications claires sur le fonctionnement du code.

Les clients de GitLab peuvent également co-créer la plateforme GitLab à l'aide de GitLab Duo. Suivez les directives récentes concernant les contributions générées par l'IA et regardez cet exemple issu des sessions GitLab Duo Coffee Chat : Contribuer à GitLab à l'aide des suggestions de code et de GitLab Duo Chat :

Comment partager vos retours

GitLab Duo optimise les workflows de développement grâce à ses suggestions de code, mais une adoption efficace passe par des exercices concrets : tutoriels, ateliers en équipe et sessions de formation guidée. L'automatisation des workflows, l'amélioration de la qualité du code, l'ajout de scanning de sécurité et la mesure de l'observabilité permettent de relever les défis posés par l'introduction fréquente de nouveau code. Tirer pleinement parti de toutes les fonctionnalités de GitLab Duo, y compris GitLab Duo Chat, renforce considérablement l'expérience développeur sur la plateforme DevSecOps la plus complète alimentée par l'IA.

Pour bien commencer, suivez les bonnes pratiques de ce tutoriel, consultez la documentation de GitLab Duo et sollicitez nos équipes pour organiser des ateliers GitLab Duo dédiés à l'IA (j'ai déjà assisté à des ateliers clients, et je vous les recommande vivement !). N'hésitez pas à partager vos retours sur les suggestions de code dans ce ticket, en incluant des captures d'écran et des vidéos (si possible).

Inscrivez-vous à un essai gratuit de GitLab Duo dès aujourd'hui !