Présentation
Les révisions de code sont plus efficaces lorsque vous passez moins de temps sur les détails de l’implémentation mineure, tels que les conventions de nommage et de style, et concentrez plutôt votre effort sur la conception de niveau supérieur, la résolution des problèmes et les fonctionnalités qui répondent aux besoins de l’utilisateur.
Dans cet article, nous allons montrer comment les révisions automatiques de Copilot peuvent vous aider à optimiser votre processus de révision afin de passer moins de temps sur les modifications mineures et plus de temps sur la résolution de problèmes nuances et une compréhension plus approfondie de l’implémentation qui n’est pas simplement adéquate, mais répond avec compétence aux besoins de l’utilisateur.
1. Améliorer la qualité des révisions avec Copilot
Révision du code Copilot peut fournir des révisions automatisées pour toutes les pull requests dans votre référentiel et rendre l’examen plus efficace en interceptant les modifications non souhaitées dans votre code. Lorsqu’elles sont associées à des instructions personnalisées, Révision du code Copilot est plus efficace, car elle peut fournir des réponses adaptées au fonctionnement de votre équipe, aux outils que vous utilisez ou aux spécificités de votre projet.
Les meilleures pratiques pour l’écriture d’instructions personnalisées sont les suivantes :
- Titres distincts
- Puces
- Instructions courtes et directes
Intéressons-nous à un exemple. Si vous créez un système de traitement des commandes à l’aide de Python, vos instructions personnalisées peuvent inclure des pratiques de mise en forme, de performances et de codage sécurisées spécifiques à Python, ainsi que des conseils directement pertinents pour votre projet. L’exemple suivant montre à quoi ressemblent quelques-unes des lignes de vos instructions personnalisées.
## Repository context
- This repository implements an order processing system (order intake, payment, fulfillment) where correctness, security, and auditability are critical.
## Style and conventions
- Follow the PEP 8 and PEP 257 style guide for Python.
- Use clear, domain-relevant names (orders, payments, inventory, customers, shipments).
- Prefer small, focused functions and methods with clearly defined responsibilities.
## Secure coding
- Verify proper input validation and sanitization.
- Review authentication and authorization logic.
## Error handling guidelines
- Handle timeouts and network errors gracefully.
- Ensure failures are logged with enough detail for debugging.
## Order processing context
- Ensure order creation, payment handling, and updates are idempotent to avoid duplicate orders or duplicate charges.
- Validate and normalize all order, payment, and customer data before persisting or acting on it.
- Do not log or persist sensitive data (passwords, raw payment details, full identifiers) without hashing, encryption, or redaction.
- Call out obvious performance issues in core order workflows (e.g., N+1 queries, per-order synchronous network calls) and suggest simpler, more efficient alternatives.
## Review style
- Be concise, specific and actionable.
- Explain the "why" behind recommendations using bullet points.
Dans la section suivante, nous verrons comment nos exemples d'instructions personnalisées peuvent avoir un impact positif sur les commentaires de révision que Copilot fournit pour une demande de tirage.
2. Automatiser les révisions pour traiter les conventions de style et les performances
Lorsque la Révision du code Copilot automatique est activée, Copilot relit automatiquement une demande de tirage dès qu'elle sort du mode brouillon.
Imaginez que vous soumettez une demande de tirage contenant la fonction suivante pour mettre à jour l'inventaire dans votre système de traitement des commandes.
def notify_inventory(product_id, quantity):
requests.post("http://inventory-service/update", json={"product_id": product_id, "quantity": quantity})
Bien que cela soit fonctionnel, il manque de clarté et de robustesse. L’intention des types est implicite, il n’y a pas de docstrings, et elle n’inclut pas la gestion des erreurs ou la journalisation, ce qui rend difficile si la notification a réellement fonctionné.
Copilot examine alors le code et peut formuler le commentaire et la suggestion de code suivants.
Remarque
La réponse suivante est un exemple. Les réponses Discussion avec Copilot ne sont pas déterministes, vous pouvez donc obtenir une réponse différente de celle affichée ici.
Missing error handling for network calls
The notify_inventory function makes a synchronous network call without any error handling for timeouts, connection failures, or non-200 responses.
Why this matters:
- Network failures will cause unhandled exceptions and crash the order processing flow
- Orders could be marked as CONFIRMED but inventory never gets updated
- This violates the requirement to "handle timeouts and network errors gracefully"
- Failures won't be logged with enough detail for debugging
Recommendation: Add proper error handling with timeout and logging:
def notify_inventory(product_id: str, quantity: int) -> bool:
"""Notify the inventory service of order placement.
Args:
product_id: The product identifier.
quantity: The quantity ordered.
Returns:
True if the notification succeeded; False otherwise.
"""
try:
response = requests.post(
"http://inventory-service/update",
json={"product_id": product_id, "quantity": quantity},
timeout=5,
)
response.raise_for_status()
logger.info(
"Inventory notified for product %s, quantity %d (status %d)",
product_id,
quantity,
response.status_code,
)
return True
except requests.exceptions.Timeout:
logger.error(
"Timeout notifying inventory for product %s, quantity %d",
product_id,
quantity,
exc_info=True,
)
except requests.exceptions.RequestException:
logger.error(
"Failed to notify inventory for product %s, quantity %d",
product_id,
quantity,
exc_info=True,
)
return False
La réponse de Copilot suit les recommandations de vos instructions personnalisées dans sa suggestion. Dans cet exemple, il suit les instructions de style PEP 8 et 257 pour Python et suggère une amélioration pour mieux gérer les délais d’expiration et la journalisation des erreurs, tout en expliquant de manière concise le raisonnement derrière les suggestions.
Remarque
Examinez toujours attentivement les suggestions de Copilot avant d’accepter et de valider.
Les commentaires de révision automatique comme ceux-ci vous aident à créer votre propre compréhension lorsque vous codez ou pouvez vous aider à vous concentrer et à affiner les commentaires donnés à d’autres personnes lors de l’examen.
3. Marquer les vulnérabilités de sécurité et les corriger
Ensuite, imaginez que vous avez été chargé d’améliorer la façon dont les mots de passe sont stockés dans votre système de traitement des commandes. Vous soumettez une pull request avec du code qui, selon vous, hachait suffisamment les mots de passe des utilisateurs pour les protéger.
def get_password_hash(password: str, salt: str) -> str:
"""Hash a password with the given salt using SHA-256.
Returns the hexadecimal representation of the hashed password.
"""
return hashlib.sha256((password + salt).encode()).hexdigest()
class User:
"""Represents a user in the order processing system."""
def __init__(self, username: str, password: str, salt: str):
"""Initialize a User with username, password, and salt.
The password is hashed and stored for authentication.
"""
self.username = username
self.salt = salt
self.password_hash = get_password_hash(password, self.salt)
def verify_password(self, password: str) -> bool:
"""Verify a plain-text password against the stored hash."""
return get_password_hash(password, self.salt) == self.password_hash
Toutefois, dans cet exemple, l’utilisation de SHA-256 n’est pas acceptable, car elle n’est pas suffisamment coûteuse pour protéger les mots de passe utilisateur.
Alors que Révision du code Copilot peut proposer des recommandations de bonnes pratiques en matière de sécurité, Correctif automatique Copilot pour code scanning va encore plus loin. En exploitant les fonctionnalités de code scanning avec l'analyse CodeQL pour analyser le code d'un dépôt GitHub et détecter les vulnérabilités de sécurité ainsi que les erreurs de codage, Correctif automatique Copilot peut ensuite proposer des correctifs pour les alertes, vous permettant de prévenir et de réduire les vulnérabilités de manière plus efficace.
Par exemple, Correctif automatique Copilot peut faire le commentaire suivant sur le code.
Using SHA-256 for password hashing is insecure for authentication systems. SHA-256 is designed to be fast, making it vulnerable to brute-force attacks.
To fix the problem, use a password-specific hashing algorithm like bcrypt, scrypt, or argon2 (e.g., `argon2-cffi` from the PyPI package) which are designed to be slow and include built-in salting mechanisms.
Correctif automatique Copilot propose également des suggestions de code pour un correctif potentiel de la vulnérabilité, que vous pourrez examiner. Dans ce cas, il peut faire des suggestions de code, comme celles ci-dessous, pour importer un package et mettre à jour le code lié au hachage du mot de passe.
from argon2 import PasswordHasher
def get_initial_hash(password: str):
ph = PasswordHasher()
return ph.hash(password)
def check_password(password: str, known_hash):
ph = PasswordHasher()
return ph.verify(known_hash, password)
Remarque
- Vérifiez et validez toujours les modifications Copilot suggère avant de les accepter.
- Dans cet exemple, Révision du code Copilot peut également souligner la nécessité de générer des sels uniques.
Comme vous pouvez le voir, l’identification automatique des vulnérabilités, ainsi que les suggestions de résolution de ces vulnérabilités, vous aide à établir une priorité de sécurité. Correctif automatique Copilot vous permet de vous concentrer sur la compréhension du codage sécurisé et sur les correctifs qui fonctionnent le mieux pour votre base de code et votre projet.
Évaluations optimisées avec Copilot
Les commentaires de révision automatique vous aident à optimiser vos révisions et à sécuriser votre code de manière plus efficace, quel que soit votre niveau d’expérience.
- Les instructions personnalisées ont permis d’affiner les réponses de Révision du code Copilot afin qu’elles soient spécifiques à nos besoins de projet et d’utilisateur et nous avons également vu comment nous pouvons adapter la quantité d’explication Copilot fournit des commentaires.
- Révision du code Copilot nous a aidés à améliorer rapidement la journalisation des erreurs et à comprendre pourquoi cela était important.
- Correctif automatique Copilot pour code scanning nous a aidés à éviter l'utilisation d'une méthode de hachage de mot de passe insuffisante et à protéger les données des utilisateurs.
Étapes suivantes
Pour rendre vos révisions plus efficaces et plus efficaces à l’aide des fonctionnalités de révision de Copilot, commencez par suivre ces étapes.
- Créez des instructions personnalisées spécifiques à votre projet et référentiel. Écrivez votre propre fichier ou inspirez-vous de notre bibliothèque d’exemples. Consultez Instructions personnalisées.
- Pour activer la Révision du code Copilot automatique pour votre dépôt, consultez Configuration de la revue automatique du code par GitHub Copilot.
- Pour configurer Correctif automatique Copilot pour votre dépôt, vous devrez activer l'code scanning. Une fois l'code scanning avec l'analyse CodeQL activée, Correctif automatique Copilot est activé par défaut. Pour obtenir la configuration la plus simple, consultez Définition de la configuration par défaut pour l’analyse du code.
Lectures complémentaires
Pour approfondir l’examen du code généré par l’IA, consultez Passer en revue le code généré par l’IA.