Meilleures pratiques de codage – Wikipedia – Bien choisir son serveur d impression

Meilleures pratiques de codage sont un ensemble de règles informelles apprises au fil du temps par la communauté du développement logiciel, qui peuvent aider à améliorer la qualité du logiciel.[1] De nombreux programmes informatiques restent utilisés beaucoup plus longtemps que les auteurs initiaux n’avaient jamais envisagé (parfois 40 ans ou plus),[2] toutes les règles doivent donc faciliter à la fois le développement initial et la maintenance et l'amélioration ultérieures par des personnes autres que les auteurs d'origine.

En règle quatre-vingt-dix-dix, Tom Cargill attribue cette explication à la raison pour laquelle les projets de programmation ont souvent du retard: "90% du code représente 90% du temps de développement. Les 10% restants représentent l'autre 90% du temps de développement ". Toute orientation permettant de remédier à ce manque de prévoyance mérite d’être examinée.

La taille d'un projet ou d'un programme a un effet significatif sur les taux d'erreur, la productivité du programmeur et la quantité de gestion requise.[3] La qualité du logiciel[[[[modifier] Comme indiqué ci-dessous, de nombreux attributs sont associés à un bon logiciel. Certaines d'entre elles peuvent être contradictoires (par exemple, vérification très rapide par rapport à une vérification d'erreur complète) et différents clients et participants peuvent avoir des priorités différentes. Weinberg montre comment différents objectifs peuvent avoir un effet considérable sur l’effort requis et sur l’efficacité.[4] En outre, il note que les programmeurs viseront généralement à atteindre les objectifs explicites éventuellement définis, probablement au détriment de tout autre attribut de qualité.

Sommerville a identifié quatre attributs généralisés qui ne concernent pas le fonctionnement d'un programme, mais son efficacité:[5] Weinberg a identifié quatre objectifs qu’un bon programme devrait atteindre:[6]

Un programme respecte-t-il ses spécifications? "sortie correcte pour chaque entrée possible"? Le programme est-il produit dans les délais (et dans les limites du budget)? Dans quelle mesure le programme est-il adaptable pour faire face aux exigences changeantes? Le programme est-il suffisamment efficace pour l'environnement dans lequel il est utilisé?

Hoare a identifié 17 objectifs liés à la qualité du logiciel, notamment:[7]

Définition claire du but. Simplicité d'utilisation. Robustesse (difficile à utiliser, gentil avec les erreurs). Disponibilité rapide (livrée à temps en cas de besoin). Fiabilité. Extensibilité à la lumière de l'expérience. Brièveté. Efficacité (assez rapide pour le but pour lequel il est mis). Coût minimum à développer. Conformité à toutes les normes pertinentes. Documents utilisateur clairs, précis et précis.

Conditions préalables[[[[modifier] Avant de commencer le codage, il est important de s’assurer que toutes les conditions préalables requises ont été remplies (ou ont au moins progressé suffisamment loin pour fournir une base solide pour le codage). Si les différentes conditions préalables ne sont pas satisfaites, le logiciel risque de ne pas être satisfaisant, même s'il est terminé.

De Meek & Heath: "Ce qui se passe avant d'arriver au stade de la codification est souvent d'une importance cruciale pour la réussite du projet."[8] Les conditions préalables décrites ci-dessous couvrent des sujets tels que:

Comment le développement est-il structuré? (cycle de la vie) qu'est-ce que le logiciel est censé faire? (exigences) la structure globale du logiciel (architecture) conception plus détaillée des composants individuels (conception) choix du ou des langages de programmation

Pour les petits projets simples impliquant une seule personne, il peut être faisable de combiner architecture et design et d'adopter un cycle de vie très simple.

Cycle de la vie[[[[modifier] Une méthodologie de développement logiciel est un cadre utilisé pour structurer, planifier et contrôler le cycle de vie d'un produit logiciel. Les méthodologies courantes incluent la cascade, le prototypage, le développement itératif et incrémental, le développement en spirale, le développement de logiciels agiles, le développement rapide d'applications et la programmation extrême.

Le modèle en cascade est une approche de développement séquentiel; en particulier, cela suppose que les exigences puissent être complètement définies au début d'un projet. Cependant, McConnell cite trois études qui indiquent qu'en moyenne, les besoins changent d'environ 25% au cours d'un projet.[9] Les autres méthodes mentionnées ci-dessus tentent toutes de réduire l'impact de ces modifications d'exigences, souvent par une forme d'approche progressive, incrémentielle ou itérative. Différentes méthodologies peuvent être appropriées pour différents environnements de développement.

Exigences[[[[modifier] McConnell déclare: "La première condition préalable que vous devez remplir avant de commencer la construction est un énoncé clair du problème que le système est censé résoudre."[10] Meek et Heath soulignent qu'une cible écrite claire, complète, précise et non ambiguë est l'objectif à atteindre.[11] Notez qu'il peut ne pas être possible d'atteindre cet objectif et que celui-ci est susceptible de changer de toute façon (comme indiqué dans la section précédente).

Sommerville distingue les exigences moins détaillées des utilisateurs des exigences système plus détaillées.[12] Il fait également la distinction entre les exigences fonctionnelles (par exemple, mettre à jour un enregistrement) et les exigences non fonctionnelles (par exemple, le temps de réponse doit être inférieur à 1 seconde).

Architecture[[[[modifier] Hoare souligne: "Il existe deux manières de concevoir un logiciel: l’une est de le rendre si simple qu’il existe évidemment pas de carences; l’autre façon est de le rendre si compliqué qu’il n’existe pas de évident carences. La première méthode est bien plus difficile."[13] L'architecture logicielle consiste à décider de ce qui doit être fait et du composant du programme qui va le faire (la façon dont quelque chose est fait est laissée à la phase de conception détaillée, ci-dessous). Ceci est particulièrement important lorsqu'un logiciel contient plus d'un programme, car il définit efficacement l'interface entre ces différents programmes. Il convient également de prendre en compte les interfaces utilisateur sans entrer dans les détails.

Toutes les exigences système non fonctionnelles (temps de réponse, fiabilité, maintenabilité, etc.) doivent être prises en compte à ce stade.[14] L'architecture logicielle intéresse également divers acteurs (sponsors, utilisateurs finaux, etc.) dans la mesure où elle leur permet de vérifier que leurs exigences peuvent être satisfaites.

Conception[[[[modifier] Le but principal du design est de compléter les détails qui ont été passés sous silence dans la conception architecturale. L'intention est que la conception soit suffisamment détaillée pour fournir un bon guide pour le codage réel, y compris les détails de tout algorithme particulier à utiliser. Par exemple, au niveau de l'architecture, il a peut-être été noté que certaines données doivent être triées, alors qu'au niveau de la conception, il est nécessaire de décider quel algorithme de tri doit être utilisé. Comme autre exemple, si une approche orientée objet est utilisée, les détails des objets doivent être déterminés (attributs et méthodes).

Choix de langage (s) de programmation[[[[modifier] Mayer déclare: "Aucun langage de programmation n'est parfait. Il n'y a même pas un seul meilleur langage; il n'y a que des langages bien adaptés ou peut-être mal adaptés à des objectifs particuliers. Comprendre le problème et les exigences de programmation associées est nécessaire pour choisir le langage le mieux adapté au Solution."[15] De Meek & Heath: "L’essence de l’art de choisir une langue est de commencer par le problème, de décider quelles sont ses exigences et leur importance relative, car il sera probablement impossible de les satisfaire toutes aussi bien. Les langues disponibles être comparés à la liste des besoins et choisir le plus approprié (ou le moins insatisfaisant). "[16] Il est possible que différents langages de programmation soient appropriés pour différents aspects du problème. Si les langues ou leurs compilateurs le permettent, il sera peut-être possible de mélanger des routines écrites dans différentes langues au sein du même programme.

Même s’il n’ya pas de choix quant au langage de programmation à utiliser, McConnell fournit quelques conseils: "Chaque langage de programmation a ses forces et ses faiblesses. Soyez conscient des forces et des faiblesses spécifiques du langage que vous utilisez."[17] Normes de codage[[[[modifier] Cette section est également une condition préalable à la programmation, comme le souligne McConnell: "Établissez des conventions de programmation avant de commencer à programmer. Il est presque impossible de modifier le code pour les faire correspondre ultérieurement."[18] Comme indiqué à la fin des conventions de codage, il existe différentes conventions pour différents langages de programmation. Il peut donc être contre-productif d'appliquer les mêmes conventions dans différents langages.

L'utilisation de conventions de codage est particulièrement importante lorsqu'un projet implique plusieurs programmeurs (il y a eu des projets avec des milliers de programmeurs). Il est beaucoup plus facile pour un programmeur de lire du code écrit par quelqu'un d'autre si tout le code suit les mêmes conventions.

Pour quelques exemples de mauvaises conventions de codage, Roedy Green fournit un long article (qui va bien) sur la façon de produire du code intempestif.[19] [[[[modifier] En raison de contraintes de temps ou de programmeurs enthousiastes qui veulent des résultats immédiats pour leur code, les commentaires de code passent souvent au second plan. Les programmeurs travaillant en équipe ont jugé préférable de laisser des commentaires car le codage suit généralement des cycles, ou plusieurs personnes peuvent travailler sur un module particulier. Cependant, certains commentaires peuvent réduire le coût du transfert de connaissances entre développeurs travaillant sur le même module.

Aux débuts de l'informatique, l'une des pratiques de commentaires consistait à laisser une brève description de ce qui suit:

Nom du module But du module Description du module Auteur original Modifications Les auteurs qui ont modifié le code avec une description de la raison de sa modification.

La "description du module" devrait être aussi brève que possible, sans toutefois sacrifier la clarté et l'exhaustivité.

Cependant, l’avènement des systèmes de contrôle des révisions a rendu les deux derniers éléments obsolètes. Les modifications et leur auteur peuvent être suivis de manière fiable en utilisant de tels outils plutôt qu'en utilisant des commentaires.

En outre, si une logique compliquée est utilisée, il est judicieux de laisser un commentaire "bloc" à proximité de cette partie afin qu'un autre programmeur puisse comprendre ce qui se passe exactement.

Les tests unitaires peuvent être un autre moyen de montrer comment le code doit être utilisé.

Conventions de nommage[[[[modifier] L'utilisation de conventions de dénomination appropriées est considérée comme une bonne pratique. Parfois, les programmeurs ont tendance à utiliser X1, Y1, etc. en tant que variables et oublient de les remplacer par des variables significatives, ce qui crée de la confusion.

Pour éviter cette perte de temps, il est généralement considéré comme une bonne pratique d’utiliser des noms descriptifs dans le code car il s’agit de données réelles.

Exemple: une variable permettant de prendre du poids en tant que paramètre pour un camion peut être nommée TrkWeight ou TruckWeightKilogram, TruckWeightKilogram étant la plus préférable, car elle est immédiatement reconnaissable. Voir Nom de variables CamelCase.

Gardez le code simple[[[[modifier] Le code écrit par un programmeur doit être simple. Une logique compliquée pour obtenir une chose simple devrait être réduite au minimum car le code pourrait être modifié par un autre programmeur dans le futur. La logique mise en œuvre par un programmeur peut ne pas avoir de sens pour un autre. Donc, gardez toujours le code aussi simple que possible.[20] Par exemple, considérons ces lignes équivalentes de code C:

si (heures < 24 && minutes < 60 && secondes < 60)

revenir vrai;

autre

revenir faux;

et

si (heures < 24 && minutes < 60 && secondes < 60) revenir vrai; autre revenir faux;

et

revenir heures < 24 && minutes < 60 && secondes < 60;

La 1ère approche, beaucoup plus utilisée[[[[douteux – discuter], est considérablement plus grand que le 3ème. En particulier, il consomme 5 fois plus d’espace vertical (lignes) et 97 caractères au lieu de 52 (bien que les outils d’édition puissent réduire la différence de frappe). C'est discutable, cependant, qui est "plus simple". Le premier a un if / then else explicite, avec une valeur de retour explicite évidemment liée à chacun; même un programmeur débutant ne devrait avoir aucune difficulté à le comprendre. La 2ème se débarrasse simplement des accolades, coupant la taille "verticale" en deux avec peu de changement de complexité conceptuelle. Dans la plupart des langues, les instructions "return" peuvent également être ajoutées aux lignes précédentes, ramenant la taille "verticale" à une seule ligne de plus que la 3ème forme.

La troisième forme minimise évidemment la taille, mais peut augmenter la complexité: elle laisse les valeurs "true" et "false" implicites, et mélange les notions de "condition" et de "valeur de retour". Cela est probablement évident pour la plupart des programmeurs, mais un débutant peut ne pas comprendre immédiatement que le résultat de l'évaluation d'une condition est en réalité une valeur (de type booléen, ou son équivalent dans n'importe quel langage), et peut donc être manipulé ou renvoyé. Dans des exemples plus réalistes, la troisième forme pourrait avoir des problèmes en raison de la priorité des opérateurs, renvoyant peut-être un type inattendu, où les formes précédentes signaleraient une erreur dans certaines langues. Ainsi, la "simplicité" n’est pas simplement une question de longueur, mais de structure logique et conceptuelle; raccourcir le code peut le rendre moins complexe ou plus complexe.

Pour les programmes de grande envergure et de longue durée, l’utilisation d’alternatives verbeuses pourrait contribuer à faire de l’engourdissement.[[[[douteux – discuter] La compacité peut permettre aux codeurs d’afficher plus de code par page, réduisant ainsi les gestes de défilement et les frappes au clavier. Étant donné le nombre de fois que le code peut être visualisé pendant le processus d’écriture et de maintenance, cela pourrait représenter une économie importante en termes de frappe au clavier dans la vie du code. Cela peut ne pas sembler significatif pour un étudiant qui commence par apprendre à programmer. Mais lors de la production et de la maintenance de gros programmes atteignant souvent des milliers voire des millions de lignes, il devient évident[[[[citation requise] combien une simplification mineure du code pourrait accélérer le travail[[[[douteux – discuter]et atténuer la fatigue des doigts, des poignets et des yeux, problèmes médicaux courants des codeurs de production et des travailleurs de l’information.[21] Le codage Terser accélère très légèrement la compilation, car moins de symboles doivent être traités. En outre, la troisième approche peut permettre de comparer plus facilement des lignes de code similaires, en particulier lorsque nombre de ces constructions peuvent apparaître simultanément sur un écran.

Enfin, les dispositions très différentes pourraient mieux utiliser les écrans d’ordinateur modernes à écran large.[[[[citation requise] Dans le passé, les écrans étaient limités à 40 ou 80 caractères (ces limites remontaient bien avant: les manuscrits, les livres imprimés et même les parchemins utilisaient depuis des millénaires des lignes assez courtes (voir par exemple la Bible de Gutenberg). Les écrans modernes peuvent facilement en afficher 200 ou plus. caractères, ce qui permet des lignes extrêmement longues. La plupart des styles et normes de codage modernes ne prennent pas toute cette largeur. Ainsi, si vous utilisez une fenêtre aussi large que l’écran, une grande partie de l’espace disponible est gaspillée. D'autre part, avec plusieurs fenêtres , ou en utilisant un IDE ou un autre outil avec diverses informations dans les panneaux latéraux, la largeur disponible pour le code est dans la gamme des systèmes précédents.

Il convient également de noter que le système visuel humain est grandement affecté par la longueur de la ligne; les très longues lignes augmentent légèrement la vitesse de lecture, mais réduisent la compréhension [1] et ajouter à des erreurs de suivi des yeux. Certaines études suggèrent que les lignes plus longues se vendent mieux en ligne que sur papier [2], mais cela ne monte toujours qu’environ 10 pouces, et principalement pour la vitesse brute de lecture de la prose.

Portabilité[[[[modifier] Le code de programme ne doit pas contenir de valeurs "littérales" "codées en dur" faisant référence à des paramètres environnementaux, tels que des chemins de fichiers absolus, noms de fichiers, noms d'utilisateurs, noms d'hôtes, adresses IP, URL, ports UDP / TCP. Sinon, l'application ne fonctionnera pas sur un hôte dont la conception est différente de celle anticipée. Un programmeur avisé peut paramétrer de telles variables et les configurer pour l'environnement d'hébergement en dehors de l'application proprement dite (par exemple, dans des fichiers de propriétés, sur un serveur d'applications ou même dans une base de données). Comparez le mantra d'un "seul point de définition"[22] (SPOD).

En tant qu'extension, les ressources telles que les fichiers XML doivent également contenir des variables plutôt que des valeurs littérales, sinon l'application ne sera pas portable dans un autre environnement sans modification des fichiers XML. Par exemple, avec les applications J2EE s'exécutant sur un serveur d'applications, ces paramètres d'environnement peuvent être définis dans le périmètre de la machine virtuelle Java et l'application doit en extraire les valeurs.

Directives de construction en bref[[[[modifier] Un aperçu général de tout ce qui précède:

Savoir ce que le bloc de code doit effectuer Maintenir les conventions de dénomination qui sont uniformes partout. Indiquez une brève description de l’utilité d’une variable (référence aux commentaires) Corrigez les erreurs au fur et à mesure qu'elles se produisent. Gardez votre code simple

Développement de code[[[[modifier] Code de construction[[[[modifier] Une bonne pratique pour le code du bâtiment implique des constructions et des tests quotidiens, ou mieux encore une intégration continue, voire une livraison continue.

Essai[[[[modifier] Les tests font partie intégrante du développement logiciel à planifier. Il est également important que les tests soient effectués de manière proactive. ce qui signifie que les tests élémentaires sont planifiés avant le début du codage et que les tests élémentaires sont développés lors de la conception et du codage de l'application.

Déboguer le code et corriger les erreurs[[[[modifier] Les programmeurs ont tendance à écrire le code complet, puis à déboguer et à rechercher les erreurs. Bien que cette approche permette de gagner du temps dans les petits projets, les plus gros et les plus complexes ont trop de variables et fonctions qui nécessitent une attention particulière. Par conséquent, il est bon de déboguer chaque module une fois que vous avez terminé et non le programme entier. Cela permet de gagner du temps à long terme pour ne pas perdre beaucoup de temps à chercher ce qui ne va pas. Des tests unitaires pour des modules individuels et / ou des tests fonctionnels pour des services Web et des applications Web peuvent vous aider.

Déploiement[[[[modifier] Le déploiement est la dernière étape de la publication d’une application pour les utilisateurs. Quelques bonnes pratiques sont:[23][24]

Conservez la structure d'installation simple: les fichiers et les répertoires doivent être réduits au minimum. N'installez rien qui ne soit jamais utilisé. Ne conservez que ce qui est nécessaire: les activités de gestion de la configuration logicielle doivent vous assurer que cela est appliqué. Les ressources non utilisées (versions de fichiers anciennes ou en échec, code source, interfaces, etc.) doivent être archivées ailleurs pour que les nouvelles versions restent minces. Maintenez tout à jour: les activités de gestion de la configuration logicielle doivent vous assurer que cela est appliqué. Pour les déploiements basés sur les deltas, assurez-vous que les versions des ressources déjà déployées sont les plus récentes avant de déployer les deltas. Si vous n'êtes pas sûr, effectuez un déploiement à partir de zéro (supprimez tout d'abord, puis redéployez). Adoptez une stratégie en plusieurs étapes: en fonction de la taille du projet, des déploiements supplémentaires sont parfois nécessaires.[25] Avoir une stratégie de restauration: Il doit exister un moyen de revenir à une version précédente (opérationnelle). Comptez sur l'automatisation pour les processus répétables: les erreurs humaines sont beaucoup trop nombreuses, les déploiements ne doivent pas être manuels. Utilisez un outil natif pour chaque système d'exploitation ou utilisez un langage de script pour les déploiements multi-plateformes.[26][27] Recréez l'environnement de déploiement réel: tenez compte de tout (routeurs, pare-feu, serveurs Web, navigateurs Web, systèmes de fichiers, etc.) Ne modifiez pas les procédures de déploiement et les scripts à la volée, et documentez ces modifications: attendez une nouvelle itération et enregistrez ces modifications de manière appropriée. Personnalisation du déploiement: les produits logiciels les plus récents tels que les API, les micro-services, etc. nécessitent des considérations spécifiques pour un déploiement réussi.[28][29][30] Réduisez les risques liés aux autres phases de développement: si d'autres activités telles que la gestion des tests et de la configuration sont incorrectes, le déploiement échouera sûrement.[31][32] Considérez l’influence de chaque acteur: Considérations organisationnelles, sociales et gouvernementales.[33][34][35]

Voir également[[[[modifier] Références[[[[modifier]

^ McConnell, Steve (2004). Code complet (Deuxième éd.). Microsoft Press. ISBN 0-7356-1967-0.

^ Sommerville, Ian (2004). Génie logiciel (Septième éd.). Pearson. p. 38. ISBN 0-321-21026-3.

^ McConnell, Steve (2004). Code complet (Deuxième éd.). Microsoft Press. pp. 649–659. ISBN 0-7356-1967-0.

^ Weinberg, Gerald (1998). La psychologie de la programmation informatique (Silver anniversaire ed.). Éditions Dorset House, New York. pp. 128–132. ISBN 978-0-932633-42-2.

^ Sommerville, Ian (2004). Génie logiciel (Septième éd.). Pearson. pp. 12–13. ISBN 0-321-21026-3.

^ Weinberg, Gerald (1998). La psychologie de la programmation informatique (Silver anniversaire ed.). Éditions Dorset House, New York. pp. 15–25. ISBN 978-0-932633-42-2.

^ Hoare, C.A.R. (1972). "La qualité du logiciel". Pratique et expérience du logiciel. Wiley. 2: 103-105. doi: 10.1002 / spe.4380020202.

^ Meek, Brian; Heath, Patricia (1980), Guide de bonnes pratiques de programmationEllis Horwood, Wiley, p. 14

^ McConnell, Steve (2004). Code complet (Deuxième éd.). Microsoft Press. p. 40. ISBN 0-7356-1967-0.

^ McConnell, Steve (2004). Code complet (Deuxième éd.). Microsoft Press. p. 36. ISBN 0-7356-1967-0.

^ Meek, Brian; Heath, Patricia (1980), Guide de bonnes pratiques de programmationEllis Horwood, Wiley, p. 15

^ Sommerville, Ian (2004). Génie logiciel (Septième éd.). Pearson. pp. 118–123. ISBN 0-321-21026-3.

^ Hoare, C.A.R (1981). "Les vieux vêtements de l'empereur" (PDF). Communications de l'ACM. ACM. 24 (2): 75–83. doi: 10.1145 / 358549.358561. Récupéré 7 nov. 2013.[[[[lien mort permanent]

^ Sommerville, Ian (2004). Génie logiciel (Septième éd.). Pearson. pp. 242–243. ISBN 0-321-21026-3.

^ Mayer, Herbert (1989). Programmation C avancée sur le PC IBM. Livres Windcrest. p. xii (préface). ISBN 0830693637.

^ Meek, Brian; Heath, Patricia (1980), Guide de bonnes pratiques de programmationEllis Horwood, Wiley, p. 37

^ McConnell, Steve (2004). Code complet (Deuxième éd.). Microsoft Press. p. 70. ISBN 0-7356-1967-0.

^ McConnell, Steve (2004). Code complet (Deuxième éd.). Microsoft Press. p. 70. ISBN 0-7356-1967-0.

^ Roedy Green. "code non maintenable: Glossaire Java". Récupéré 2013-11-26.

^ Multiple (wiki). "Les meilleures pratiques". Docforge. Récupéré 2012-11-13.

^ "Blessure à répétition". Récupéré 30 octobre 2016.

^ Voir par exemple: "Exemple unique de point de définition". Récupéré 2015-11-30. 'Ne répète rien. Visez un seul point de définition pour chaque aspect de votre application […]'.

^ https://dzone.com/articles/7-application-deployment-best

^ https://lwn.net/Articles/562333/

^ blog.fortrabbit.com/multi-stage-deployment-for-website-development

^ https://www.wired.com/insights/2013/04/why-30-of-app-deployments-fail/

^ http://emphaticsolutions.com/2009/09/06/the-rules-of-software-deployment.html

^ https://airbrake.io/blog/software-development/speed-up-deployment-match-demand

^ https://www.linux.com/news/devops-and-art-secure-application-deployment

^ https://www.awsarchitectureblog.com/2014/05/organizing-software-deployments-to-match-failure-conditions.html

^ http://www.theserverside.com/news/1364556/Best-Practices-for-Risk-Free-Deployment

^ http://www.drdobbs.com/effective-software-deployment/184415760

^ http://searchitoperations.techtarget.com/tip/Enterprise-application-deployment-The-humanity-of-software-implementation

^ https://18f.gsa.gov/2014/05/14/hacking-bureaucracy-improving-hiring-and-software/

^ http://www.intact-tech.com/why-a-bad-software-deployment-is-worse-than-doing-nothing/

Général

Harbison, Samuel P .; Steele, Guy L. C – Un manuel de référence. ISBN 978-0-13-089592-9. Amélioration du cycle de développement du logiciel sécurisé produit, V2.0 oct. 2008 décrit les principes et les pratiques de sécurité que les développeurs, les testeurs et les intégrateurs de logiciels peuvent adopter pour atteindre le double objectif de produire des systèmes plus sécurisés à forte intensité de logiciel et de vérifier la sécurité. du logiciel qu'ils produisent. Dutta, Shiv; Hook, Gary (26 juin 2003). "Bonnes pratiques pour la programmation en C". developerWorks. IBM. Archivé de l'original le 13 juillet 2009. Récupéré 21 janvier 2010.

Liens externes[[[[modifier]

Click to rate this post! [Total: 0 Average: 0]