Entwicklungsübersicht

Heutige Software besteht in der Regel aus einer Reihe von Komponenten, die miteinander interagieren, um die für die Implementierung der Anwendung nötigen Aufgaben auszuführen. Die Entwicklung umfasst das Erstellen solcher Komponenten, indem Quellcode in einer der zahlreichen verfügbaren Sprachen geschrieben wird. Dieser Code definiert die grundlegenden einzelnen Aktionen, die vom Computer ausgeführt werden, damit das im Design der Anwendung festgelegte Endergebnis erzielt werden kann. Diese Aktionen können einfach sein, wie z.B. Zahlen addieren, Werte für Objekte innerhalb der Komponenten festlegen oder verschiedene Codeabschnitte auf Basis eines Wertevergleichs der im Code definierten Variablen ausführen. Zur Generierung der geforderten Ergebnisse sind auch komplexere mathematische Berechnungen in Code sowie die Anwendung von Logikabläufen nötig. Andere Aktivitäten im Rahmen der Entwicklung umfassen das Debuggen von Code, um Fehler aufzuspüren und zu beheben, die Arbeitsverfolgung anhand von formellen Methoden, den Einsatz von gemeinsam genutzten Code-Repositorys und die Teilnahme an Besprechungen mit den Themen Design, Planung, Feedback und Codeüberprüfungen.

In diesem Text werden die Entwicklungsaufgaben im Kontext des Lebenszyklus der Softwareerstellung beschrieben. Er hilft Ihnen, die Verantwortungsbereiche bei der Entwicklung, die übergeordneten Ziele sowie die ausgeführten Prozesse zu erkennen. In Abbildung 1 wird eine Übersicht des typischen Lebenszyklus der Softwareentwicklung angezeigt.

Abbildung 1: Lebenszyklus der Softwareentwicklung

Der Prozess der Softwareerstellung beinhaltet eine Vielzahl von Aufgaben, vom ursprünglichen Entwurf bis hin zur letztendlichen Bereitstellung und Kundenakzeptanz. Die Hauptaufgabe bei der Entwicklung besteht darin, den ursprünglichen Entwurf mithilfe von Tools (wie z.B. Microsoft Visual Studio) und Sprachen (wie Visual Basic, C# und JavaScript) in funktionierenden Code umzusetzen. Meist ist dies jedoch während des gesamten Lebenszyklus der Softwareentwicklung erforderlich, besonders, wenn Sie allein oder in einem kleinen Team arbeiten (in einem solchen Fall werden Sie häufig mit einer Aufgabenkombination aus Entwicklung, Tests und Architektur beschäftigt sein). In den folgenden Abschnitten werden die Hauptaufgaben der Entwicklung im Softwarelebenszyklus beschrieben.

Überprüfen von Kundenangaben und Projektzielen

Die erste Aufgabe beim Entwickeln einer Softwareanwendung besteht darin, Informationen zu erfassen und das übergeordnete Design gemäß den Kundenanforderungen zu entwerfen. Wenn das übergeordnete Design dann die Phase einer deutlich spezifischeren und technisch fokussierten Dokumentation durchläuft, sind Informationen zur technischen Implementierung nötig, damit Feedback zu den Möglichkeiten der Hardware und der praktischen Implementierung des Softwaredesigns gegeben werden kann. Somit lassen sich spätere Überraschungen vermeiden, außerdem wird sichergestellt, dass eine Implementierung des letztlichen Softwaredesigns in einer angemessenen Zeitspanne sowie auf verfügbarer Hardware und in vorhandener Infrastruktur möglich ist.

Schreiben von Code für Komponenten

Das ist die Hauptaktivität bei der Entwicklung, durch die der gesamte Prozess der Softwareerstellung vorangetrieben wird. Wer Code schreibt, arbeitet mit Spezifikationen oder einer Anforderungsliste, in der beschrieben wird, was eine Komponente oder ein Teil der Anwendung leisten soll, welche Ergebnisse erwartet werden und wie diese Komponente bzw. dieser Teil mit anderen Bestandteilen der Anwendung kommunizieren soll. Für diese Spezifikationen sind zahlreiche verschiedene Erscheinungsformen denkbar, es kann sich beispielsweise um Modelle, die in einer Standardsprache für Modellierung geschrieben sind, Beschreibungen der Funktionen oder schlicht Diagramme auf einem Whiteboard handeln.

Im Rahmen der Entwicklung werden mithilfe der Funktionen der ausgewählten Programmiersprache Quellcodedateien erstellt, in denen die benötigten Instruktionsreihen enthalten sind, die vom Computer ausgeführt werden sollen. Im Grunde genommen ruft Code eine Reihe von Eingabewerten ab, verarbeitet diese und gibt die Ergebnisse aus. Unter Umständen werden dazu andere Komponenten und Funktionen der Software herangezogen, und bei Bedarf können auch Codebibliotheken und vom Team geschriebene oder von Drittanbietern erworbene Funktionen verwendet werden. Die eingesetzten Entwicklungstools und Umgebungen, wie z.B. Microsoft Visual Studio (siehe Abbildung 2), können helfen, das Codeschreiben zu vereinfachen. Dazu werden Namen für Objekte und Variablen vorgeschlagen, Syntaxprüfungen ausgeführt, damit eine erfolgreiche Kompilierung gewährleistet ist, und Hinweise auf Fehler ausgegeben.

Abbildung 2: Microsoft Visual Studio 2010-Entwicklungsumgebung

Codeüberprüfung mit Teammitgliedern

Für alle von Entwicklern geschriebenen Codeabschnitte gibt es meist nicht nur eine richtige Lösung. Die Fähigkeiten eines Entwicklers bestehen darin, Features und Möglichkeiten von Codesprachen zu nutzen, um Code zu erstellen, mit dem die geforderten Aufgaben ausgeführt werden können. Dies kann auf zahlreichen Wegen erreicht werden. Verschiedene Entwickler können also unterschiedliche Ansätze und unterschiedliche Kombinationen von Codeanweisungen verwenden.

Eine von Kollegen und Vorgesetzten durchgeführte Codeüberprüfung erfüllt zwei wichtige Aufgaben. Zum Ersten fließen die Ansichten und Meinungen von mehreren Entwicklern ein, die möglicherweise andere Herangehensweisen bieten, auf bisher unbemerkte Fehler hinweisen oder Codeverbesserungen vorschlagen. Dadurch wird eine Optimierung von Codeeffizienz und -leistung erzielt. Zum Zweiten vertiefen sich durch den Wissensaustausch die Kenntnisse aller Teammitglieder, was im Verlauf der Zeit zu einer Leistungsverbesserung des gesamten Teams führt.

Kompilieren und Testen von Code

Abhängig von der verwendeten Codesprache umfasst die Entwicklung auch die Kompilierung von Quellcode, um diesen in eine Form umzuwandeln, die vom Computer ausgeführt werden kann. In der Regel wird diese Aufgabe von den Entwicklungstools und Umgebungen übernommen. Ein Teammitglied (zunächst der ursprüngliche Ersteller, danach die Tester) führt die Codeabschnitte aus, um sicherzustellen, dass alles wie geplant funktioniert. Wenn das Team einen Ansatz gemäß TDD (Test-Driven Design) verfolgt, sind zuvor von einem Teammitglied Komponententests geschrieben worden, die nun ausgeführt werden. So wird gewährleistet, dass der Code korrekt funktioniert und die geforderten Ergebnisse erzielt.

Das Kompilieren, Ausführen und Testen von Code ist ein schrittweiser Prozess, der während der Codeerstellung stattfindet. In der Regel wird zunächst der grundlegende Basiscode geschrieben, um das Konzept zu testen und sicherzustellen, dass der Code kompiliert und ausgeführt wird. Danach werden stufenweise Codeabschnitte hinzugefügt oder aktualisiert, um Leistung und Effizienz zu maximieren und gleichzeitig zu bestätigen, dass die gewünschten Ergebnisse erzielt werden.

Einchecken und Aktualisieren des Code-Repository

Bei den meisten mittelgroßen und großen Projekten wird ein Teaminformations- und Code-Repository-System (wie z.B. Team Foundation Server (TFS)) zum Speichern von Code, Dokumenten und Daten für das Projekt verwendet. Der Entwickler checkt den von ihm entwickelten Code ein, sodass er Bestandteil des übergeordneten Projekts wird und im Rahmen regulärer Builds in die Gesamtlösung kompiliert werden kann. Meist werden solche Builds täglich durchgeführt, und das Testteam arbeitet jeden Tag mit dem neuen Build, um neue Fehler aufzuspüren und zu gewährleisten, dass gemeldete vorhandene Fehler behoben worden sind.

Meist umfasst das Repository Arbeitsaufgaben und Berichte. Der Entwickler aktualisiert für den erstellten Code wichtige Arbeitsaufgaben, markiert die Arbeitsaufgaben für Fehler, die behoben wurden, und fügt der Aufgabe weitere relevante Informationen hinzu, die für andere Teammitglieder hilfreich sind, einschließlich Testteam und Dokumentationsteam. Das Team führt Berichte auf Basis dieser Arbeitsaufgaben aus, um den Projektfortschritt zu überwachen und anhaltende Probleme zu ermitteln. In Abbildung 3 wird Microsoft Visual Studio Team Foundation Server dargestellt.

Abbildung 3: Code- und Arbeitsaufgabenberichte in Microsoft Team Foundation Server

Implementieren von Änderungen sowie Debuggen und Beheben von Fehlern

Falls die Tests zu Berichten über Fehler im Code führen, muss ein Entwickler zurückgehen und die Ursache der Fehler finden, dann den Code ändern, um die Fehler zu beheben. Debugging beschreibt die Aufgabe, die Fehlerquelle zu finden, die sich an einer beliebigen Stelle im Code befindet und nur an dem während der Tests entdeckten Punkt auftritt. Manchmal wird das Debuggen auch als „Schwarze Kunst“ bezeichnet, da es sowohl Erfahrung als auch eine logische Herangehensweise erfordert. Dies gilt besonders, wenn der Fehler nur sporadisch auftritt oder kaum reproduzierbar ist.

Moderne Tools und Entwicklungsumgebungen wie z.B. Visual Studio bieten jedoch Features, mit denen Teammitglieder den Code durchgehen können, um die Variablenwerte und deren Änderungen zu beobachten. Dadurch wird die Fehlererkennung zu einem stark vereinfachten und logischen Prozess. Weitere Features und Tools, die eine Liste der ausgeführten Codeprozeduren sowie die Art und Weise der Verarbeitung durch den Computerprozessor bereitstellen, unterstützen das Team bei der Fehlersuche. Zudem kann das Team auf eine Instrumentation (wie z.B. Code zum Schreiben von Ereignissen zur Dateiprotokollierung) zugreifen, um die Codeausführung zu überwachen und bei der Fehlererkennung zu helfen.

Im Rahmen der kundenseitigen Akzeptanztests ist es durchaus üblich, dass Änderungen an Anwendungsfeatures verlangt werden, damit die Software exakt auf die Anforderungen des Kunden zugeschnitten ist. Der Entwickler implementiert diese Änderungen, meist auf Basis der überprüften Anforderungen und ausführlichen Angaben zur Wirkung dieser Änderungen auf die restliche Software. Mit einem guten, ursprünglichen Design, das eine korrekte Trennung der Zuständigkeiten für die einzelnen Komponenten aufweist, ist es einfacher, Änderungen zu implementieren, ohne dabei andere Anwendungsbestandteile zu beeinträchtigen.

Der Lebenszyklus der Softwareentwicklung ist ein schrittweiser Prozess, und so werden viele der beschriebenen Aufgaben im Verlauf des Entwicklungsverfahrens wiederholt ausgeführt. Beispielsweise kann das Team während der Entwicklung mehrere halbfertige Versionen der Software oder der Komponenten erstellen, die dann basierend auf den Testergebnissen und Kundenfeedback verbessert oder geändert werden.

Arbeiten im Team

Einige Entwickler arbeiten alleine oder in kleinen Gruppen, andere hingegen in großen organisierten Teams. Als Einzelperson oder in einem kleinen Team ist ein Entwickler möglicherweise für alle Aufgaben im Entwicklungslebenszyklus zuständig, einschließlich Design, Tests, Bereitstellung und Wartung. In größeren Teams gibt es meist separate Gruppen, die sich mit Design, Tests, Bereitstellung und Wartung auseinandersetzen, sodass sich der Entwickler mehr auf die Hauptaufgabe des Codeschreibens konzentrieren kann.

In der Regel arbeiten größere Teams mit Strukturen, um den Entwicklungslebenszyklus sowie den Entwicklungsprozess zu verwalten und zu überwachen. Es gibt viele verschiedene Ansätze, um die Softwareentwicklung in einem Team zu organisieren. Dazu zählen der herkömmliche entwurfsbasierte Zyklus, der auf nacheinander auszuführenden, im Voraus geplanten Aufgaben basiert (die „Wasserfallmethode“), und der auf Feedback basierende Ansatz, bei dem Planungen parallel ausgeführt werden und Entwicklungsaufgaben auf regelmäßigen Kundeneingaben basieren (die „Agile-Methode“). In Abbildung 4 werden diese beiden Hauptmethoden der Softwareentwicklung veranschaulicht.

Abbildung 4: Vergleich der Entwicklungsprozesse "Wasserfall" und "Agile"

Unabhängig von der verwendeten Entwicklungsmethode ist eine gute Kommunikation zwischen Teammitgliedern und Projektmanagern unerlässlich. Viele Teams arbeiten gemeinsam am selben Ort, aber immer häufiger werden auch Teammitglieder an anderen geografischen Standorten eingebunden. Für Besprechungen werden dann Telefon- und Videokonferenzen genutzt. In regelmäßig stattfindenden Besprechungen, an denen alle Teammitglieder einschließlich Entwickler, Softwaredesigner (Architekten), Tester und Projektmanagement teilnehmen, werden Fortschritte besprochen, Aktivitäten geplant und Feedback von anderen Teammitgliedern und Kunden eingeholt. Damit wird sichergestellt, dass die Entwickler ständig über die erforderliche Weiterentwicklung des Softwaredesigns auf dem Laufenden sind und auf regelmäßig eingehendes Feedback, das sich möglicherweise auf die Implementierung der Software auswirken könnte, reagieren können.

Zusammenfassung

An Softwareentwicklungen zu arbeiten, ist ein interessanter und herausfordernder Job, der zutiefst befriedigend sein kann. Er erfordert eine logische Denkweise und einen strukturierten Ansatz, außerdem gibt es viele Aufgabenstellungen, die sich nicht nur auf das Lernen von Codesprachen beziehen. Es gibt immer etwas Neues zu lernen, immer neue Anforderungen, die Recherchen erfordern, und neue Technologien, die ausprobiert werden wollen. Die Belohnung besteht darin, die fertige Softwareanwendung im Einsatz zu sehen und zu wissen, dass Sie Ihren Teil dazu beigetragen haben. Unsere heutige Welt wird von Software geprägt, und als Softwareentwickler liegt es an Ihnen, die Zukunft zu gestalten.