Je comprends le concept de tests unitaires comme à venir avec des idées simples sur ce que votre code devrait produire - puis la sortie. Donc, il pense à ce que vous voulez un morceau de code à faire - puis faisant un test pour vous assurer que cela fonctionne.
À quel point dans la programmation d'apprentissage devrait être incorporé TDD (test unitaire)?
Edit: J'ai aimé le commentaire sur le test de l'unité dès que les outils de le faire, arrêtez de devenir magique.
À l'origine, la question s'est produite parce que je me rendrai compte que je n'ai pas encore les compétences nécessaires pour développer un grand programme, mais j'aimerais apprendre en proposant des idées pour ce que certains morceaux de code pourraient / devraient faire.
Je veux que je veux apprendre en faisant et je pense une manière structurée de faire cela aiderait. Python est la langue que j'utilise. Merci pour toute l'entrée jusqu'à présent.
13 Réponses :
le plus tôt possible. Tous mes obstacles à adopter TDD ont été parce que j'ai dû casser de vieilles habitudes et changer ma façon de penser. Si j'aurais pu penser en termes de TDD dès le début, j'aurais trouvé le tout beaucoup plus facile.
Parlez-nous du novice total ou du programmeur qui apprend une nouvelle langue? Si ce dernier - je dirais, tout de suite. pourquoi? Depuis le meilleur moyen d'apprendre est de coder, et si vous codez, vous devez tester. Cependant, quelqu'un qui n'a aucune notion de programmation devrait probablement apprendre les bases de la programmation d'abord
Vous pouvez apprendre les bases de TDD apprendre ... Je me souviens d'écrire toutes ces chaudières pour apprendre les bases de Java.
Le test unitaire est un économiseur de temps énorme lorsque vous commencez, car vous finissez par faire beaucoup de "code, courir, déboguer" des cycles tout en apprenant. C'est cette phase "géré" qui devient une époque suce lorsque vous le faites ad-hoc à chaque fois. De plus, je pense que les débutants ont tendance à introduire davantage de problèmes de régression, ce qui est un autre temps énorme évier si vous ne les attrapez pas tout de suite avec un test d'unité.
+1 - grand point. Cela est particulièrement vrai dans le développement Web ou dans des systèmes nécessitant un identifiant / mot de passe et une navigation pour atteindre le code à tester. Il est beaucoup plus facile d'écrire le test, puis (dans mon cas) simplement cliquez simplement sur le test et dites-lui d'exercer le code que vous écrivez. C'est une énorme frontière et une énorme qui ne reçoit pas assez de reconnaissance dans la discussion de TDD.
TDD vous fait penser beaucoup plus avant de coder - quelque chose que je manquais au début de ma carrière. J'avais l'habitude de monter et de courir dans l'IDE et de commencer à taper - code et corrigez comme on dit.
Si j'avais utilisé des tests unitaires et TDD plus tôt dans mon développement en tant que programmeur, je crois fermement que j'aurais pu produire un code de meilleure qualité plus tôt (pas que mon code à cette époque était l'esprit total de la merde :)
Bien sûr, c'est une question très subjective, mais je pense que nous pouvons certainement mettre une limite précoce à ce sujet. Je dirais que non avant que les opérations du cadre de test de l'unité ne soient arrêtés comme une magie. Donc, en Java, avec Junit, vous devez d'abord comprendre des exceptions, des méthodes, des valeurs de retour, des paramètres, des opérateurs de base, des choses comme ça.
Une partie du problème est que de nombreux exemples de programmation simples demandent une entrée utilisateur, ce qui est difficile à tester unitaire, de sorte que vous ne voulez pas faire trop d'un obstacle tôt, mais si le test de l'unité était couramment fait tôt, il pourrait être plus facile de faciliter le code de test unitaire qui doit faire cela.
Je pense que le paradigme (changement de réflexion) devait travailler avec TDD (ou veux pour travailler avec TDD) est qu'il est justifié par une vue "holistique" de l'endroit où les programmeurs passent du temps et d'ajouter de la valeur . Les pratiquants pure agile / Scrum sont formés pour voir qu'un morceau de code a une valeur positive (et comptée comme "faite") uniquement lorsqu'il réussit correctement son objectif (de transformer quelque chose, etc.). C'est parce que nous nous trompons seulement sur la valeur (acceptabilité) à moins que ce soit correct.
Définition de la structure de test définit d'abord l'objectif du codage et où il peut aller mal (les cas de test de bord et négatif). En outre, vérifiez si l'objectif est atteint est automatisé.
Les tests en général doivent être enseignés dans le cadre d'un premier cours de programmation, OMI. Les tests unitaires ne sont pas nécessairement quelque chose que je mets au début comme l'idée de ce qui est ou non une "unité" peut facilement devenir une sémantique et une philosophie. Spécification des types de tests en tant que tests unitaires que je pouvais voir dans un deuxième ou troisième cours. Bien sûr, je ne me souviens pas des tests d'unités d'apprentissage à l'université, donc d'une manière ou d'une autre, il n'a pas compris dans le programme où je suis allé à l'école dans les années 90.
TDD en tant que philosophie pourrait probablement être utilisé peu de temps après avoir obtenu les idées de base des tests. Je ne suis pas sûr que je voulais passer par tous les types de tests avec des personnes qui n'ont aucune idée de quel code ressemble. Une fois que quelqu'un a eu quelques bases de la programmation, les tests deviennent un moyen utile de montrer que "Oui, ce programme fait ce qu'il a à faire". Les élèves essayant de sortir de TDD peuvent le voir comme quelque chose de facile et de naturel s'ils sont toujours relativement nouveaux pour la programmation, tandis que ceux qui ont programmé pendant des années peuvent avoir du mal à s'adapter au paradigme.
En tant que sidenote, TDD et / ou les tests unitaires peuvent venir très tard dans l'apprentissage
traiter. Même les programmeurs chevronnés peuvent gagner de Tests d'apprentissage lors du démarrage de travailler avec une nouvelle langue ou une nouvelle API.
Kent Beck recommande ceci sous le " Test d'apprentissage de" dans sa « barre rouge
modèles » dans le développement dirigé par les tests: par exemple.
Au lieu d'utiliser une nouvelle méthode ou
une nouvelle classe, nous écrivons un petit test
qui vérifie que les travaux de l'API comme prévu.
De même, Mike Clark a écrit une suite de plus de 400 essais en apprentissage Ruby .
L'écriture des tests d'apprentissage est une façon amusante de
les titiller une nouvelle langue ou de l'API.
Et vous avec tous les tests que vous écrivez êtes
investir dans une connaissance exécutable
base.
Oh! Quel concept cool. C'est comme garder un journal de ce que vous avez appris, mais un journal exécutable.
Le lien vers le blog de Mike Clark est mort. Voici un Lien machine de Wayback
Je suppose Ce que vous voulez faire est fondamentalement "faire de plus petits programmes, puis les rendre complexes progressivement (et dans le cours, vous apprendrez finalement la programmation)". Ce type de développement logiciel "commence avec plus simple, puis la rendre complexe progressivement" est appelée "prototypage logiciel" techniquement. Voici une définition de celui-ci:
"Prototypage de logiciel, une activité pendant certains logiciels, est la création de prototypes, c'est-à-dire des versions incomplètes du programme logiciel développé.
Un prototype ne simule généralement que quelques aspects des caractéristiques du programme éventuel et peut être complètement différent de la mise en œuvre éventuelle.
L'objectif conventionnel d'un prototype est de permettre aux utilisateurs du logiciel d'évaluer les propositions de développeurs pour la conception du produit éventuel en les essayant, plutôt que de devoir interpréter et évaluer la conception basée sur des descriptions. Le prototypage peut également être utilisé par les utilisateurs finaux pour décrire et prouver les exigences que les développeurs n'ont pas pris en compte, ce qui "contrôlant le prototype" peut donc être un facteur clé de la relation commerciale entre les fournisseurs de solutions et leurs clients. "
D'autre part, le test unitaire est une seule de la méthodologie dans "Test de logiciel". Ce n'est pas une partie du développement de logiciels commençant. Il est fait à la fin lorsque le programme assez important a été créé et assurer chaque pièce (c'est-à-dire des unités plus petites telles que des fonctions, des procédures, des méthodes de classe, etc.) fonctionnent correctement. Les tests unitaires ne peuvent pas être utilisés pour fonder un développement de logiciels car à la fin si le test de l'unité entraîne une erreur "une seule pièce a une erreur", cela signifie certainement que l'ensemble du logiciel est erroné alors que le test de l'unité indique "toutes les pièces n'ont aucune erreur, elle ne t signifie que tout le logiciel est exempt d'erreur "car il peut y avoir une erreur dans l'intégration de ces pièces ou des tests unitaires à saisir toutes les erreurs dans le programme: il est impossible d'évaluer chaque chemin d'exécution de tous les programmes les plus triviaux. Il en va de même pour les tests unitaires. En outre, les tests unitaires par définition ne teste que la fonctionnalité des unités elles-mêmes. Par conséquent, il ne va pas attraper des erreurs d'intégration ni des erreurs de niveau de niveau plus vastes (telles que des fonctions effectuées sur plusieurs unités ou des zones de test non fonctionnelles telles que la performance). Les tests unitaires doivent être effectués conjointement avec d'autres activités de test de logiciels. Comme toutes les formes de test logiciel, les tests d'unités ne peuvent montrer que la présence d'erreurs; ils ne peuvent pas montrer l'absence d'erreurs.
Pour obtenir les avantages prévus de tests unitaires, une discipline rigoureuse est nécessaire tout au long du processus de développement de logiciels. Il est essentiel de conserver des enregistrements soignés non seulement des tests effectués, mais également de toutes les modifications apportées au code source de cette unité ou de toute autre unité du logiciel. L'utilisation d'un système de contrôle de version est essentielle. Si une version ultérieure de l'unité échoue à un test particulier qu'il avait précédemment passé, le logiciel de contrôle de la version peut fournir une liste des modifications du code source (le cas échéant) qui ont été appliquées à l'unité depuis cette période.
Il est également essentiel de mettre en œuvre un processus durable pour garantir que les défaillances de cas de test soient examinées quotidiennement et abordées immédiatement. Si un tel processus n'est pas implémenté et intégré dans le flux de travail de l'équipe, l'application évoluera par la suite de la suite de tests d'unité, augmentant les faux positifs et la réduction de l'efficacité de la suite de tests.
J'espère que vous avez maintenant une meilleure compréhension du terme "test de l'unité". Et ce que vous voulez faire est d'apprendre par "prototypage logiciel". En ce qui concerne l'apprentissage, vous pouvez opter n'importe quelle façon.
a) Lire beaucoup de programmes avant de coder un
b) Il suffit de lire peu de bases de tout langage de programmation et commencez à créer des programmes plus simples et de les rendre complexes avec votre connaissance accrue.
L'option (a) prend moins de temps pour vous rendre sur la voie de l'expert et qu'il existe également une chance d'adopter des pratiques erronées que vous pourriez développer lors de la "programmation auto-apprenante"
Option (b) prend plus de temps pour vous rendre sur la voie de l'expert mais que vous puissiez peut-être concevoir votre propre style de programmation et qu'il devient aussi bon que (sinon mieux) le style de programmation d'un autre expert.
Je recommande de ne pas choisir un seul moyen des options mentionnées ci-dessus (a) ou (b). Utilisez un mélange des deux et commencez par l'option (a).
Programmation heureuse! Bienvenue à la communauté folle!
Vous avez un point pour effort que j'ai emporté pour avoir tort - je ne pense pas avoir jamais vu quelqu'un affirmer que le test de l'unité "est fait à la fin".
Le mot "fin" peut signifier "à la fin du logiciel" à certains développeurs ou cela peut signifier "à la fin de la pièce ou du module" pour les autres. Quel que soit ce que vous voulez, cela signifie toujours que les tests logiciels sont toujours effectués lorsqu'il y a quelque chose de développé. Le gars qui a demandé à cette question a un malentendu du fait que le test de l'unité est une méthode d'apprentissage en faisant pendant que les livres de développement de logiciels ont une signification différente de ce terme «test de l'unité».
Le test de l'unité est différent du prototypage logiciel. Ce que Brian veut faire, c'est du prototypage de logiciel ... apprendre des erreurs ... Améliorer ... do ... Améliorer .... do ... Améliorer ... jusqu'à ce que vous obteniez ce que vous souhaitez. Cette chose n'est pas appelée test d'unité, elle s'appelle le prototypage logiciel. N'hésitez pas à vérifier Wikipedia si vous n'avez pas encore lu de livre sur le développement de logiciels.
Je pense que faire des tests unitaires est davantage d'apprendre
Ont surtout en particulier le contexte - Les tests d'unité Python sont très faciles à écrire et nécessitent très peu de compréhension - je dirais aller pour cela et couvrir votre compréhension et vos explorations avec des tests.
Après avoir effectué cela pendant un moment, incluez une étape d'examen où vous revenez et lisez vos tests antérieurs et voyez comment vous les avez réécrites avec votre compréhension actuelle. C'est ce que font les commentaires pour - écrire des questions et examiner des notes à vous-même dans les docstrings dans chaque définition de test.
Avec une telle approche progressive, l'utilisation de la version de version vous aidera à examiner et je le recommande vivement, notamment parce que vous pourrez voir une historique de vos modifications des journaux de contrôle de la version et donc plus d'encouragement auto-encouragement avec votre visible. le progrès. Je recommande GIT et en utilisant l'intégré Gitgui ou Gitx sur Macinosh.
En tant que professionnel très expérimenté, j'espère que le concept Test de l'unité, mais j'ai certainement utilisé beaucoup de petits tests comme moyen d'apprendre de nouvelles bibliothèques et de nouvelles langues.
À mon avis, c'est un outil énorme et puissant d'apprendre. J'utilise pour apprendre JavaScript et Python et avoir des résultats excellents.
Je ne parle pas d'un test de l'unité, je parle de l'utilisation de babysteps, refacteur vert rouge ... Tous ces pratices qui tournent le processus d'apprentissage d'un processus facile.
Alors j'essaie de commencer avec les petits morceaux, faire des trucs de mannequins et je vais augmenter le difficile en utilisant les morceaux durs de la langue.
Puis je remarque que je finirai de rédiger une excellente source d'études postérieures, donc si j'ai du doute, je revenais à mon TDDLearn et que je le résolvez, ou si j'ai trouvé une meilleure façon de faire quelques affaires ou de trouver une limitation, J'écris des tests pour cela ...
c'est génial !!!
Vous pouvez regarder mes progrès ici
ne peut pas croire que personne ne mentionnait KATAS:
https://github.com/gamontalvo/awesome-katas
et les koans similaires:
https://github.com/ts25504/awesome-koans
Les deux conceptions enseignent à travers l'auto-apprentissage en écrivant et en exécutant des tests jusqu'à ce qu'ils passent.
L'approche supérieure à la fin de TDD ressemble à une approche académique de base; Lorsqu'un sujet est introduit en général en général, souvent une présomption, puis foré dans des détails spécifiques
D'une perspective d'ingénierie logicielle? Du point de vue de l'étudiant en informatique? Du point de vue amateur?
Test de l'unité! = TDD. Ce sont des concepts de vastes concepts à l'esprit.
Demandez-vous la question dans le titre ou le corps? Ils sont deux choses différentes.
@JB KING: Et cela est très pertinent pour la question. Tout ingénieur logiciel doit être introduit le plus tôt possible aux tests unitaires, en tant que partie fondamentale de OO. D'autre part, TDD est génial, mais pas nécessaire. Tant que le code fonctionne et que les tests sont là, je ne me soucie pas vraiment s'ils ont été écrits avant ou après le fait.