Bei der testgetriebenen Entwicklung handelt es um eine Methode, die in der agilen Entwicklung von Computerprogrammen angewendet werden kann. Wie bei allen Methoden gibt es auch für die testgetriebene Entwicklung Vor- und Nachteile. Am Anfang des Projektes investiert man mehr in die Entwicklungszeit, erhält dafür aber auch mehr Softwarequalität und als Entwickler mehr Freizeit während der Testphase.
Entscheidet man sich für die testgetriebene Entwicklung, muss man sich vorab Gedanken um das Testframework machen. In der Java-Welt wird hier die Wahl sehr wahrscheinlich auf JUnit fallen. Weiterhin muss bei der Projektplanung auch mehr Aufwand für die Entwicklung der Komponenten berücksichtigt werden, da man zusätzlich noch die Tests schreiben muss, die eine gewisse Testabdeckung erreichen sollten.
Man kann die testgetriebene Entwicklung jedoch gleich Nutzen um das Know-How für die entsprechende fachliche Funktionalität auf zwei Personen zu übertragen und mittels Paarprogrammierung die Aufgaben so aufteilen, dass ein Entwickler die Tests schreibt und der andere Entwickler die eigentliche Umsetzung schreibt; die Rollen sollen jedoch regelmäßig wechseln, da Testfälle schreiben nicht zu den Favoriten in der Entwicklung gehören. Durch dieses Vier-Augen-Prinzip kann man die Softwarequalität steigern, da die fachlichen Anforderungen von zwei Entwicklern überdacht werden und man so evtl. Missverständnisse frühzeitig aufdecken kann. Eine Paarprogrammierung ist jedoch bei der testgetriebenen Entwicklung nicht vorgeschrieben, sondern erhöht lediglich weiter die Softwarequalität und „überwacht“ die Umsetzung der geforderten Unit-Tests. Die Partner spornen sich gegenseitig an und können auch voneinander etwas lernen (Mentoring).
Der erhöhte Aufwand bei der Entwicklung wird sich durch die gesteigerte Softwarequalität dann bei den System- und Integrationstest, sowie durch eine geringere Fehlermenge beim Kunden kompensieren, vorausgesetzt man setzt konsequent für die Module die entsprechenden Unit-Tests um. Je später ein Fehler gefunden wird, desto teurer wird die Behebung.
Durch die konsequente Erstellung von Tests für einzelnen Funktionalitäten (Units) wird in den meisten Fällen eine höhere Modularität der fertigen Software erreicht. In C würde eine Unit einer Funktion entsprechen, in objektorientieren Sprachen eine Klasse mit ihren Methoden.
Da jeder erstellte Code sofort getestet wird, können Fehler frühzeitig aufgedeckt und entsprechend schnell und kostengünstig behoben werden. Bei einem späteren Refactoring kann man sofort erkennen, ob die Anwendung noch fehlerfrei funktioniert, da die Tests einen Großteil der Funktionalität sofort automatisiert prüfen können.
Um einen messbaren Erfolg mit der testgetriebenen Entwicklung zu erreichen und nicht nur auf den erhöhten Aufwand sitzen zu bleiben, sollte man eine die Testabdeckung automatisiert prüfen lassen. Wenn man JUnit zum Testen genutzt hat, kann man hierfür z.B. NoUnit nutzen oder sich einen Überblick auf Java-Source.net verschaffen.
Schreibe einen Kommentar