TDD nur in der Theorie

Vor etwas mehr als einem Jahr hatte ich das Glück, eine neunmonatige Pause von der Arbeit machen zu können. Ich entschied, dass ich in dieser Zeit meine C # -Fähigkeiten verbessern würde. Ich begann an einer Reihe von Projekten zu arbeiten und zwang mich, TDD zu folgen.

Es war ein ziemlich aufschlussreicher Prozess.

Anfangs war es schwierig, aber im Laufe der Zeit lernte ich, mehr testbaren Code zu schreiben (was, wie sich herausstellt, mehr SOLID-Code ist) und schärfte dabei auch meine Fähigkeiten im OO-Design.

Jetzt bin ich wieder in der Belegschaft und merke etwas Seltsames.

Ich folge TDD lieber nicht.

Ich finde, TDD verlangsamt mich und erschwert das Entwerfen einer sauberen Anwendung.

Stattdessen habe ich einen etwas (massiv) anderen Ansatz gewählt:

1. Wählen Sie ein vertikales Stück Arbeit
2. Entwickeln Sie einen funktionierenden Prototyp
3. Refactor bis alles schön aufgeräumt ist
4. Lehnen Sie sich zurück und schätzen Sie den SOLIDEN und testbaren Code, den ich geschrieben habe.

Möglicherweise haben Sie bemerkt, dass Schritt 1 nicht "die öffentliche Oberfläche meines Testziels definieren" und Schritt 2 nicht "den Bejesus von dieser öffentlichen Oberfläche testen" war. Möglicherweise haben Sie auch bemerkt, dass keiner der Schritte Tests umfasst. Ich schreibe testbaren Code, aber ich teste ihn noch nicht.

Nun möchte ich klarstellen, dass ich nicht auf irgendwelche Tests verzichte. Der Code, den ich schreibe, funktioniert . Es funktioniert, weil ich es manuell teste.

Ich möchte auch klarstellen, dass ich auch nicht auf alle automatisierten Tests verzichte. Hier ist mein Prozess anders. Und deshalb stelle ich diese Frage.

TDD in der Theorie. Nicht in der Praxis.

Mein Prozess hat sich ein wenig weiterentwickelt und ich habe eine Balance zwischen TDD und keinen Tests gefunden, die ich als sehr produktiv und auch einigermaßen sicher empfinde. Es geht wie folgt:

1. Implementieren Sie eine vertikale Arbeitsaufgabe mit Blick auf das Testen, schreiben Sie jedoch keine Tests.
2. Wenn Sie später (z. B. einen Monat später) auf der Straße sind, muss dieses Segment geändert werden
   1. Schreiben Sie Unit-Tests, Integrationstests, Verhaltenstests usw., die sicherstellen, dass die Arbeit korrekt ist
   2. Ändern Sie den Code
3. Wenn das Slice nicht geändert werden muss,
   1. Nichts tun

Indem ich einfach die Belastung durch das Schreiben von Tests von vor dem Schreiben des Codes auf vor dem Ändern des Codes verlagere , konnte ich viel mehr Arbeitscode produzieren. Und wenn ich zum Schreiben von Tests komme, schreibe ich viel weniger, aber fast genauso viel Grund (höherer ROI).

Ich mag diesen Prozess, bin aber besorgt, dass er möglicherweise nicht gut skaliert. Der Erfolg hängt davon ab, dass Entwickler fleißig Tests schreiben, bevor sie etwas ändern. Und das scheint ein ziemlich großes Risiko zu sein. TDD birgt jedoch das gleiche Risiko.

Also, gehe ich zur [BT] DD-Hölle, oder ist dies eine übliche Form von pragmatischem Codieren und Testen?

Ich würde gerne so weitermachen. Was kann ich tun, damit dieser Prozess langfristig funktioniert?

Ich bin der einzige Entwickler in meinen Projekten und für alles verantwortlich: Erfassung der Anforderungen, Design, Architektur, Tests, Bereitstellung usw. Ich vermute, dass dies der Grund ist, warum mein Prozess funktioniert.

Damit der Prozess auf lange Sicht funktioniert, würde ich die Tests schreiben, wenn der Code geschrieben wird.

Was Ihrem Ansatz zu widersprechen scheint. Wie auch immer Sie die Frage gestellt haben, ich gebe Ihnen mein Einverständnis:

Sie müssen die Tests nicht vor dem Code schreiben. vergiss diese Reinheit. Allerdings sollten Sie die Tests schreiben um diese Zeit.
Sobald der Code funktioniert, Sie ihn ein wenig verbessert und einige Fehler behoben haben (wir sprechen hier von einer Zeitspanne von Stunden), sind Sie an einem Punkt angelangt, an dem Sie das maximale Wissen darüber haben, was der Code tut. Dies ist eine großartige Zeit, um Tests zu schreiben, die Ihr Wissen erfassen.

Dies bis später zu belassen bedeutet, dass das Wissen (natürlich) im Laufe der Zeit abnimmt.

Dies bedeutet auch, dass Sie, sollten Sie jemals abreisen und jemand anderes die Leitung übernehmen, nicht die unmittelbare technische Schuld haben, nicht (durch Tests) dokumentiert zu haben, was was tut.

Am allermeisten kann "eines Tages" nicht kommen. Sie können entweder von einem Bus angefahren werden oder in den Bus einsteigen, um neue Abenteuer zu erleben.

Schließlich sind manuelle Tests nicht skalierbar und decken häufig nicht alle vom Endbenutzer verwendeten Geräte ab.

Obwohl es schwierig ist, TDD zu 100% umzusetzen, liegt ein Fehler in Ihrem Ansatz vor

1. Implementieren Sie einen vertikalen Arbeitsabschnitt

   1.1 1 Jahr vergeht ....

   1.2 Ein neuer Entwickler beginnt mit der Arbeit am Projekt

2. Wenn das Slice geändert werden muss

   2.3 Analysieren der Namen und Parameter der 'Clean Coding'-Methode' GetUnicorn (colourOfUnicorn) '

   2.4 Lesen Sie die XML-Kommentare 'Bekommt ein goldenes Einhorn (zum Reiten) (obvs)'

   2.5 Jage den ursprünglichen Entwickler

   2.6 Ich hoffe, sie erinnern sich daran, was der Code tun soll

   2.7 Lassen Sie sie alles erklären

3. Schreiben Sie Unit-Tests, Integrationstests, Verhaltenstests usw., die hoffentlich sicherstellen , dass die Arbeit korrekt ist

4. Ändern Sie den Code

Ich denke, Sie haben Recht zu erkennen, dass Komponententests wirklich ihren Wert zeigen, wenn Änderungen erforderlich sind.

Ich stimme sowohl Daniel Hollinrake als auch Ewan zu, dass der erste wichtige Punkt, warum Ihr Test nur bei Änderung gut funktioniert, ist:

I am the sole developer on my projects and I am responsible for everything

und dass ein wahrscheinlicher zweiter wichtiger Punkt ist:

you're producing nice clean code

Ich glaube nicht, dass TDD den alleinigen Programmierern einen enormen Produktivitätsschub bringt, und es kann die Qualität Ihres Codes nicht wesentlich verbessern, wenn Sie bereits guten, sauberen Code schreiben.

TDD wird jedoch mit Sicherheit die Qualität des Codes für arme / unerfahrene / veraltete Programmierer verbessern, insbesondere wenn es an der Zeit ist, den Code zu ändern, ohne etwas anderes zu beschädigen. Und umso mehr, wenn die Person, die den Code ändert, nicht dieselbe Person ist, die den Code ursprünglich geschrieben hat, oder mehrere Monate dazwischen vergangen sind.

Mit anderen Worten, ich denke, TDD ist sowohl eine gute Methode, um die Qualität Ihres Codes zu verbessern (wie Sie sich selbst eingestehen), als auch (und noch wichtiger) eine Art Absicherung, wenn Sie mit durchschnittlichen oder mittelmäßigen Programmierern zusammenarbeiten (etwa von einem anderen) Abteilung oder ein anderes Unternehmen), was weitaus häufiger vorkommt, als allein zu arbeiten.

Für mich scheint der Schlüssel folgender zu sein:

Ich bin der einzige Entwickler in meinen Projekten und für alles verantwortlich: Erfassung der Anforderungen, Design, Architektur, Tests, Bereitstellung usw. Ich vermute, dass dies der Grund ist, warum mein Prozess funktioniert.

Dies funktioniert für Sie und Sie produzieren netten, sauberen Code (nehme ich an!). Ich würde nur sagen, dass Sie ein Test-Gurtzeug erstellen müssen, damit andere Entwickler zuversichtlich Änderungen vornehmen können. Auch das Testgeschirr sorgt für Konsistenz im Verhalten des Codes.

Ich denke, Ihr Ansatz ähnelt meinem. Normalerweise bin ich der einzige Entwickler meiner Projekte. Ich habe festgestellt, dass ich dank TDD kleinere Funktionen und saubereren Code schreiben kann, aber ich füge Tests hinzu, während ich den Code als Test-Harness schreibe. Auf diese Weise kann ich, während sich der Code weiterentwickelt und die Funktionalität ändert, einigermaßen sicher sein, Änderungen vorzunehmen.

Ein zweiter Grund für das Schreiben von Tests ist, dass ich denke, dass sie eine Form der Dokumentation sind. Sie können meine Gründe dafür erklären, warum eine Funktion erstellt wurde. Aber hier denke ich mehr über behaviour Driven Development nach.

Beim Unit Testing geht es darum, das Problem der Codewartung anzugehen. Es gibt zwar Leute, die behaupten, dass sie mit TDD schneller Code schreiben als ohne, aber ich bin nicht überrascht, dass Sie in der Lage sind, mehr neuen Code zu schreiben, ohne Tests zu schreiben.

Die Probleme, die ich beim Schreiben von Tests sehen kann, bevor Sie sie ändern:

Ich muss mich oft in Eile verändern

Während Sie möglicherweise insgesamt Zeit sparen, indem Sie Tests nur dann schreiben, wenn Sie sie benötigen, ist nicht alle Zeit gleich. Verbringen Sie 2 Stunden mit dem Schreiben von Tests, um 1 Stunde zu sparen, wenn ich mich im Krisenmodus befinde - es lohnt sich auf jeden Fall.

Es ist einfacher, Tests gleichzeitig mit dem Schreiben des Codes zu schreiben

Um Unit-Tests richtig schreiben zu können, müssen Sie den Code verstehen, den ich teste. Ich benutze Unit-Tests oft als Übung zum Verstehen, aber das Testen vorhandener Codes kann zeitaufwändig sein, da das Verstehen vorhandener Codes zeitaufwändig ist. Vergleichen Sie dies mit dem Schreiben von Tests, während Sie den Code schreiben, und Sie werden ihn viel schneller finden, da Sie den Code bereits verstehen - Sie haben ihn gerade geschrieben!

Michael Feathers Definition von Legacy-Code ist Code ohne Tests. Unabhängig davon, ob Sie mit seiner Definition einverstanden sind, ist klar, dass ein erheblicher Teil der Kosten für die Änderung des vorhandenen Codes dafür verantwortlich ist, dass dieser weiterhin wie erwartet funktioniert. Oft ist nicht einmal klar, wie das erwartete Verhalten ist.

Das Schreiben von Einheiten testet kostenintensive Offsets, indem es ein Verständnis für das richtige Verhalten codiert und "Future Us" eine einfache Möglichkeit bietet, zu überprüfen, ob das Verhalten noch korrekt ist.

Das ist eine gute Frage, und FWIW werde ich meine zwei Cent einwerfen.

Vor ungefähr einem Jahr programmierte ich in Salesforce, einer Plattform mit einem integrierten Mechanismus, der Sie dazu zwang, nicht unbedingt Tests zu schreiben, bevor Sie programmierten , sondern Tests generell zu schreiben.

Es funktionierte so, dass das System Sie zwang, Tests zu schreiben, und die Anzahl der getesteten Codezeilen in Prozent berechnete. Wenn der gesamte Code in Ihrer gesamten Produktionsinstanz unter 75% gefallen ist, wird Salesforce nicht mehr ausgeführt.

Das Endergebnis war, dass Sie jedes Mal, wenn Sie in Salesforce etwas unternahmen, Tests schreiben oder aktualisieren mussten. Obwohl ich mir sicher bin, dass dies einen enormen Einfluss auf den Marktanteil von Salesforce hat, war es in Bezug auf das Leben eines Entwicklers ein schwerer Ärger .

Die meiste Zeit haben Sie nur versucht, durch ein kleines Ticket zu kommen, und dann kommt das Testen und verdoppelt Ihre Entwicklungszeit für eine Funktion, von der Sie nur wissen, dass sie funktioniert.

Dann durchlief das umständliche Konzept von TDD unsere Abteilung bis hinunter zu unseren Datenbanken. Unsere Architekten wollten alle Aspekte unserer IT-Abteilung einer gründlichen Prüfung unterziehen. Leichte Schmerzen im Arsch, noch größere Schmerzen im Arsch.

TDD hat mir damals noch nie wirklich Sinn gemacht und auch jetzt noch nicht. Viele der Funktionen, die ich in meiner aktuellen Rolle geschrieben habe, basieren auf einem ähnlichen Mechanismus wie dem, den Sie erwähnt haben: in vertikalen Segmenten, die ich verfeinere, bis sie funktionieren. Als ich noch in dieser alten Rolle war, weiß ich oft nicht, was mein Code tun wird, bis ich ihn tatsächlich schreibe. Die Idee, dass ich Code schreiben kann, wird also getestet, um den Code zu steuern, den ich jetzt schreibe. macht für mich keinen Sinn, ist umständlich und meistens Zeitverschwendung.

All das sagte, Tests sind wunderbare und magische Dinge , die alles richtig machen in der Welt . Sie korrigieren Ihren Code, sorgen dafür, dass Ihre App genau das tut, was Sie denken, und im Allgemeinen ist alles reibungsloser. Die Frage ist dann nicht, ob Sie Ihre Tests schreiben, bevor Sie codieren, oder ob Sie nach dem Codieren die Frage stellen, wie viel Zeit Sie für das Testen aufwenden werden. Das ist das eigentliche Problem, zumindest in meiner Erfahrung in der Softwareentwicklung. Testen kostet Zeit und Geld und muss im Rahmen konkurrierender Interessen durchgeführt werden.

Und so stimme ich Ihnen im Allgemeinen zu: TDD ist in der Praxis etwas umständlich und umständlich. An diesem Punkt müssen Sie bedenken, was in Ihrer aktuellen Situation am besten funktioniert . Wenn Sie kritischen Code schreiben, stellen Sie einfach sicher, dass er allgemein getestet wurde. Wenn Sie die Zeit haben, versuchen Sie es mit TDD, und prüfen Sie, ob der Prozess dadurch etwas verbessert wird.

Ich kann Ihren Ansatz nicht empfehlen.

Wenn ich Ihren Ansatz verwende, würde dies beispielsweise wie folgt aussehen (das Haus ist die Anwendung):

1. Ich beginne als Maurer mit etwas Wissen oder als Anfänger ein Haus für meine Familie zu bauen.
2. Ich kenne die Anforderungen wie Kinderzimmer, Gästezimmer und beginne mein "Prototyp" -Haus zu bauen.
3. Dann ist Ihr "Prototyp" -Haus ein paar Mal später fertig.
4. Ich beginne manuell zu schauen, ob die Struktur stabil genug ist. Also nehme ich viele Gewichte und bringe sie in die verschiedenen Räume im ersten Stock. Um sicherzustellen, dass die Decke nicht bricht, wenn ich mit meiner Familie in einem Raum sitze. Aber es bricht und ich beginne mit dem Refactoring. Zuerst die ganze Masse aufräumen. Dann baue es neu und teste es erneut manuell, bis es stabil genug ist.
5. Dann ziehe ich bei meiner Familie ein. Alles ist gut.
6. Eine Motte später kommen meine Cousins ​​und Eltern, um uns zu besuchen. Bevor sie unser Haus betreten können, müssen sie einen Architekten und einen Bauingenieur bezahlen, um sicherzustellen, dass die Decke nicht bricht, wenn wir in einem der Räume im ersten Stock sitzen.
7. Der Architekt und der Bauingenieur haben viel zu tun, weil sie zunächst nichts zu tun haben. Also müssen sie in mein Haus gehen und schauen, wie ich es baue.
8. Und wieder ist es nicht stabil genug. Sie müssen also den Boden im ersten Stock umgestalten.
9. Aber danach ist alles in Ordnung und alle können sicher mein Haus betreten.

Ihr Ansatz kostet also viel Zeit und viel Wissen, bevor ich das Haus mit Ihrem Ansatz baue. Oder es braucht ein bisschen Zeit! Es ist auch kein schöner Gentleman, andere Schreibtests für Ihren Code durchführen zu lassen, wenn sich die Anforderungen geändert haben.

Es gibt also einen besseren Ansatz, als einen "Prototyp" zu programmieren und mit dem Refactoring zu beginnen. Anstatt einen Prototyp zu programmieren, "erstellen Sie ein Design mit UML Ihrer Anwendung wie folgt.

1. Erstellen Sie ein UseCase-Diagramm. Sie können mit draw.io beginnen.
2. Erstellen Sie dann ein EPK-Diagramm, das auf Ihren UseCases basiert, um das Verhalten zu bestimmen. (VERHALTEN IHRER ANWENDUNG) Schnelleres Refactoring als Refactoring eines codierten Prototyps. Besonders wenn Sie ein Anfänger sind.
3. Erstellen Sie ein Klassendiagramm. (STRUKTUR Ihrer Bewerbung)
4. Stellen Sie fest, wo bei der Implementierung des Verhaltens Probleme auftreten können.
5. Schreiben Sie dazu einen einfachen Prototyp mit vielleicht 10 oder 20 Codezeilen, um festzustellen, wie Sie dieses Verhalten implementieren können. Gut für Anfänger. Oder schauen Sie sich ein Tutorial an und sehen Sie sich den Quellcode anderer Beispielanwendungen an. Wie sie es gelöst haben.
6. Dann starten Sie die Codierung. Führen Sie die erfolgreichen Tests Ihres UseCase durch. Dies kann auf verschiedene Arten erfolgen. Erstellen Sie zunächst die gesamte Struktur, die für den Test und den UseCase benötigt wird. Bei Verwendung von Enterprise Architekt kann die Struktur für Sie generiert werden. Basierend auf Ihren Diagrammen. Oder erstellen Sie die Struktur, während Sie den Test verdrahten. Es treten also keine Kompilierungsfehler auf. Erwähnen Sie hier, dass Sie NUR das VERHALTEN Ihrer Anwendung testen müssen. Die UseCases, die Sie haben.
7. Dann implementieren Sie das Verhalten Ihres UseCase.
8. Nach dem erfolgreichen Start von UseCases schreiben Sie Tests für die Ausnahmen. Und es fühlt sich immer gut an, wenn Sie die grünen Farben sehen, wenn Ihre Tests gültig sind;)
9. Und du bist fertig.

Sicher, dieser Ansatz erfordert auch einige Kenntnisse in UML, ist aber schnell zu erlernen. Und es ist immer schneller, eine Klasse umzubenennen oder Pfeile in einem Digramm zu verschieben, als dies in Ihrer IDE der Fall ist. Das Erlernen der Verwendung von Test-Frameworks wird am Anfang jedoch anstrengender sein. Am besten ist es, wenn Sie Open Source-Projekte testen und sehen, wie sie funktionieren. Aber wenn Sie eine testgetriebene Anwendung haben, wird die nächste Anwendung viel schneller sein. Und ich finde es ein gutes Gefühl zu wissen, dass alles gut funktioniert.

Deshalb stimme ich die Ansätze nur herab, weil sie für Anfänger sehr zeitaufwendig und schließlich nicht gut sind. Um eine saubere Grenze zwischen Ihrer Struktur und dem Verhalten zu haben, können Sie das domänengesteuerte Design verwenden und unter "Sehr Domäne mit zwei Paketen anordnen" (ein Paket mit dem Namen "Struktur" und das andere mit dem Namen "Verhalten"). Auch für Ihre Tests. Einfaches Beispiel Schauen Sie sich dieses in Java geschriebene Beispiel an.

Der Code, den ich schreibe, funktioniert. Es funktioniert, weil ich es manuell teste.

Haben Sie nach einer kleinen Änderung jeden möglichen Zweig Ihrer Bedingungen manuell getestet? Wie lange dauert die Rückkopplungsschleife Ihres manuellen Tests? Wie nahe es an der Rückkopplungsschleife liegt, können Sie mit automatisierten Tests feststellen.

Durch automatisierte Tests (egal, ob zuerst oder nicht) können Sie schnell voranschreiten - indem Sie eine schnellere Rückkopplungsschleife für Ihren Code bereitstellen.

Sind Sie sicher, dass Sie daran denken werden, eine Bedingung nach sechs Monaten manuell zu testen? Bitte sagen Sie nicht, dass Sie alle wichtigen zu testenden Bedingungen dokumentieren werden?

• Wählen Sie ein vertikales Stück Arbeit

• Entwickeln Sie einen funktionierenden Prototyp

• Refactor bis alles schön aufgeräumt ist

Und nochmal: Haben Sie beim Refactoring alle Logik, die vom Refactoring betroffen ist, manuell getestet? Wie lange dauert es, um Änderungen am Refactoring zu testen? Wenn das Refactoring Code bricht, wie lange dauert es, bis Sie einen Grund für Brüche finden?

• Lehnen Sie sich zurück und schätzen Sie den SOLIDEN und testbaren Code, den ich geschrieben habe.

Schöner und sauberer Code, den Sie genossen haben, ist sehr subjektiv. Ihr Code kann für Sie sauber und vernünftig sein. Die beste Methode, um zu überprüfen, ob Ihr Code wirklich lesbar, verständlich und testbar ist, sind Tests und Codeüberprüfungen, die von anderen Entwicklern durchgeführt wurden.

Sie fanden Ihren Weg sehr produktiv, nur weil Sie nur Entwickler sind, die mit dem Code arbeiten, und ich denke, weil Sie erst anfangen, in diesem Projekt zu arbeiten (Wie alt sind Sie in diesem Projekt, an dem Sie arbeiten? 6 - 8 Monate?).
Sie erinnern sich noch an alles, was Sie geschrieben haben, und können einen Grund für mögliche Probleme erkennen. Ich bin mir ziemlich sicher, dass Sie nach 2-3 Jahren Ihres Projekts von Anfang an Tests schreiben werden - weil Sie sicher sein möchten, dass Sie nichts vergessen.

Wenn Sie nie Fehler machen, brauchen Sie keine Tests. Die meisten Entwickler machen Fehler, aber wenn Sie dies niemals tun und Sie sicher sind, dass Sie in Zukunft niemals Fehler machen werden (und Sie sind der einzige im Projekt), gibt es wirklich keinen Grund, Zeit damit zu verschwenden, Tests zu schreiben.

Ihre Lösung ist jedoch auf halbem Weg, da Sie beim Ändern von Code das Schreiben von Tests vorschlagen. Gleichzeitig geht Ihre Methode jedoch davon aus, dass Sie bei der Entscheidung, für welche Teile des Codes Tests geschrieben werden sollen, keine Fehler machen werden. Dies funktioniert nur, wenn Sie immer genau wissen, welche Bereiche von einer Änderung betroffen sein können. Ich denke, viele gängige Entwickler (natürlich nicht Sie!) Haben die Erfahrung gemacht, Änderungen vorzunehmen, und dann schlägt ein Test an einer unerwarteten Stelle fehl, weil Sie einen Fehler gemacht haben.

Natürlich sollten eine gute Architektur, SOLID-Prinzipien usw. dies verhindern, aber die meisten Entwickler sind nicht perfekt, und deshalb sind systemübergreifende Tests wertvoll.