• 25.04.2024, 10:38
  • Registrieren
  • Anmelden
  • Sie sind nicht angemeldet.

 

Frage an Softwareexperte

Donnerstag, 7. März 2013, 10:47

Hallo Community,

ich führe im Rahmen eines Studienprojekts ein Fallstudie zum Thema "Software testen während oder nach der Entwicklungsphase? pro und contra" durch und würde gern von euch folgendes wissen:
1- Was sind die Vor- und Nachteile der Softwareuntersuchung während und nach der Entwicklungsphase aus Kosten und Zeitaufwand Sicht.
2- Wo liegt der Unterschied zwischen dynamischem und statischem Testen und welches Testverfahren aus Sicht der Softwareentwickler bzw. -Tester sinnvoller.

Danke schon mal.
Be or not to be, that ist the question

Donnerstag, 7. März 2013, 14:12

Testen sollte man auf jeden Fall während der Entwicklung, automatisiert und continously. Nach einem Release sind Fehler viel aufwändiger zu beseitigen, daher sollte man möglichst viele von ihnen im Vorfeld finden.

Donnerstag, 7. März 2013, 15:59

Testen sollte man auf jeden Fall während der Entwicklung, automatisiert und continously. Nach einem Release sind Fehler viel aufwändiger zu beseitigen, daher sollte man möglichst viele von ihnen im Vorfeld finden.
Er hat nicht von einem Release geredet....
Ich will wissen ob testen während oder erst nach der Entwicklung stattfinden soll und wo die vor und nachteile sind.


Edith meint:

Ich persönlich teste schon während der Entwicklung ob kleine Teile des großen ganzen funktionieren und geh dann den nächsten teil an.
Meist fällt dir dabei schon auf, was du vorher nicht bedacht hast.

Aber ich bin ja auch ein extrem programming Mensch ;)

Ich denke das man das nicht pauschalisieren kann, sondern von Programm abhängen machen muss.

Eins was durch extrem programming entsteht, sollte zwischendurch getestet werden.

Eins was geplant und dann umgesetzt wird, kann auch hinterher getestet werden.

So seh ich das zumindest.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »Ani« (7. März 2013, 16:02)

Donnerstag, 7. März 2013, 16:21

Als Tester habe ich einen statischen Zyklus lieber, da ich dann einen Build "in Ruhe" nach div . Kriterien unter die Lupe nehmen kann... Beim sogenannten Scrum Ansatz bekomme ich als Tester "den neuen Build über den Zaun geworfen", sobald er fertig ist, strukturiertes Testen ist m.E.n. so schwieriger, hängt aber auch individuell mit der Häufigkeit neuer Builds und damit der vorhanden Zeit für den Test zusammen... Wird schlimmer, je häufiger neue Builds kommen.

Donnerstag, 7. März 2013, 16:52

würde auch vermuten das es vom programm abhängt und vorallem vom betrachtungswinkel.

privat:
(visual basic programm)
ist es etwas kleines, dann schlies ich alles ab und teste am schluss ob auch das endergebnis past.
sitze ich an was gröserem, dann mache ich währenddessen viele kleine tests.

arbeit:
(einführung CRM)
hier läuft ohnehin alles über mehrer umgebungen.
sprich entwicklungen laufen einer entwicklungsumgebung.
dort macht der entwickler seine tests, ist der test aus seiner sich ok,
dann geht das programm in die qualitätssicherungumgebung.

ist der fachanwender mit dem ergebnis zufrieden läuft das ganze in die produktion.
findet er fehler, falsch berechnete kennzahlen, falsche beschriftung etc,
dann geht das ganze zurück an den entwickler und es fängt wieder von vorne an.

Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von »futureintray« (7. März 2013, 17:42)

powerslide

unregistriert

Donnerstag, 7. März 2013, 17:50

eigentlich will er ja wohl den klassischen v-modell / wasserfall ansatz mit agilen methoden aus testsicht verglichen..

aus der agilen sicht, gehört testen während der entwicklung einfach dazu. eine der base practices von extreme programing ist TDD (test driven development), wobei hier natürlich unit-tests gemeint sind.

und es ist meiner meinung nach ganz egal wie groß das teil ist, ne handvoll unit-tests sind sofort mitgeschrieben, und ich kann nach jedem build prüfen ob ich was kaputt gemacht habe.

wie yogi schon konkret angemerkt hat, steigt der aufwand einen fehler zu beheben je später man ihn findet. der worst case ist hierbei bei einem kommerziellen projekt der rückruf wenn die software schon produktiv im Einsatz ist.

wenn man das ganze mal schwarz/weiss malt:

testen nach der entwicklung:
typisches problem: man denkt, die software ist ja eigentlich fertig und dann dauert die Fehlerbehebung die in der nachgelagerten Testdurchführung gefunden wird genauso lange wie die Entwicklung bisher.
Der Testumfang ist natürlich auch riesig; dauert also entsprechend, und ich bekomme das Ergebnis erst viel später. Das kann durchaus mehrere Wochen in Anspruch nehmen.
Dann wird Fehlerbehebung betrieben, dann wieder getestet und das ganze dauert wieder ... usw usf .. das macht aus heutiger sicht einfach keinen Sinn.

testen während der Entwicklung.
okay malen wir hier mal die schöne heile welt:
es gibt unit-tests die schonmal einiges finden, parallel zur entwicklung werden systemtests gemacht, die tester sind optimal ins team integriert, wissn also bescheid welche funktionen bereits implementier sind und welche nicht.
Die direkte kommunikation erlaubt es Fehler meist direkt mit dem Entwickler zu klären, und die bugs werden auch direkt gefixt. am Ende einer iteration wird ein abschliessender Test durchgeführt, der nur noch sehr wenige fehler finden sollte.
diese werden dann in der nächsten iteration mit behoben.
prima..
der testaufwand am ende einer iteration wäcst hier kontinuierlich an.. sodass diese aktivät wenns dumm läuft länger dauert, als eine iteration.
was nun --> zauberwort testautomatisierung so hoch wie möglich
nachteil, das kostet geld und zeit.
aber man bekommt sehr schnell ergebnisse, die tester haben zeit für exploaritve tests.
die software wird so deutlich schneller eine reife erreichen als mit dem klassischen Ansatz!
am ende macht man eine test und bugfix iteration, die ausgelegt ist nur noch fehler zu eliminieren und keine neuen funktionen mehr zu integrieren.

zieht man das so durch, ist man auf nem sehr guten weg.

das mal in aller kürze ;)

Donnerstag, 7. März 2013, 19:44

Vielleicht sollte der OP mal "Entwicklungsphase" definieren. Wann genau soll die sein? Enthält die nicht auch Releases? Hört die Entwicklung überhaupt jemals auf?

Donnerstag, 7. März 2013, 20:06

Wann eine Software fertig ist das ist schon mal nicht leicht festzustellen. Da fangt das Problem meist an.
Meine Erfahrung sagt dass die Tests immer gleich bei der Entwicklung mitgemacht werden müssen. Alles andere endet irgendwann in der Sackgasse.
Es kommt aber immer auf die Applikation und auch auf die eingesetzte Sprache drauf an wie getestet wird.
Das Herzstück sollte immer ein Jenkins oder anderer CI Server sein.
Man sollte mit den ganzen JUnit/Hamcrest Tests anfangen über Mocking bis hin zu Oberflächentests mit Gebish usw.
Ich kommt eben aus der Java Welt.
Nichts ist schlimmer als ein Fehler der spät entdeckt wird und danach viel Arbeit in der Beseitigung kostet.
TDD ist sicherlich ein netter Ansatz wobei ich mir das nicht in allen Projekten vorstellen kann.
Gerade im Java Web Bereich ist der Ansatz von einem Release nach dem anderen nicht mehr gültig.
Jenkins fragt das SCM ab stößt den Build an führt die Tests durch wenn alles ok ist werden dann die fertigen war Files gleich auf den Tomcat deployed.
Softwaretests von den Entwicklern zu trennen halte ich auch nicht für wirklich sinnvoll. Der Entwickler soll seinen Code selbst Testen und auf die Code Abdeckung achten. Die Spezifikationen was der Code können muss bekommt er ja eh von der technischen Abteilung.
Die ganzen alten klassen Softwareentwicklungsmodelle passen einfach nicht mehr in die heutige Zeit. Das habe ich bei Projekten gesehen. Wenn ein Projekt in so ein Modell gezwängt wird kommt meist nichts Gutes dabei heraus.
Gerade bei Gebish also für die ganzen Webtests kann ich den Code für so ziemlich alle Browser Testen und jeder DAU kann die Specs schreiben. Der Entwickler muss dann nur mehr die Implementierung übernehmen.

Eine Applikation zu schreiben und sagen jetzt ist sie fertig halte ich für unmöglich. Das klingt nach Traumdenken eines Entwicklers der an Selbstüberschätzung leidet. Das mag eventuell für irgendwelche Bash Skripte funktionieren aber bei viel mehr auch schon nicht mehr.
Wie soll denn der Entwickler überhaupt wissen ob ein Algorithmus funktioniert oder eine Spezifikation genauso umgesetzt ist. Das beste sind ja dann die Fehler die erst im Produktivbetrieb auftreten. Das kostet dann wirklich viel Geld und spätestens dann zuckt der Projektmanager aus.
Man muss aber immer bedenken jeder Test der geschrieben wird kostet Zeit und Zeit ist Geld. Aber durch CI spart man sich dafür wieder die Zeiten für die Testdurchläufe.
For Windows reboot
for Linux be root