Liste de contrôle pour la revue de code par Redwerk – toutes les étapes incluses

Vous êtes-vous déjà demandé si votre fournisseur informatique a bien fait son travail et créé une application de haute qualité ? Il est facile de le vérifier avec une revue de code indépendante. Les revues de code menées par des experts externes apportent une perspective fraîche et impartiale sur la qualité de votre produit. Ils examinent le code uniquement sur le mérite, découvrant des problèmes que les équipes internes pourraient manquer.

Dans cet article, nous partagerons notre checklist complète de revue de code pour un projet web/SaaS afin que vous compreniez chaque étape du processus de revue de code. En tant qu’entreprise de développement logiciel avec plus de 19 ans d’expérience, nous avons effectué d’innombrables revues de code comme pratique quotidienne et dans le cadre d’audits de diligence raisonnable. Nous avons beaucoup à partager, alors allons-y !

Pourquoi utiliser une checklist de revue de code ?

Une checklist de revue de code garantit la cohérence entre les équipes de développement, soutenant à la fois les développeurs expérimentés et les nouveaux membres peu familiers avec les meilleures pratiques de leurs frameworks de programmation.

Avantages clés d'une checklist de revue de code

• Identifier les problèmes rapidement : Cibler les défauts tôt est crucial pour l’amélioration du logiciel. Les checklists permettent de détecter rapidement les problèmes critiques, les empêchant de devenir des problèmes plus importants.
• Maintenir les meilleures pratiques : Une checklist aide les équipes à adhérer aux meilleures pratiques, réduisant la dette technique et améliorant la sécurité, les performances et la maintenabilité. Cela maintient tout le monde aligné sur les objectifs stratégiques.
• Stimuler la collaboration : En établissant des attentes claires pour les discussions sur le code, les checklists améliorent la communication, accélèrent la résolution des problèmes et augmentent la qualité du logiciel.
• Rationaliser les processus : La standardisation des revues réduit le temps consacré aux discussions sur les modifications de code. Une checklist claire permet une identification plus rapide des problèmes et des résolutions rationalisées, améliorant la productivité.

Éléments clés de la revue de code : manuelle et automatisée

Une revue de code complète doit se composer de deux parties : une vérification manuelle et automatique. Une combinaison des deux permet d’atteindre la plus haute qualité et valeur des revues de code.

Lors de la revue manuelle, les aspects généraux suivants sont vérifiés :

• Architecture
• Style et propreté du code
• Noms des classes et variables
• Tests unitaires
• Documentation

Lors de la vérification manuelle, il est nécessaire de s’appuyer sur les meilleures pratiques de revue de code.

La revue automatique utilise des outils qui aident à vérifier le système pour les vulnérabilités, les bibliothèques obsolètes et le code inutilisé en analysant de grandes quantités de données. Toutes les métriques trouvées à l’aide du programme doivent être soigneusement décrites.

Les outils suivants peuvent être utilisés pour la vérification automatique :

• Analyseurs de code statiques pour trouver des bugs potentiels et des vulnérabilités de sécurité dans le code
• Outils de couverture de code pour mesurer la quantité de code exécutée par une suite de tests
• Linters pour repérer les écarts par rapport aux règles de style de codage
• Outils d’automatisation des tests pour exécuter les tests automatiquement

N’oubliez pas que, bien que les outils d’automatisation soient essentiels pour soutenir et améliorer les revues de code professionnelles, ils ne peuvent pas remplacer la pensée critique, le jugement et l’expertise du domaine que les réviseurs humains apportent au processus. Passons maintenant au modèle de revue de code proprement dit.

Notre checklist complète de revue de code

Étapes préliminaires

Il y a plusieurs étapes préliminaires à suivre avant de plonger dans la revue de code elle-même. Elles contribuent à garantir une expérience de revue de code plus ciblée, productive et collaborative pour toutes les personnes impliquées.

Exigences et objectifs du projet :

• Lire la documentation du projet, y compris les exigences, les spécifications et les documents de conception
• Comprendre les objectifs principaux de la revue de code : identifier les problèmes de sécurité, améliorer la qualité du code, garantir le respect des normes de codage, ou autre chose ?
• Déterminer s’il existe des domaines d’intervention ou des préoccupations spécifiques pour la revue

Portée du projet :

• Déterminer si la revue portera sur des modules, fonctionnalités ou fonctions spécifiques du codebase
• Identifier les domaines où des problèmes se sont produits dans le passé ou où la dette technique est connue pour exister
• Pour les projets dans des industries réglementées, s’assurer que les sections pertinentes du code sont revues pour la conformité
• Dans le cas d’audits de sécurité, identifier les composants qui traitent des données sensibles ou qui sont critiques pour la sécurité du système

Configuration de l’environnement :

• S’assurer que vous avez accès au codebase, aux outils de test et à toute documentation pertinente
• Choisir les outils appropriés pour votre processus de revue, tels que des linters de code, des outils d’analyse statique ou des environnements de développement intégrés (IDE)
• Le cas échéant, s’assurer que vous pouvez exécuter et tester le code efficacement

Revue de l'architecture

L’examen architectural fait partie intégrante de notre liste de contrôle de revue de code. Il évalue dans quelle mesure le code respecte les principes de conception du système global et la maintenabilité à long terme. La détection précoce des problèmes architecturaux évite des corrections coûteuses plus tard dans le processus de développement. Il garantit également que le système peut gérer la croissance et fonctionner efficacement sous des charges variables.

Alignement avec les décisions architecturales :

• Vérifier si le code adhère à l’architecture système documentée dans les spécifications
• Vérifier si les modèles architecturaux choisis sont appropriés pour le domaine du problème et les exigences du système

Séparation des préoccupations et modularité :

• Vérifier si le code est divisé en plusieurs couches, telles que la logique métier, l’accès aux données et la présentation, si cela est requis
• Vérifier si le code est divisé en fichiers respectifs, par exemple pour le frontend – HTML, JavaScript et CSS
• Examiner si les modules sont bien définis, cohésifs et faiblement couplés
• S’assurer qu’il n’y a aucun signe de code spaghetti ou de composants étroitement couplés

Principes d’analyse et de conception orientées objet :

• Vérifier si le principe de responsabilité unique (SRP) est suivi : une seule responsabilité doit être placée dans une seule classe ou fonction
• S’assurer que le code adhère au principe ouvert-fermé (OCP) : lors de l’ajout de nouvelles fonctionnalités, celles-ci doivent être écrites dans de nouvelles classes et fonctions ; le code existant ne doit pas être modifié
• Inspecter si le principe de substitution de Liskov (LSP) est observé : la classe enfant ne doit pas modifier le comportement (le sens) de la classe parente ; la classe enfant peut être utilisée comme substitut d’une classe de base
• Examiner la ségrégation des interfaces : les interfaces longues doivent être divisées en plus petites en fonction de leur fonctionnalité. L’interface ne doit contenir aucune dépendance (paramètres) non requise pour la fonctionnalité attendue
• Examiner l’injection de dépendances : les dépendances ne doivent pas être codées en dur mais injectées

Exemple d’une violation du SRP :

public class CustomerManager
{
    public void AddCustomer(Customer customer) { /* Implementation */ }
    public void UpdateCustomer(Customer customer) { /* Implementation */ }
    public Customer GetCustomer(int id) { /* Implementation */ }
    public void SendWelcomeEmail(Customer customer) { /* Implementation */ }
    public void GenerateCustomerReport() { /* Implementation */ }
}

Gestion et stockage des données :

• Vérifiez si les tables sont correctement normalisées pour éliminer la redondance des données, tout en tenant compte de la dénormalisation lorsque la performance est critique.
• Vérifiez l’implémentation des contraintes de base de données, des transactions et des stratégies d’annulation pour gérer les erreurs.
• Examinez les stratégies de sauvegarde et de récupération des données pour garantir leur durabilité.
• Évaluez si les champs fréquemment interrogés sont indexés pour accélérer les opérations de recherche.
• Analysez la gestion des données sensibles, y compris les mécanismes de chiffrement et de contrôle d’accès.

Intégration et interopérabilité :

• Évaluez la conception, la documentation et la gestion des API, en vous assurant qu’elles sont bien définies et qu’elles facilitent une communication sécurisée et fiable.
• Évaluez l’intégration avec les services externes et la gestion des dépendances externes.
• Lorsque cela est applicable, vérifiez si le système prend en charge les formats de données standard pour l’interopérabilité, tels que JSON pour les services Web.
• Évaluez l’utilisation de middlewares ou d’outils d’intégration pour connecter des systèmes disparates.

Évolutivité et performance :

• Vérifiez si l’architecture peut gérer la croissance future attendue en termes d’utilisateurs, de données et de transactions.
• Vérifiez si l’architecture peut évoluer verticalement (ajout de ressources à un seul serveur) et horizontalement (ajout de plusieurs serveurs).
• Vérifiez si les opérations gourmandes en ressources sont déplacées dans des services distincts et appelées via une file d’attente ou un autre mécanisme.
• Vérifiez s’il est possible de déplacer des services distincts vers différentes instances de serveur et s’il est possible d’exécuter plusieurs instances d’un service.
• Examinez les stratégies d’optimisation des performances, y compris la mise en cache, l’équilibrage de charge et le traitement asynchrone, pour garantir que le système peut gérer efficacement les charges de pointe.
• Examinez les mécanismes de repli et de redondance conçus pour maintenir la disponibilité et les performances du système dans des conditions défavorables.

Sécurité :

• Analysez le framework de sécurité de l’application, en veillant à ce qu’il intègre une stratégie de défense multicouche pour se protéger contre divers types de menaces.
• Examinez les mécanismes d’authentification, d’autorisation et d’audit pour confirmer qu’ils sont robustes et conformes aux meilleures pratiques de sécurité.
• Inspectez les protocoles de chiffrement et les mesures de sécurité appliqués aux données en transit et au repos, en vérifiant leur adéquation pour protéger les informations sensibles.

Revue de la qualité du code

Vient ensuite sur notre checklist de revue de code l’évaluation de la qualité du code en termes de lisibilité, maintenabilité, réutilisabilité, fiabilité et extensibilité. Un code clair et bien formaté est plus facile à comprendre et à maintenir, ce qui entraîne moins de bugs, un développement plus rapide et une dette technique réduite. De plus, un style de codage cohérent favorise une meilleure collaboration entre les membres de l’équipe, car chacun peut facilement travailler avec le code des autres.

Méthodes et fonctions :

• Vérifier si les noms des fonctions ont la forme « verbe expressif + objet » pour qu’ils soient concis et faciles à comprendre
• Inspecter si les noms des fonctions décrivent toutes les actions qu’elles effectuent
• Évaluer si la fonction est trop grande et si elle devrait être refactorisée en fonctions plus petites
• Analyser si la fonction ne fait qu’une seule chose, mais la fait bien (principe de responsabilité unique)

Variables :

• Vérifier si chaque variable a un et un seul objectif
• Vérifier si les variables sont nommées selon la convention, telle que camelCase, kebab-case et snake_case
• S’assurer que les noms de variables décrivent pleinement et précisément l’entité représentée
• Vérifier si les noms de variables trouvent un équilibre entre fournir suffisamment d’informations et garder les noms concis
• S’assurer que les noms de variables permettent de comprendre facilement quel type de données elles contiennent
• Vérifier s’il existe des nombres ou des chaînes magiques

Exemple de chaînes magiques :

if (message == "Insufficient funds")
{
    // Handle insufficient funds error
}
else if (message == "Invalid product ID")
{
    // Handle invalid product ID error
}
// ...more logic based on string comparisons

Expressions conditionnelles :

• Vérifiez si les vérifications complexes sont converties en appels de fonctions logiques
• Voyez si les cas les plus probables sont vérifiés en premier. Toutes les options sont-elles prises en compte ?
• Vérifiez s’il existe des fonctions contenant de nombreuses expressions conditionnelles. Y a-t-il une bonne raison de ne pas les redessiner ?

Récursivité :

• Vérifiez si la fonction récursive contient un point de sortie
• Voyez si le cas de base est facile à comprendre et à reconnaître. Les cas de base complexes peuvent masquer la logique globale
• Vérifiez si la profondeur de récursion correspond aux contraintes imposées par la taille de la pile du programme

Maintenabilité des classes/structures :

• Vérifiez si toutes les structures de données ont un objectif central
• Assurez-vous que toutes les structures de données sont bien nommées et que leurs noms décrivent leur objectif central
• Vérifiez si toutes les structures de données sont indépendantes des autres classes et si elles sont faiblement couplées
• Inspectez si toutes les structures de données collaborent avec d’autres classes uniquement lorsque c’est absolument nécessaire
• Vérifiez si toutes les structures de données masquent leurs détails d’implémentation aux autres structures de données autant que nécessaire

Réutilisabilité :

• Assurez-vous que le code suit le principe « Ne vous répétez pas » (DRY) : chaque élément de connaissance doit avoir une représentation unique, sans ambiguïté et faisant autorité au sein d’un programme
• Examinez s’il existe du code dupliqué qui peut être refactorisé en une méthode ou une classe commune
• Vérifiez s’il existe des fonctions ou des méthodes qui effectuent des tâches similaires et qui peuvent être consolidées

Exemple de fonctions pouvant être consolidées en une seule méthode avec un paramètre supplémentaire :

public class CustomerService
{
    public Customer GetCustomerById(int id)
    {
        // Logic to retrieve customer from database by ID
        return customer;
    }

    public Customer GetCustomerByEmail(string email)
    {
        // Logic to retrieve customer from database by email
        return customer;
    }
}

Gestion des erreurs et journalisation :

• Vérifiez si la technique de gestion des erreurs est définie, en spécifiant le format des erreurs (messages, codes d’état) et où envoyer les erreurs (console, fichier, AWS S3)
• Vérifiez si des erreurs sont ignorées quelque part. Par exemple, un bloc « catch » vide signifie que l’erreur est ignorée, ce qui rend le débogage difficile
• Examinez si le code de gestion des erreurs est centralisé dans un seul module qui peut être remplacé si nécessaire
• Vérifiez si trop d’informations sont renvoyées à l’utilisateur et si aucune information sensible comme les chemins système, les détails de la base de données ou les codes d’erreur internes n’est exposée
• Évaluez la mise en œuvre des niveaux de journalisation, tels que DEBUG, INFO, WARN, ERROR, FATAL
• Évaluez les politiques de rotation et d’archivage des journaux pour gérer la taille des fichiers journaux et conserver les données historiques

Exemple de code qui entrave un débogage efficace :

public decimal CalculateAverage(List numbers)
{
    try
    {
        int sum = 0;
        foreach (var number in numbers)
        {
            sum += number;
        }
        return sum / numbers.Count;
    }
    catch (Exception) 
    {
        // Log the error somewhere (omitted for brevity)
        return 0;
    }
}

Bibliothèques tierces :

• Analysez si une bibliothèque particulière est réellement nécessaire
• Vérifiez si la bibliothèque est distribuée sous licence open-source
• Inspectez s’il existe des vulnérabilités connues dans la bibliothèque
• Vérifiez s’il existe des bibliothèques inconnues utilisées, en particulier à la place de celles qui sont populaires et bien soutenues par la communauté
• Vérifiez si les mainteneurs de la bibliothèque et la communauté sont actifs. Est-il facile de les contacter en cas de problème ?
• Examinez si le projet utilise différentes bibliothèques frontend dans différentes sections

Commentaires et documentation :

• Assurez-vous que les commentaires sont significatifs, concis et n’expliquent que le code non évident
• Inspectez la documentation pour sa complétude et sa clarté, en particulier pour les parties du code qui sont complexes ou cruciales
• Confirmez que tous les commentaires et la documentation reflètent la version la plus actuelle de la base de code, en tenant compte des changements ou mises à jour récents

Simplification et refactorisation du code :

• Repérez les opportunités de refactoriser ou de simplifier le code pour réduire la complexité sans perdre de fonctionnalités
• Favorisez la suppression des segments de code superflus ou obsolètes, rendant la base de code plus légère et plus efficace
• Soutenez l’utilisation de modèles de conception et de frameworks reconnus lorsqu’ils sont appropriés pour une compréhension commune entre les développeurs et le respect des meilleures pratiques de l’industrie

Couverture de test et qualité

La couverture des tests garantit que vos efforts de test couvrent autant d’aspects de votre application que possible. Cela inclut la couverture du code, les exigences, la fonctionnalité, la logique métier, les scénarios utilisateur, les performances et la sécurité. Un code non couvert pourrait cacher des bugs critiques. Mais n’oubliez pas qu’une couverture de code élevée n’équivaut pas à une qualité élevée. Examinez la conception, l’exécution et l’efficacité de vos tests pour une véritable excellence logicielle.

Couverture des tests :

• Assurez-vous que la suite de tests couvre toutes les exigences fonctionnelles spécifiées dans la documentation
• Vérifiez que les tests couvrent les conditions limites et les cas d’utilisation extrêmes
• Évaluez l’équilibre entre les tests unitaires et les tests d’intégration : il devrait y avoir un nombre suffisant de tests unitaires pour les composants individuels et de tests d’intégration pour garantir que ces composants fonctionnent ensemble

Documentation et maintenabilité :

• Vérifiez si chaque test a une description claire de ce qu’il teste et du résultat attendu
• Examinez la structure et l’organisation du code de test pour faciliter la maintenance : l’utilisation de fixtures de test, de méthodes de configuration/nettoyage et de tests pilotés par les données
• Assurez-vous que toute documentation associée aux tests, comme les plans de test ou les descriptions de cas de test, est à jour et correspond aux tests réels

Fiabilité et stabilité des tests :

• Vérifiez si les tests produisent des résultats cohérents et ne sont pas instables
• Examinez comment les tests gèrent les systèmes externes ou les dépendances comme les bases de données ou les API
• Vérifiez si les échecs de test indiquent clairement le problème, en renvoyant des messages d’erreur et des journaux pertinents qui identifient la source de l’échec

Performances et efficacité :

• Examinez le temps total nécessaire pour exécuter la suite de tests. Les tests qui prennent trop de temps pourraient être optimisés ou exécutés en parallèle
• Évaluez si les tests sont efficaces en termes d’utilisation de la mémoire et du processeur
• Assurez-vous que la suite de tests peut gérer des charges accrues, ce qui est particulièrement important pour les tests de performances

Sécurité

Imaginez construire une maison sans vérifier les défauts structurels. De même, un code non sécurisé expose votre application aux attaques, compromettant ainsi les données des utilisateurs, l’intégrité du système et la réputation. C’est pourquoi nos directives d’examen du code incluent également une vérification de sécurité.

Authentification et autorisation :

• Examinez si les mots de passe sont stockés de manière sécurisée (hachés et salés)
• Assurez-vous que des politiques de mots de passe robustes sont appliquées, y compris la longueur et la complexité des mots de passe
• Si l’authentification multifacteur est requise pour l’accès privilégié, vérifiez sa présence
• Vérifiez si des contrôles d’autorisation sont présents pour toutes les actions sensibles
• Vérifiez si les principes du moindre privilège sont respectés (octroi des seules autorisations nécessaires)

Validation et assainissement des entrées :

• Vérifiez si toutes les entrées utilisateur, telles que le type, la longueur et les caractères autorisés, sont validées
• Examinez si des techniques d’assainissement de données, d’échappement ou d’encodage sont utilisées pour prévenir les attaques par injection
• Vérifiez si des procédures stockées sont utilisées pour les interactions avec la base de données afin d’éviter la construction manuelle de SQL

Sécurité des données :

• Vérifiez si les éléments de données sensibles sont chiffrés au repos et en transit à l’aide d’algorithmes robustes tels que AES et TLS
• Assurez-vous que des pratiques de gestion sécurisée des clés sont suivies, comme l’utilisation de modules de sécurité matériels pour le stockage et la rotation régulière des clés
• Assurez-vous que l’accès aux données est restreint aux utilisateurs et processus autorisés
• Vérifiez les procédures d’élimination des données, en vous assurant que les données sont écrasées pour empêcher leur récupération non autorisée

Gestion des sessions :

• Analysez la sécurité des identifiants de session pour prévenir le détournement de session. Sont-ils aléatoires et impossibles à deviner ?
• Assurez-vous que les sessions sont invalidées après une période d’inactivité ou une déconnexion
• Vérifiez si des jetons CSRF (Cross-Site Request Forgery) sont implémentés pour prévenir les actions non autorisées
• Vérifiez si des protocoles de communication sécurisés comme HTTPS sont utilisés

Gestion des erreurs et journalisation :

• Vérifiez si des messages d’erreur génériques sont fournis au lieu de traces de pile détaillées exposant des informations internes
• Assurez-vous que les journaux sont stockés en toute sécurité et surveillés pour détecter les activités suspectes, telles que les tentatives de connexion échouées ou les modèles d’accès inhabituels
• Vérifiez si les journaux évitent de stocker des données sensibles comme les mots de passe ou les numéros de carte de crédit

Pratiques de codage sécurisé :

• Vérifiez si les meilleures pratiques de sécurité telles que le OWASP Top 10 sont suivies
• Analysez si les pratiques de gestion de la mémoire sont sécurisées pour prévenir les dépassements de tampon et autres exploits liés à la mémoire
• Vérifiez si des générateurs de nombres aléatoires cryptographiquement sécurisés sont utilisés pour des tâches critiques comme la génération de mots de passe et les jetons de session

Comment améliorer le processus de revue de code

Après avoir maîtrisé quoi vérifier lors d’une revue de code, il est temps d’affiner le processus lui-même. Voici plusieurs stratégies pour élever la qualité de vos revues de code :

• Implémentez un guide de style complet : Au-delà de la résolution des débats de style sur l’espacement ou la nomenclature, un guide de style de code complet à l’échelle de l’organisation devrait englober les meilleures pratiques pour utiliser efficacement les fonctionnalités du langage de programmation.
• Fixez des délais : Établissez des directives claires pour les délais attendus en fonction de la longueur et de la complexité du code, par exemple, visez des revues d’une journée pour les mises à jour standard et accordez plus de temps pour les changements importants.
• Encouragez un dialogue approfondi : Passez de la simple annotation du code à l’interrogation de l’auteur sur ses choix. Posez des questions sur la justification de formats ou de décisions spécifiques pour favoriser un dialogue constructif.
• Promouvez l’unité d’équipe dans les retours : Formulez les critiques dans un contexte collectif, en utilisant des phrases comme « Nous préférons cette méthode car elle améliore la lisibilité ». Évitez les retours accusateurs, ce qui peut aider à maintenir un esprit d’équipe positif.
• Basez les retours sur des principes objectifs : Fournissez des retours basés sur des principes de codage ou des frameworks établis plutôt que sur des préférences personnelles. Cette approche contribue non seulement à maintenir la cohérence, mais aussi à créer un environnement éducatif pour les développeurs.
• Concentrez-vous sur les améliorations à fort impact : Lors de la revue, privilégiez les changements qui améliorent significativement la valeur du projet. Concentrez-vous sur les améliorations critiques plutôt que sur la perfection, en tenant compte des contraintes de temps et de portée du projet.

Notre expérience avec les revues de code

Pour Redwerk, les revues de code sont une démarche très naturelle. Nous revoyons mutuellement le code que nous écrivons lors du développement de solutions logicielles pour nos clients. Mais nous sommes tout aussi heureux d’examiner du code externe et de partager notre expertise pour améliorer ces produits et aider nos collègues développeurs. Voici un aperçu de nos derniers projets de revue de code.

Project Science

Project Science est un logiciel de gestion de devis informatiques développé par Complete Network, un fournisseur leader de services de réseau géré et de support informatique aux États-Unis. Complete Network a engagé Redwerk pour effectuer une revue de code de l’API backend de Project Science.

Nous avons examiné l’architecture, la structure de la base de données et la qualité du code et avons signalé 40 problèmes critiques. Nous avons identifié des opportunités simples pour augmenter les performances de l’application en utilisant la mise en cache Django, la mise en cache des requêtes de base de données et des outils d’accélération Python. Nos développeurs Python ont identifié 50 cas de code inutilisé, de fichiers vides, de fonctions inutilisées, une utilisation excessive de mots réservés Python, et d’autres problèmes de lisibilité et de réutilisabilité.

Avec notre aide, Complete Network a réussi à augmenter la maintenabilité de son code de 80 % et a adopté des pratiques de codage saines pour prévenir des problèmes similaires à l’avenir.

Site Compass

Site Compass est une application de cartographie réseau développée par Reivernet Group, un intégrateur de systèmes réseau basé aux États-Unis, qui gère des réseaux de données complexes pour les secteurs de l’hôtellerie, de l’éducation et du gouvernement. Elle est construite en C# à l’aide d’Uno Platform.

Reivernet Group a fait appel à Redwerk pour obtenir un audit impartial de l’application Site Compass et la préparer à sa sortie officielle. Notre mission comprenait l’examen de l’architecture, de la base de données, de la qualité du backend, de la couverture de code et de la sécurité.

Nous avons signalé des exemples de couplage fort, de classes avec une profondeur d’héritage trop élevée, de méthodes avec trop de paramètres, de types trop volumineux conduisant au phénomène d’objet divin (god object), et plusieurs autres problèmes. Grâce à notre audit, Reivernet Group a pu corriger les problèmes critiques avant de commercialiser le produit, ce qui a abouti à une lisibilité et une maintenabilité du code de 90 %.

Vous avez encore des questions sur l’examen du code ? Faites-nous part de vos besoins, et nous organiserons une consultation gratuite pour vous.

FAQ

Découvrez comment nous avons aidé Complete Network à auditer et pérenniser son API backend et à augmenter sa maintenabilité de 80%

Veuillez saisir votre adresse courriel professionnelle n'est pas un courriel professionnel

Obtenir une étude de cas