Je suis un développeur Web sur le point de déverrouiller la réalisation "Bibliothèque de première classe publiée" dans ma carrière et je transpire des balles (j'étais debout toute la nuit en stressant). Je serais ravi de profiter de l'expérience de la communauté pour voir si quelqu'un a des suggestions ou des recommandations pour s'assurer que cela se déroule aussi bien que possible. Y a-t-il des détails ou des accrochages dont je dois être conscient? Quelque chose de spécial sur le processus de construction qui peut revenir me mordre?

Voici où j'en suis:

• La bibliothèque est testée à l'unité et a une couverture de code d'environ 97%
• L'API est bien documentée et des documents xml pour la prise en charge d'intellisense ont été créés
• J'ai veillé à ce que les accesseurs de classe publics / privés soient exacts et corrects. Il en va de même pour tous les getters / setters
• La gestion des erreurs n'est pas aussi gracieuse que je le souhaiterais, mais je suis contre une date limite et j'ai accepté que ce soit "aussi bon que ça va être" pour l'instant
• Pas de journalisation amicale. Debug.Writeline a été largement utilisé ... J'ai appris récemment que cela reflète mon inexpérience :(

Vos conseils sont grandement appréciés!

La bibliothèque sera utilisée pour générer des rapports. Chapeau standard - se connecte à la base de données en lecture seule, effectue des calculs, formate et génère des données dans le flux de réponse.

J'ai été choisi comme ressource marginale pour remplacer l'un des programmeurs qui ont démissionné, et cette tâche m'a été confiée dans le cadre d'un projet de "coupe-toi les dents". La bibliothèque de classes va être publiée pour que d'autres programmeurs de l'entreprise l'utilisent pendant qu'ils écrivent du code de production.

Verrouiller l'API

L'art de construire efficacement une API est autant une question de gestion des attentes que de structure.

Quand je dis API, je me réfère spécifiquement à la façon dont les classes / méthodes publiques / internes sont nommées et quel est leur niveau d'accès (c'est-à-dire privé / public / interne).

Si vous craignez que le code ne soit pas complètement prêt pour les heures de grande écoute, vous pouvez toujours le publier initialement en version bêta.

Communiqués:

• Bêta (c'est-à-dire avant 1.0)

  • peut contenir plusieurs modifications de rupture de l'API
  • peut manquer de modifications de compatibilité descendante entre les versions
  • peut avoir un manque de vernis

• Officiel (1.0+)

  • L'API est verrouillée jusqu'à la prochaine version majeure
  • tout changement introduit devrait garantir la compatibilité descendante

• Mineure (ex 1.1)

  • contiennent des corrections de bogues et / ou des implémentations de fonctionnalités
  • peut s'ajouter à l'API définie mais ne pas l'enlever

Si vous pensez que l'API doit être endurcie, alors libérez-la pendant un certain temps en version bêta. Cela indique qu'il est disponible pour utilisation mais ne doit pas être utilisé pour la production et / ou le code critique.

Beaucoup de gens traitent les schémas de version numérotés comme le lavage à chaud, mais lorsqu'ils sont utilisés efficacement, ils peuvent être utilisés pour fournir une certaine marge de manœuvre jusqu'à ce que la structure soit triée.

Vos hypothèses sur la façon dont il sera utilisé sont fausses

Peu importe à quel point quelque chose est bien conçu, les gens trouveront un moyen d'abuser ou de créer une autre utilisation.

Une façon de gérer cela est de verrouiller autant d'implémentations que possible à l'aide d'accesseurs (c'est-à-dire privés / publics / internes), mais aucune conception ou ingénierie ne vous donnera autant d'informations que de divulguer le code aux utilisateurs.

Peu importe à quel point vous pensez que votre code peut devenir parfait, vos utilisateurs prouveront que ce n'est pas le cas.

Je dirais que c'est la principale raison pour laquelle il est toujours préférable d'utiliser une base de code existante plutôt que de faire une réécriture complète. Au mieux, une réécriture complète réduira le ballonnement, mais il est fort probable que la nouvelle base de code contienne autant (et peut-être plus) de bogues que la base de code d'origine.

Dans votre cas, vous vous endurcissez la bataille à partir de zéro, alors vous pourriez aussi bien commencer.

Il semble que vous ayez le reste de vos bases couvertes. La documentation de l'API est vitale et les tests seront bons pour garantir la stabilité lorsque des modifications seront apportées à l'avenir.

La mise en œuvre d'un schéma de journalisation cohérent sera importante avant la publication du code pour la production, car vous aurez besoin d'un moyen d'activer / désactiver / filtrer globalement les journaux. BTW, dans la plupart des cas, la journalisation implique uniquement d'importer une bibliothèque et de changer les appels de sortie de Debug.WriteLine () en quelque chose comme Logging.Debug (), Logging.Info (), Logging.Error (). L'enregistreur lui-même fournit simplement une implémentation standard pour la configuration, le filtrage et une plus large gamme de schémas de sortie (ex fichiers, console, etc.).

En dehors de cela, je chercherais à sortir le code et à l'utiliser. Même si ce n'est que par un petit nombre d'utilisateurs pour commencer.

Ce sont deux choses que je trouve essentielles à la publication de logiciels:

• Sachez exactement ce que vous avez publié
• Gérer les attentes

Vous voulez pouvoir revenir en arrière et corriger les bogues que vous avez publiés et vous voulez que les gens comprennent quel problème votre code va résoudre.

Savoir ce que vous avez publié

Assurez-vous de l'avoir correctement versionné et signé (si approprié). Utilisez votre contrôle de code source pour étiqueter \ étiqueter le code associé à la version officiellement publiée. Cela vous aidera à identifier plus facilement les bogues car vous pourrez revenir exactement au code source que vous avez publié. Cela vous aidera également sur toute la ligne lorsque vous pourriez avoir plusieurs versions différentes.

Essayez de rendre la dernière version facile à obtenir et à mettre à jour. Que ce soit un programme d'installation ou simplement le mettre sur un partage commun dépend de qui \ quand \ combien de fois vous expédierez.

Assurez-vous que quelqu'un examine votre version finale, y compris la documentation. Il est très facile de devenir nerveux ou impatient de publier un logiciel et de manquer quelque chose.

Gérer les attentes

Documentez les limitations et rendez-les raisonnablement évidentes pour les développeurs. C'est bien que vous les ayez trouvés. Les gens sont souvent plus compréhensifs s'ils connaissent les limites de votre logiciel, surtout si vous avez un plan pour les corriger.

Documentez comment vous souhaitez obtenir des commentaires, bons ou mauvais. Comme il s'agit d'un projet interne, si tout le monde a accès à un système de suivi des bogues commun, demandez-leur de déposer des bogues contre le projet approprié.

À l'avenir, évitez de changer l'API si possible, c'est la seule chose qui pourrait gêner vos clients. N'oubliez pas que les exceptions font également partie de l'API, même si en C # elles ne font pas partie de la documentation de la méthode. Il peut être possible d'améliorer les exceptions levées à une date ultérieure, mais vous devrez parler aux utilisateurs finaux et voir quel impact cela aura.

J'ai une liste de contrôle pour les déploiements qui peuvent vous être utiles. Je fais du développement de bureau mais une partie de cela devrait se traduire. En voici quelques-unes:

Général:

• Mettez des contrôles nuls pour les paramètres de fonction qui ne doivent pas être nuls. Cela m'aide à échouer tôt.
• Supprimez les commentaires inutiles et les fichiers mis en commentaire. Ceux-ci provoquent des travaux futurs.
• Recherchez les commentaires "// TODO". Parfois, je me laisse des notes. Parfois je les oublie.
• Exécutez un test de mon code en utilisant la base de données de production lorsque cela est possible. Cela permet de garantir que toutes mes modifications de base de données sont en place sur le serveur de production.
• Mettez dans une journalisation abondante. Surtout pour un déploiement initial. En fait, j'économise la journalisation pour la fin car mon code en est généralement gélifié à ce stade. Vous ne voulez pas être dans une situation où vous avez un crash et vous vous dites "Si seulement je savais quelle était la valeur de X à ce moment". Essayez de planifier à l'avance.
• Essayez d'envelopper les appels de bibliothèque tiers dans les façades. Cela facilite le changement de bibliothèques à l'avenir et fournit une liste de contrôle de ce dont vous avez besoin d'une bibliothèque.

Spécifique .Net:

• Assurez-vous que j'appelle Dispose () sur les objets jetables. J'utilise l'analyse de code ou FxCop pour aider à trouver des cas de cela.
• Assurez-vous que je décroche correctement tous les gestionnaires d'événements. Cela évite les fuites de mémoire.