Umgang mit Wissensgefälle in Softwareprojekten

Vom Lehrstuhls Softwaresysteme der Uni Leipzig aus haben wir im Wintersemester 2018/19 an der Betreuung des Softwaretechnikpraktikums mitgewirkt. In diesem Rahmen sind wir gebeten worden, einige Erfahrungen weiterzugeben, wie Softwareteams mit dem Thema Wissensverteilung praktisch umgehen können.

Immer wieder kommt man in Softwareprojekten in die Situation, dass der Kenntnisstand der einzelnen Entwickler auseinander geht. Das Team muss damit zurecht kommen und im Idealfall schwächere Teammitglieder ausbilden. Dazu wird eine geeignete Team-Kultur benötigt, die im folgenden beschrieben wird. Darauf aufbauend wird exemplarisch das Werkzeug „Pair Programming“ konkret vorgestellt.

Eine Team-Kultur, die Entwickler entwickelt

Ein Wachstum ist nur möglich in einer Kultur, die Verbesserung fördert. Das setzt eine Kultur voraus, die Fehler zulässt und unverkrampft damit umgehen kann. Dafür gibt es einige Grundhaltungen, die vom Entwicklerteam gelebt und von den Führungskräften gezielt implementiert werden müssen:

  • Niemand muss alles richtig machen. Wir respektieren jeden unabhängig von seinem Output.
  • Jeder kann noch etwas dazulernen. Deshalb strebt jeder nach ständiger Verbesserung.
  • Wir ringen um ein gemeinsames Verständnis vom „besten Code“.
  • Wir sind offen für neue Herangehensweisen und Experimente.
  • Es darf über alles diskutiert werden und es darf auch alles in Frage gestellt werden. Wir nehmen das nicht persönlich, sondern verstehen es als Einladung zum Lernen.

Das Ziel ist es, eine Atmosphäre zu erreichen, in der gerne und viel diskutiert wird. So können unterschiedliche Sichtweisen zu Stilfragen, aber auch zu technologischen Präferenzen und Architekturentscheidungen ausgetauscht werden. Nicht immer ist es unter wirtschaftlichen Gesichtspunkten möglich, die Ergebnisse der Diskussion in laufenden Projekten auch direkt anzuwenden. Aber erzielt wird mindestens eine Verbreiterung des Erfahrungshorizonts und eine bessere Zusammenarbeit der Entwickler in zukünftigen Projekten.

Diese Kultur des gemeinsamen und voneinander Lernens kann ganz besonders intensiv im Pair Programming gelebt werden.

Entwickler entwickeln praktisch: Pair Programming

Beim Pair Programming arbeiten zwei Entwickler an einem Arbeitsplatz. Während ein Entwickler als „Navigator“ sich vorrangig mit der Planung der Arbeit und Seiteneffekten befasst, übernimmt der „Driver“ die Arbeit an der Tastatur. Der Navigator „steuert“ den Driver und gibt ihm Anweisung, was jeweils als Nächstes zu tun ist. Abhängig von der Erfahrung des Drivers variiert die Flughöhe der Anweisungen. Grundsätzlich ist auch ein regelmäßiger Wechsel dieser Rollen vorgesehen.

Im Folgenden werden kurz die Vorteile von Pair Programming erläutert.

Fokussierung, Code-Qualität und Effizienz

Pair Programming erhöht die Fokussierung des einzelnen Entwicklers. Dadurch, dass gemeinsam an einer Sache gearbeitet wird, reduziert sich die Gefahr, abgelenkt zu werden. Durch die unterschiedlichen Betrachtungsweisen der Entwickler auf den gleichen Code (Driver: Details, Navigator: Gesamtbild) ergibt sich ein deutlich größeres Potential zur frühzeitigen Fehlererkennung. Gleichzeitig werden Code-Smells, im Sinne von „schlechtem Code“ (was natürlich Verhandlungssache ist…) tendenziell eher vermieden, weil sie vom jeweils anderen Entwickler nicht unbedingt akzeptiert werden. Weiterhin steht das gesammelte Wissen zweier Programmierer zur Verfügung, was die Ideen und damit auch die Qualität der gebauten Lösung steigert.

Somit wird erwartet, dass im Pair Programming wesentlich weniger Aufwand für Refactoring und Debugging anfällt. In der Praxis zeigt sich, dass Pair Programming deutlich effektiver ist als Einzelprogrammierung mit anschließender Qualitätssicherung durch einen zweiten Entwickler.

Teambildung und Lerneffekte

Ein weiterer Vorteil von Pair Programming ist die Förderung der Teambildung. Durch die unmittelbare Zusammenarbeit lernen sich die Teammitglieder besser kennen und festigen ihre fachlichen Kommunikationsfähigkeiten. Außerdem entsteht durch die gemeinsamen Erfolge (und möglicherweise Misserfolge) ein Gemeinschaftsgefühl: Pair Programming schweißt zusammen.

Auf der anderen Seite befördert Pair Programming das Lernen. Jeder Entwickler kann von der Erfahrung des anderen profitieren bzw. ihn in gleicher Weise herausfordern, seine etablierten Praktiken zu hinterfragen. Das gilt auf allen Ebenen, von der Bedienung des Rechners oder der IDE über die Verwendung der Infrastruktur bis zur Strukturierung des Quellcodes auf Funktions-, Klassen-, Modul- oder Projektebene.

Paarkonstellationen

Spannend ist, wann der Lerneffekt beim Pair Programming am Größten ist. Verschiedene Konstellationen hinsichtlich des Erfahrungsgrads der Entwickler sind möglich:

  • Senior-Senior
    Hierbei kann man die höchste Produktivität beim Programmieren erreichen, da beide Entwickler sehr selbstständig sind, sich der Navigator ganz auf die Seiteneffekte konzentrieren kann und die Steuerung des Drivers auf einem sehr hohen Level erfolgt. Der Lerneffekt ist aber geringer, da Senior-Entwickler tendenziell seltener ihre etablierten Praktiken hinterfragen. Hier hat Pair Programming vor allem die Funktion der 4-Augen-Kontrolle.
  • Junior-Junior
    Diese Form findet seltener Anwendung, kann jedoch auch zu verbesserten Resultaten führen. Die gemeinsame Arbeit verstärkt oft das Vertrauen in den eigenen Code, was wiederum die Produktivität begünstigt.
  • Senior-Junior
    Diese Aufstellung bietet den idealen Lerneffekt. Der Junior-Entwickler kann von der Erfahrung des Senior-Entwicklers lernen. Dieser wird wiederum zu größerer Selbstreflexion motiviert, da er den Sinn seines Vorgehens erklären muss. Wichtig ist hierbei: Der Senior-Entwickler soll offen für alle Rückfragen sein und muss aufpassen, den Junior nicht durch seine feste Meinung oder sein Auftreten zu „erdrücken“. Wenn das gelingt, kann die Ausbildung sehr effektiv sein.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.