Y at-il un processus de bonne façon de mettre en œuvre une amélioration continue (AKA durcissement du logiciel)?

Question

Chaque version, il semble que nos clients à trouver quelques vieux problèmes avec notre logiciel. Il fait ressembler à chaque nouvelle version a plusieurs bogues, alors qu'en réalité notre nouveau code est généralement solide.

Nous avons essayé de mettre en œuvre des tests supplémentaires où nous avons testeurs font plusieurs heures de tests de régression par mois sur une seule application chaque mois dans un effort pour rester en tête des petits problèmes. Nous nous référons à ce processus que notre processus Durcissement Software, mais il ne semble pas que nous rattrapons assez des insectes et il se sent comme un processus très second plan car il y a toujours un nouveau code à écrire.

Y at-il une astuce pour ce genre de test? Ai-je besoin de cibler une caractéristique spécifique à un moment?

Answer 1

Lorsque vous développez vos procédures de test, vous pouvez mettre en œuvre ce genre de tests:

• tests unitaires (test des composants invididuels de votre projet pour tester leur fonctionnalité), ces tests sont importants parce qu'ils vous permettent de déterminer où dans le logiciel l'erreur peut provenir. En gros, dans ces tests vous permettra de tester une fonctionnalité unique et utiliser des objets fantaisie pour simuler le comportement, la valeur de retour d'autres objets / entités.

• tests de régression, que vous avez mentionné

• tests de caractérisation, un exemple pourrait être en cours d'exécution automatiquement le programme sur l'entrée généré automatiquement (simulant l'entrée utilisateur), le stockage des résultats et de comparer les résultats de toutes les versions par rapport à ces résultats.

Au début, ce sera très lourd à mettre en place, mais avec d'autres communiqués et d'autres corrections de bugs ajoutés aux tests de non régression automatisés, vous devriez commencer à gagner du temps.

Il est très important que vous ne tombez pas dans le piège de la conception très grand nombre de tests muets. Le test doit vous rendre la vie plus facile, si vous passez trop de temps comprendre beaucoup où les tests ont rompu, vous devez repenser les tests tels qu'ils vous donnent de meilleurs messages / compréhension du problème afin que vous puissiez trouver le problème rapidement.

En fonction de votre environnement, ces tests peuvent être liés au processus de développement.

Dans mon environnement, nous utilisons SVN pour versioning, un bot exécute les tests contre chaque révision et renvoie les tests ayant échoué et des messages avec le nom de la révision qui rompit et le contributeur (son login).

EDIT:

Dans mon environnement, nous utilisons une combinaison de C ++ et C # pour livrer des analyses utilisées en finance, le code est C ++ et est assez vieux alors que nous essayons de faire migrer les interfaces vers C # et de garder le noyau de l'analyse en C ++ ( principalement en raison des exigences de vitesse)

La plupart des tests C sont des tests unitaires écrits à la main et les tests de régression.

Du côté C #, nous utilisons NUnit pour les tests unitaires. Nous avons deux ou trois tests généraux.

Nous avons une politique 0 avertissements, nous interdire explicitement les gens à commettre le code qui génère des avertissements à moins qu'ils ne peuvent justifier pourquoi il est utile de contourner l'avertissement de cette partie du code. Nous avons ainsi conventions sur la sécurité d'exception, l'utilisation des modèles de conception et de nombreux autres aspects.

Définition des conventions et des meilleures pratiques est une autre façon explicite d'améliorer la qualité de votre code.

Answer 2

  

Y at-il une astuce pour ce genre de test?

Vous avez dit: « Nous avons testeurs font plusieurs heures de tests de régression par mois sur une seule application chaque mois dans un effort pour rester en tête des petits problèmes. »

Je suppose que par « les tests de régression » vous voulez dire « l'exercice manuellement vieilles fonctions ».

Vous devez décider si vous êtes à la recherche de vieux bogues qui ont jamais été trouvés avant (ce qui signifie, l'exécution des tests que vous avez jamais exécuté avant); ou , que vous répéter les tests précédemment gérés pour vérifier que la fonctionnalité précédemment testée est inchangée. Ce sont deux choses opposées.

« Les tests de régression » me implique que vous faites ce dernier.

Si le problème est que « les clients à trouver quelques vieux problèmes avec notre logiciel » alors soit vos clients sont en cours d'exécution des tests que vous ne l'avez jamais exécuté avant (dans ce cas, pour trouver ces problèmes dont vous avez besoin pour exécuter nouveau tests d'anciens logiciels), ou ils trouvent des bugs que vous vous précédent testé et trouvé, mais que vous apparemment jamais fixé après que vous les avez trouvés.

  

Dois-je cibler une caractéristique spécifique à un moment?

Qu'est-ce que vous essayez de faire, exactement:

• Rechercher les bugs avant que les clients les trouver?
• Convaincre les clients qu'il ya peu de mal avec le nouveau développement?
• Passez aussi peu de temps que possible sur les tests?

conseils très générale est que les insectes vivent dans des familles: donc quand vous trouvez un bug, regardez pour ses parents et frères et sœurs et cousines, par exemple:

• Vous pourriez avoir cette même bug exacte dans d'autres modules
• Ce module peut être Brugière que d'autres modules (écrit par Somone sur un jour de congé, peut-être), donc chercher tous les autres types de bug dans ce module
• Peut-être est l'un d'une classe de problèmes (problèmes de performance, ou des problèmes de faible mémoire) qui suggère toute une zone (ou type d'exigence tout) qui a besoin d'une meilleure couverture de test

Autre conseil est qu'il est à faire avec la gestion des attentes des clients: vous avez dit: « Il fait ressembler à chaque nouvelle version a plusieurs bogues, alors qu'en réalité notre nouveau code est généralement solide » comme si le vrai problème est la perception erronée que le bug est nouvellement écrit.

  

il se sent comme un processus très second plan car il y a toujours un nouveau code à écrire

Software ne Promotion se fait pas en arrière-plan, sur un brûleur: soit quelqu'un travaille là-dessus, ou ils ne sont pas. La direction doit décider d'assigner quelqu'un à cette tâche (c.-à rechercher existants bogues précédemment non trouvées ou fix-précédemment trouvé-mais-pas-encore-rapporté des bugs), ou si elles préfèrent se concentrer sur le nouveau développement et de laisser la les clients font le bug-détection.

---

Modifier Il convient de mentionner que les tests ne sont pas la seule façon de trouver des bogues. Il y a aussi:

• Avis de conception informel (35%)
• inspections de conception formelles (55%)
• revues de code informel (25%)
• inspections de code officiel (60%)
• vérification de bureau personnel du code (40%)
• Test unitaire (30%)
• test de composants (30%)
• test d'intégration (35%)
• test de régression (25%)
• test de système (40%)
• faible beta test de volume (<10 sites) (35%)
• beta test à haut volume (> 1000 sites) (70%)

Le pourcentage que je mets à côté de chacun est une mesure du taux défaut d'élimination pour chaque technique (prise de la page 243 de McConnel de Software Estimation livre). Les deux techniques les plus efficaces semblent être inspection de code formel, et les tests bêta haut volume.

Il pourrait donc être une bonne idée d'introduire des revues de code officiel:. Qui pourrait être mieux détecter les défauts que le test noir boîte est

Answer 3

Dès que vos extrémités de codage, d'abord, vous devez aller pour les tests unitaires. Là, vous obtiendrez quelques bugs qui devraient être fixes et vous devez effectuer une autre série de tests unitaires pour trouver si nouveaux bugs sont venus ou non. Après avoir terminé le test de l'unité, vous devriez opter pour des tests fonctionnels.

mentionné ici que votre testeur effectue sont les tests de régression sur une base mensuelle et il y a encore des anciens bugs qui sortent. Il est donc préférable de s'asseoir avec le testeur et examiner les cas de test que je pense qu'ils ont besoin d'être mis à jour régulièrement. Aussi lors de l'examen mis l'accent sur ce qui module ou fonctionnalité des bogues sont à venir. Le stress sur ces zones et ajouter plus de cas de test dans ces domaines et les ajouter dans votre cas de test rgression de sorte qu'une fois nouvelle construction vient ces cas de test doit être exécuté.

Vous pouvez essayer une chose si votre projet est un à long terme, alors vous devriez en parler avec le testeur pour automatiser les cas de tests de régression. Il vous aidera à exécuter les cas de test à congé comme la nuit et le lendemain, vous obtiendrez les résultats. De plus, les cas de tests de régression doivent être mis à jour comme le problème majeur vient quand des cas de test de régression ne sont pas mis à jour régulièrement et en exécutant les anciens cas de test de régression et de nouveaux cas de test de progression vous manque quelques modules qui ne sont pas testés.

Answer 4

Il y a beaucoup de discussions ici au sujet des tests unitaires et je ne pouvais pas être plus d'accord. J'espère que Josh comprend que les tests unitaires est un processus mécanique. Je suis en désaccord avec PJ en ce que les tests unitaires doivent être écrits avant de coder l'application et non après. Ceci est appelé TDD ou Test Driven Development.

Certaines personnes écrivent des tests unitaires qui exercent le code de niveau intermédiaire mais négligent de tester le code de l'interface graphique. C'est imprudent. Vous devriez écrire des tests unitaires pour tous les niveaux de votre application.

Les tests unitaires sont également le code, il y a la question de l'AQ pour votre suite de tests. La bonne couverture de code? Y at-il de faux positifs / négatifs erreurs dans les tests unitaires? testez-vous pour les bonnes choses? Comment assurez-vous la qualité de votre processus d'assurance de la qualité? En fait, la réponse à cette question se résume à un examen par les pairs et les valeurs culturelles. Toute l'équipe doit être engagée à une bonne hygiène de test.

Le plus tôt un bug est introduit dans votre système, plus il reste dans le système, il est plus difficile d'enlever et plus il en coûte cher. Voilà pourquoi vous devriez regarder dans ce qu'on appelle l'intégration continue. Lorsque mis en place correctement, signifie l'intégration continue que la compilation du projet et exécuté avec la suite complète de tests unitaires peu après avoir vérifié vos modifications pour la journée.

Si les tests de construction ou de l'unité échouent, le codeur incriminé et le maître de construction devient une notification. Ils travaillent avec le chef d'équipe pour déterminer quelle correction la plus appropriée devrait être. Parfois, il est tout aussi simple que résoudre le problème et vérifier le correctif. Un maître de construction et chef d'équipe doit participer à identifier les modèles généraux qui nécessitent une intervention supplémentaire. Par exemple, une crise familiale peut provoquer le codage de la qualité vers le bas d'un développeur sur. Sans CI et une surveillance de la gestion, il pourrait prendre six mois de bugs avant de réaliser ce qui se passe et prendre des mesures correctives.

Vous n'avez pas mentionné ce que votre environnement de développement est. Si le vôtre était un magasin J2EE, alors je vous suggère de regarder dans ce qui suit.

• CruiseControl pour l'intégration continue
• Subversion pour le code source de contrôle de versioning, car il intègre bien avec CruiseControl
• Spring parce DI facilite la mécaniser les tests unitaires à des fins d'intégration continue
• JUnit pour les tests unitaires au niveau intermédiaire
• HTTPUnit pour les tests unitaires de l'interface graphique
• Apache JMeter pour tester le stress

Answer 5

Pour en revenir et mettre en œuvre une stratégie de test pour (tous) des choses existantes est une douleur. Il est long, il est difficile, et personne ne voudra le faire. Cependant, je recommande fortement que comme un nouveau bug arrive, un test développé autour de ce bug. Si vous ne recevez pas un rapport de bogue sur elle, alors soit est (a) fonctionne ou (b) l'utilisateur ne se soucie pas que cela ne fonctionne pas. De toute façon, un test est une perte de temps.

Dès que l'a identifié, écrire un test qui va rouge . Maintenant. Ensuite, corriger le bug. Assurez-vous qu'il est fixé. Assurez-vous que le test est maintenant vert . Répétez que de nouveaux bogues entrent en jeu.

Answer 6

Désolé de dire cela, mais peut-être vous êtes tout simplement pas assez de tests, ou trop tard, ou les deux.