Elena Hollen über Code Reviews und Extreme Programming – Anwendungsentwickler-Podcast #123

Elena Hollen hat ihre Bachelorarbeit über Code Reviews und Extreme Programming geschrieben und erzählt mir alles darüber in der einhundertdreiundzwanzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Mit Code Reviews findest du Fehler früh und lernst durch den Austausch über fremden Code. Gemeinsam mit Elena Hollen habe ich bei der Alte Oldenburger erprobt, wie sich Reviews im Arbeitsalltag einführen lassen: In drei Wochen entstanden bei 26 Reviews rund 350 Anmerkungen und 18 gefundene Fehler in 30.000 Codezeilen. Als IT-Azubi kannst du dabei auch erfahrenen Entwickler:innen Feedback geben und andere Lösungswege kennenlernen. Für den Einstieg reichen Kommentare im Code und eine Versionsverwaltung, wobei du Zeit für die Reviews einplanen und respektvoll über den Code sprechen solltest.

Kapitelmarken

  • [00:00:00] Einstieg ins Thema Code Reviews
  • [00:01:03] Elena Hollen und ihre Arbeit mit technischen Dokumenten
  • [00:04:02] Weg in die IT und bevorzugte Programmiersprache
  • [00:06:24] Bachelorarbeit zu Softwarequalität und Extreme Programming
  • [00:07:34] Werte und Praktiken von Extreme Programming
  • [00:09:16] Feedback und Kommunikation durch Code Reviews
  • [00:10:49] Was ein Code Review ist und welche Formen es gibt
  • [00:12:06] Qualität und Wartbarkeit durch Reviews verbessern
  • [00:13:33] Offline-Reviews in der ersten Testphase
  • [00:15:42] Checklisten und gemeinsame Programmierregeln
  • [00:17:03] Statische Codeanalyse und Best Practices im Wiki
  • [00:19:09] Fragebogen zum Auswerten der Reviews
  • [00:20:53] Ergebnisse aus 26 Reviews
  • [00:22:25] Austausch über Codequalität im Team
  • [00:23:48] IT-Azubis reviewen erfahrene Entwickler:innen
  • [00:25:06] Respektvoll über Code sprechen
  • [00:26:45] Aufwand und mögliche Schwierigkeiten
  • [00:28:03] Reviews einführen und in den Arbeitsablauf einbauen
  • [00:29:54] Fachlichen Kontext geben und Code während der Entwicklung prüfen
  • [00:30:48] Reviews mit Pair Programming und TDD verbinden
  • [00:31:32] Fachliche Fehler im Code erkennen
  • [00:32:09] Anforderungen an Review-Werkzeuge
  • [00:34:37] Erfahrungen mit Agile Review
  • [00:35:42] Gemeinsame Snippets und einheitliche Review-Kommentare
  • [00:37:51] Reviews mit Code-Kommentaren und Versionsverwaltung
  • [00:38:48] Freiwillige Reviews im weiteren Arbeitsalltag
  • [00:42:06] Wirtschaftliche Gründe und Unterstützung durch Führungskräfte
  • [00:45:06] Bücher zu Extreme Programming und Soft Skills
  • [00:47:30] Fachbücher und weitere Quellen zum Lernen
  • [00:50:33] Regelmäßige Code Reviews in meiner Ausbildung
  • [00:51:14] Rückblick und Kontaktmöglichkeiten

Probeabo bei Audible (Affiliate)

Inhalt

Allgemeines zur Person

  • Wie ist dein Name und wo arbeitest du?
    • Elena Hollen, Technische Redakteurin bei der ALTE OLDENBURGER Krankenversicherung AG
  • An welchen Projekten arbeitest du zur Zeit in deinem Tagesjob?
    • Technische Redaktion, Toolauswahl für Code Reviews, viel schreiben, Compliance-Anforderungen, DSGVO, Dokumentation für den Fachbereich
  • Wie bist du zur Informatik bzw. Softwareentwicklung gekommen?
    • Nach der Realschule bin ich auf ein Fachgymnasium Wirtschaft gewechselt und habe dort im Abitur bereits etwas über Informatik gelernt, z.B. PHP, HTML, CSS, SQL, Excel. Der Bereich BWL hat mir aber auch viel Spaß gemacht. Ich bin kein „klassischer“ Nerd! 🙂 Aber ich mag es sehr, Probleme zu lösen. Meine persönliche Entscheidung war dann aber nach der Ausbildung, dass ich nicht 24/7 programmieren möchte. Daher habe ich die Stelle als technische Redakteurin angenommen.
  • Welche Ausbildung bzw. welches Studium hast du im Bereich der Informatik absolviert?
  • Was ist deine Lieblingsprogrammiersprache und warum?
    • Java, da in Ausbildung und Studium gelernt und auch aktuell im Einsatz.

Code Reviews und Extreme Programming

  • Worum geht es in deiner Bacherlorarbeit (z.B. Thema, Zielsetzung)?
    • Code Reviews zur Steigerung der Codequalität. Ich habe eine Studie zu Code Reviews bei der ALTE OLDENBURGER durchgeführt. Ziel war die Verbesserung der Kommunikation und Feedback.
  • Was ist Extreme Programming und wer braucht das?
    • Extreme Programming wurde von Kent Beck entwickelt. Es legt den Fokus auf den Menschen. Die Werte sind u.a. Feedback und Kommunikation, die Prinzipien z.B. Menschlichkeit und Praktiken sind z.B. TDD und Code Reviews.
  • Was sind Code Reviews?
    • Eine manuelle Prüfung von Code ohne Automatisierung. Der Code, der von einem Autor erstellt wird, wird von einem Reviewer kontrolliert.
  • Was sind die Ziele von Code Reviews?
    • Fehler finden, Selbstkontrolle, Einheitlichkeit des Codes, langfristige Wartbarkeit.
  • Welche Varianten von Code Reviews gibt es?
    • Walkthrough, Review mit Checkliste, Inspektion mit detaillierten Phasen.
  • Was wurde bei der AO gemacht?
    • Einfache Reviews ohne Checkliste. Es gab einen Leitfaden mit Fragen, z.B. Anzahl Lines of Code gereviewt, Fehler/Anmerkungen gefunden, technischer Mehrwert und was habe ich gelernt? Die Auswertung war auch eine gute Begründung für den Chef. Es gab eine Testphase mit 17 Entwicklern, die 1x pro Woche ein Review durchgeführt haben. Insgesamt wurden 26 Reviews durchgeführt.
  • Was sind die Vor- und Nachteile von Code Reviews?
    • Vorteile: Einfacher Start ohne großen Aufwand möglich. Eine Checkliste sollte gemeinsam erarbeitet werden. Best Practices ergeben sich im Prozess.
    • Nachteile: Gefühl von Kontrolle. Es entstehen Kosten (Arbeitszeit), der Chef sollte also gefragt werden.
  • Was sind die Ergebnisse deiner praktischen Studie zu Code Reviews in der AO?
    • 30.000 LOC gereviewt, 18 Fehler gefunden, 350 Anmerkungen geschrieben, Wissenssilos aufgebrochen, viel gelernt (jeder Teilnehmer), Anregung über Qualität nachzudenken, Austausch mit anderen Entwicklern, keine Probleme aufgetreten, zwischenmenschlich hat es super geklappt.
  • Welche praktischen Tipps für die Einführung von Code Reviews hast du?
    • Zu Beginn muss oft eine ablehnende Haltung der Entwickler überwunden werden. Ein Kümmerer als Ansprechpartner ist nötig. Eine Integration in den Entwicklungsprozess ist nötig. Das Feedback der Teilnehmer muss berücksichtigt werden. Zu Beginn sollte erstmal eine Einführung in den zu reviewenden Code gegeben werden, damit der Reviewer weiß, worum es geht. Perfekter Code ist nicht nötig! Fachliche Fehler können gefunden werden.
  • Macht Pair Programming Code Reviews überflüssig?
    • Nein, sie bilden eine Symbiose, auch TDD passt gut dazu.
  • Können auch Azubis schon Code Reviews durchführen?
    • Ja! Ein Austausch mit langjährigen Entwicklern war möglich. Andere Meinungen werden diskutiert. Es wurden viele Fragen gestellt. Und sogar Anmerkungen von Azubis wurden umgesetzt.
  • Welche Tools benötigt man für Code Reviews?
    • Erstmal sind keine Tools nötig, Kommentare im Code reichen. Tool ist evtl. Overkill im Prozess. Es gibt aber viele Tools am Markt. Zunächst sind die eigenen Anforderungen zu klären und dann ein Tool zu suchen (z.B. IDE-Plugin, Git, keine DB, Gruppenverwaltung). Fehler vs. Anmerkungen sollten unterschieden werden können.
  • Wie geht es mit den Code Reviews bei der AO weiter?
    • Jeder Entwickler entscheidet selbst, ob und wie oft Code Reviews durchgeführt werden. Tool suchen. Es gibt keine Kontrolle, die war nur für die Bachelorarbeit nötig. Langfristige Motivation ist nötig, ein Kümmerer ist sinnvoll. Code Reviews werden bereits in die Ausbildung integriert.
  • Kann man die Einführung von Code Reviews auch monetär begründen?
    • Na klar! Wann sind Fehler am teuersten? Wenn der Code schon auf der Produktion läuft! Wir haben in 3 Wochen 18 Fehler gefunden, und zwar vor derm Deployment! Das Management muss von Anfang an einbezogen werden.

Aus- und Weiterbildung

  • Was ist das letzte Fachbuch mit Bezug zur Programmierung, das du selbst gelesen hast?
    • Soft Skills von John Sonmez.
  • Was ist dein absolutes Lieblingsbuch mit Bezug zur IT/Programmierung und warum?
    • Extreme Programming Explained von Kent Beck (bitte auf Englisch!).
  • Welche Quellen kannst du für die Aus- und Weiterbildung im Bereich Programmierung empfehlen und warum?
    • Wissenschaftliches Arbeiten macht Spaß und man lernt sehr viel dabei. Quellen sind u.a. Springerlink und Google Scholar.
    • Auf GitHub findet man viel Code, an dem man selbst lernen kann.

Abschluss

  • Wo können die Hörer mehr über dich erfahren bzw. dich kontaktieren?

Literaturempfehlungen

Extreme Programming Explained: Embrace Change (Affiliate)*

Soft Skills:The software developer's life manual (Affiliate)*

Links

Zusammenfassung

Wie Elena zum Thema kam

Bei der Alte Oldenburger hat Elena Hollen ihre Ausbildung zur Fachinformatiker:in für Anwendungsentwicklung bei mir abgeschlossen und anschließend Wirtschaftsinformatik studiert. Nach ihrem Bachelor begann sie ein berufsbegleitendes Masterstudium. Beruflich schreibt sie technische Dokumente und kümmert sich darum, wie diese geordnet und gepflegt werden. Dabei arbeitet sie mit Fachabteilungen und IT-Kolleg:innen zusammen, etwa wenn Abläufe beschrieben oder rechtliche Vorgaben berücksichtigt werden müssen.

Über den Informatikunterricht am Wirtschaftsgymnasium fand sie zur Anwendungsentwicklung. Java blieb ihre bevorzugte Programmiersprache, auch nachdem sie sich beruflich stärker mit Dokumenten beschäftigte.

Der Bezug zu Extreme Programming

Für ihre Bachelorarbeit untersuchte Elena, wie Praktiken aus Extreme Programming (XP) die Softwarequalität im Unternehmen verbessern können. Das von Kent Beck entwickelte agile Vorgehen richtet sich an kleine bis mittelgroße Projekte und stellt die Menschen, die Software entwickeln, in den Mittelpunkt.

Aus abstrakten Werten ergeben sich Prinzipien, aus denen konkrete Praktiken folgen. Beispielsweise gehört Feedback zu den Werten; Test-Driven Development ist eine konkrete Praktik. Code Reviews greifen den Wunsch nach Rückmeldungen auf und schaffen einen Anlass, mit anderen Entwickler:innen über Code zu sprechen.

Bei der Alte Oldenburger kamen bereits einzelne XP-Praktiken zum Einsatz. Elena untersuchte zunächst, welche Werte im Arbeitsalltag gelebt wurden, und leitete daraus passende Ansätze ab. Code Reviews sollten dazu beitragen, häufiger fachlich miteinander zu sprechen und Feedback zu bekommen.

Was bei einem Code Review passiert

Wenn du Code geschrieben hast, schaut sich ein:e Reviewer:in diesen manuell an, sucht nach Fehlern und hält Hinweise fest. Dabei fließen die eigenen Erfahrungen der prüfenden Person ein. Im Gespräch werden folgende Formen beschrieben:

  • Walkthrough: Der/die Autor:in geht den Code gemeinsam mit einer kleinen Gruppe durch.
  • Review mit Checkliste: Ein:e Reviewer:in prüft den Code anhand festgelegter Fragen, während der/die Autor:in abwesend ist.
  • Inspektion: Die Beteiligten folgen einem ausführlicheren Ablauf mit eigenen Phasen, etwa zum Planen und Vorbereiten.

Durch eine zweite Person werden Fehler sichtbar, während verständlicher Code leichter gepflegt werden kann. Schon das Wissen, dass später jemand hineinschaut, beeinflusst die Sorgfalt beim Programmieren. Diesen Effekt habe ich selbst während der Testphase erlebt.

Wie die erste Testphase ablief

Innerhalb der acht Wochen für Elenas Bachelorarbeit wurde ein Offline-Review erprobt: Ein:e Reviewer:in schaute sich den Code zunächst allein an. Als Einstieg gab es einen Leitfaden. Eine Checkliste hätte zusätzlich erarbeitet werden müssen und hätte den Rahmen der Arbeit überschritten.

An der dreiwöchigen Testphase nahmen 17 Entwickler:innen teil. Vorgesehen war, dass jede Person wöchentlich einmal fremden Code prüft und einmal eigenen Code prüfen lässt. Die Teilnahme war freiwillig. Insgesamt fanden 26 Reviews statt.

Die Paare wurden ausgelost, sodass auch IT-Azubis den Code von Senior-Entwickler:innen prüften. Auf diese Weise sollten Verzerrungen durch gezielt ausgewählte Paare verringert werden.

Für jedes Review erstellte Elena einen Fragebogen, mit dem sie unter anderem Folgendes erfasste:

  • Wer den Code geschrieben und wer ihn geprüft hatte.
  • Wie viele Codezeilen betrachtet wurden.
  • Welche Fehler gefunden und welche Anmerkungen geschrieben wurden.
  • Ob der/die Autor:in die Hinweise aufgegriffen hatte.
  • Was beide Personen technisch oder fachlich gelernt hatten.
  • Wie die Beteiligten das Review in einem freien Textfeld bewerteten.

Was die Reviews gebracht haben

Bei rund 30.000 geprüften Codezeilen entstanden 350 Anmerkungen, außerdem wurden 18 Fehler gefunden. Beide Rollen konnten technisch voneinander lernen. Fachlich fiel der Lerngewinn geringer aus, weil sich die Beteiligten zunächst in unbekannten Code einarbeiten mussten.

Beim Lesen fremder Programme beschäftigten sich die Teilnehmer:innen stärker damit, was guten Code ausmacht. Aus wiederkehrenden Hinweisen entstand auf Initiative eines/einer Entwickler:in ein Wiki-Artikel mit gemeinsamen Best Practices, den weitere Reviewer:innen ergänzten.

Als IT-Azubi kannst du aktuelle Sprachfunktionen einbringen und nach den Gründen für eine Lösung fragen. In einem Beispiel prüfte ein:e IT-Azubi den Java-Code eines/einer Entwickler:in mit etwa 15 Jahren Erfahrung. Beide lernten dabei etwas. Durch solche Gespräche bekommst du zusätzlich zu den Hinweisen von deinem/deiner Ausbilder:in weitere Perspektiven auf das Programmieren.

Checklisten und automatische Prüfungen

Für eine spätere Checkliste eignen sich Fragen dazu, wie Variablen benannt werden oder ob der Code den üblichen Konventionen der Sprache folgt. Auch gemeinsam vereinbarte Lösungen können darin stehen. Im Unternehmen wurde beispielsweise eine bestimmte Art vereinbart, Fehler in Natural ähnlich wie mit Try-Catch in Java zu behandeln.

Aus wiederkehrenden Review-Hinweisen lassen sich solche Regeln schrittweise entwickeln. Technisch prüfbare Regeln können später in eine statische Codeanalyse einfließen. Zum Zeitpunkt der ersten Testphase gab es diese im Unternehmen noch nicht.

Für fachliche Fragen braucht es Menschen, die verstehen, was das Programm leisten soll. Im Review lässt sich untersuchen, ob die implementierte Lösung zu den fachlichen Anforderungen passt. Pair Programming und Test-Driven Development lassen sich mit zusätzlichen Reviews verbinden.

Wie du Reviews im Alltag einführst

Beim Start können sich Entwickler:innen kontrolliert fühlen. Außerdem braucht jedes Review zusätzliche Arbeitszeit. Für Elenas Versuch war deshalb die Unterstützung durch die Führungskraft wichtig.

Damit Reviews im Alltag funktionieren, helfen folgende Schritte:

  • Sorge dafür, dass ein:e Ansprechpartner:in Fragen beantwortet und Termine organisiert.
  • Plane die nötige Zeit im Entwicklungsprozess ein.
  • Lege fest, wann ein Review stattfindet, etwa nach dem Programmieren und vor dem Testen.
  • Frage die Beteiligten nach ihren Erfahrungen und passe den Ablauf daran an.
  • Gib dem/der Reviewer:in vorab fachlichen Kontext zum Code.
  • Besprich Hinweise respektvoll und arbeite gemeinsam daran, den Code zu verbessern.

Du kannst Code bereits während der Entwicklung prüfen lassen. Auch bei sauber geschriebenem Code lohnt sich der Blick auf mögliche fachliche Fehler.

Nach der ersten Testphase folgte eine längere zweite Phase, in der Rückmeldungen aus dem ersten Versuch aufgegriffen wurden.

Welche Werkzeuge ausprobiert wurden

Bei der Suche nach einem Review-Werkzeug waren ein Eclipse-Plugin und eine Git-Anbindung wichtig. Das Werkzeug sollte Gruppen abbilden und Fehler von allgemeinen Anmerkungen unterscheiden können. Die Kommentare sollten auch zugänglich bleiben, wenn später ein anderes Werkzeug gewählt würde.

GitHub Enterprise und Collaborator passten aufgrund ihres Umfangs beziehungsweise ihrer Abläufe wenig zu den gewünschten Reviews. Im vorgesehenen Ablauf setzte der/die Autor:in die Hinweise eigenständig um; das Team vertraute darauf, dass dies geschah.

Das Open-Source-Plugin Agile Review setzt Anker in den Code und speichert Kommentare in separaten XML-Dateien. Nach einem dreiwöchigen Test empfand das Team es für den eigenen Alltag als hinderlich.

Ich arbeite außerdem mit einem Snippet-Werkzeug, über das sich Codevorlagen in einem Git-Repository teilen lassen. SnipMatch aus dem Eclipse-Umfeld ermöglicht solche gemeinsamen Vorlagen. Für die Reviews wurden damit einheitliche Kommentare vorbereitet, die eine Review-Kennzeichnung sowie Name und Datum enthielten.

Im weiteren Ablauf schrieb der/die Reviewer:in Hinweise direkt als Kommentare in den Code und commitete sie. Dafür genügten der Zugriff auf den Code und die Versionsverwaltung.

Wie es im Unternehmen weiterging

Nach der zweiten Testphase blieben Reviews für die Entwickler:innen freiwillig. Jede Person durfte selbst entscheiden, wie häufig sie ein Review machte und mit wem. Elena erinnerte in regelmäßigen Besprechungen daran und kümmerte sich weiter um die gemeinsamen Best Practices. Ein passendes zusätzliches Werkzeug wurde weiterhin gesucht.

Bei meinen IT-Azubis habe ich einen festen Rhythmus eingeführt: Alle zwei Wochen prüft jede Person den Code eines/einer Kolleg:in und lässt eigenen Code prüfen. Ich reviewe ebenfalls ihren Code; außerdem finden Reviews zwischen IT-Azubis statt.

Warum frühe Fehler wirtschaftlich relevant sind

Wenn ein Fehler während der Entwicklung auffällt, lässt er sich günstiger beheben als später im produktiven Betrieb. Nach längerer Zeit muss sich der/die Entwickler:in zusätzlich wieder in den Code einarbeiten. Die 18 gefundenen Fehler lieferten im Versuch ein Argument dafür, die nötige Arbeitszeit bereitzustellen. Eine konkrete Geldsumme wurde im Gespräch dazu nicht genannt.

Als IT-Azubi kannst du einen ersten Austausch anstoßen, indem du eine:n Kolleg:in um Feedback zu deinem Code bittest oder anbietest, dessen/deren Code anzuschauen.

Bücher und Quellen zum Weiterlernen

Elena empfiehlt Extreme Programming Explained von Kent Beck, bevorzugt auf Englisch. Das Buch behandelt neben dem Programmieren auch den Umgang miteinander und die Werte von XP.

Als weitere Empfehlung nennt sie das im Gespräch als Software Developers Life Manual bezeichnete Buch von John Sonmez, das sie von mir zum Bachelor bekommen hat. Darin geht es unter anderem um Soft Skills für Softwareentwickler:innen.

Für vertiefende Fragen greift Elena auf Fachbücher zurück und sucht über SpringerLink sowie Google Scholar nach Quellen. Auf GitHub entdeckt sie Werkzeuge und Open-Source-Projekte. Ihr Lernstil hat sich während der Ausbildung und des Studiums verändert; inzwischen schätzt sie ausführlich aufbereitete Themen in Büchern, die sie auch in wissenschaftlichen Arbeiten zitieren kann.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:00] Herzlich willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker

[0:09] für Anwendungsentwicklung. In dieser Episode gibt es ein Interview mit Elena Hollen zum

[0:14] Thema Code Reviews. Viel Spaß!

[0:20] Hallo und herzlich willkommen zur 123. Episode des Anwendungsentwickler-Podcasts. Mein Name

[0:27] ist Stefan Macke und heute geht es um ein Thema, das bestimmt, wie ich glaube, in vielen

[0:33] Unternehmen sträflich vernachlässigt wird, und zwar Code Reviews. Eine super einfache

[0:38] und kostengünstige Möglichkeit, die Qualität deines Codes und auch des Codes deines Unternehmens

[0:44] zu optimieren. Und bevor ich da jetzt noch weiter darüber schwadroniere, leite ich direkt

[0:49] über zum Interview, denn Elena Hollen, mit der ich heute darüber spreche, hat ihre Bachelorarbeit

[0:54] zum Thema Code Reviews geschrieben. Die kann uns also sehr gut Auskunft über das ganze

[0:58] Thema geben. Ich wünsche dir viel Spaß beim Interview und ja, auf geht's!

[1:03] Hallo Elena, schön, dass das heute geklappt hat mit unserem Interview zum Thema Code Reviews.

[1:09] Da bin ich ganz gespannt drauf, weil es sicherlich was ist, was auch für viele Leute ja draußen

[1:14] interessant ist. Vielleicht werden ja bei dem einen oder anderen sogar schon Codes

[1:17] gereviewt, wenn man noch in der Ausbildung ist, oder man reviewt selber Code bei anderen.

[1:20] Von daher, ich finde das sehr wichtig, weil es auch schön die Qualität steigern kann,

[1:23] aber bevor wir da einsteigen, vielleicht erzählst du den Leuten mal, wer du eigentlich bist und was

[1:28] du so machst in deinem Alltag. Hi, ich bin Elena Hollen. Ich arbeite,

[1:33] wie Stefan auch, bei der Alte Oldenburger. Ich habe jetzt gerade im letzten Sommer meinen

[1:37] Bachelor gemacht, Wirtschaftsinformatik. Ich habe auch davor schon eine Ausbildung zur

[1:42] Fachinformatikerin für Anwendungsentwicklung gemacht bei Stefan. Genau, seit Sommer arbeite

[1:49] ich nebenbei einen Master Wirtschaftsinformatik an der Australierhochschule nebenbei im Online-Studium.

[1:58] Was ich jetzt hier machen darf, sind technische Dokumentation, Dokumentationsmanagement. Da geht

[2:04] es dann um die Erfüllung von Complianceanforderungen, DSGPO, GOBD und so weiter. Das geht dann um

[2:13] Verfahrensdokus, Benutzerdokus, Projektdokus. Auf langer Sicht gesehen wäre es mir auch ein

[2:19] Herzensanliegen, Softwaredokumentation hier nochmal einen Blick reinzuwerfen, da noch

[2:25] mehr machen zu können. Okay, da brauchen wir auf jeden Fall später noch eine Episode zum

[2:31] Thema Softwaredokumentation. Das höre ich da schon raus. Aber was macht man denn als technischer

[2:35] Redakteur dann so im Tagesjob? Also schreibst du da wirklich die ganze Zeit nur Texte oder wie

[2:40] kann man sich das vorstellen? Es ging am Anfang darum, die Dokumentation der Rechnungslegung,

[2:50] oder wie soll man das sagen, wie wir Rechnungen schreiben, ETC zu dokumentieren bzw. weiter zu

[2:57] dokumentieren. Da habe ich wirklich den ganzen Tag nur geschrieben, eng mit dem Fachbereich

[3:00] zusammengearbeitet, mit denen dann so Anwendungsdokumentation geschrieben, Benutzerdokus.

[3:09] Jetzt geht es viel um Complianceanforderungen. Die DSGVO steht ja vor der Tür, da darf ich dann

[3:18] viele Sachen mit den Leuten zusammenschreiben und mache jetzt demnächst auch die Dokumentation

[3:29] von einer Fachabteilung, die Leistungsabrechnung oder die Leistungsabteilung bei uns. Das ist auch

[3:36] wieder die Zusammenarbeit mit den EDV-Lernen und auch mit den Fachbereichen. Und es geht

[3:41] natürlich auch um Sachen wie Dokumentationsmanagement, wie bekomme ich es hin,

[3:46] dass es nicht einfach nur ein Wirwarr von irgendwelchen Dokumenten auf dem Dateisystem

[3:50] ist, sondern dass es ein bisschen Struktur hat. Ich bin jetzt auch gerade erst mit angefangen,

[3:57] es ist auch eine neue Stelle, von daher sind das noch viele Sachen, die da zusammenkommen.

[4:02] Aber du bist ja, als du angefangen hast, schon im Bereich Informatik gestartet. Wie bist du denn

[4:08] damals überhaupt zur Informatik gekommen? Hat sich das schon immer interessiert oder wie kam es dazu,

[4:13] dass du da eine Ausbildung bei mir gemacht hast? Nee, überhaupt nicht. Ich habe heute nochmal in

[4:18] Gesprächen mit Kollegen festgestellt, dass ich überhaupt kein Nerd bin, ganz im Gegenteil. Ich

[4:24] bin auch so überhaupt nicht angefangen. Ich habe ein Wirtschaftsgymnasium besucht und habe dann da

[4:30] BWL und auch Informatik gehabt. Wir haben dann so Sachen gemacht wie PHP, HTML, CSS, SQL und das

[4:37] hat mir sehr gut gefallen. Ich wollte meinen Job machen, bei dem ich Probleme lösen kann, damals

[4:42] zumindest. Und weil mir BWL auch gut gelegen hat, habe ich mich dann für Wirtschaftsinformatik

[4:47] entschieden. Und dieses Probleme lösen, da bietet sich die Anwendungszentrale mir eigentlich sehr an.

[4:52] Und war nur noch froh, als ich hier anfangen konnte und so bin ich dann dahin gekommen und habe mich

[4:59] aber während des Studiums entschieden. Okay, Softwareentwicklung, schön und gut, aber 24-7 das

[5:04] zu machen, na, nicht unbedingt. Deswegen hatte ich auch die schöne Möglichkeit, hier dann einen

[5:11] anderen Bereich bearbeiten zu dürfen. Und ja, falls es jemanden interessiert, wie so ein duales

[5:18] Studium abläuft, da habe ich zum Beispiel auch schon mal mit Elena darüber gesprochen in einer

[5:21] Episode, die natürlich alles in den Shownotes nochmal später dann verlinkt. Aber trotzdem noch

[5:26] eine Frage, die ich eigentlich jedem Gast hier immer stelle. Du hast ja mal eine Zeit lang

[5:29] programmiert. Gibt es da so eine Art Lieblingsprogrammiersprache, mit der du mal

[5:32] gearbeitet hast? Oder findest du die alle gleich gut oder wie sieht das aus? Ja, also ich habe ja

[5:38] bei der Java gelernt. Das ist auch noch wie vor meine Lieblingsprogrammiersprache. Ich mache im

[5:44] Studium, wenn wir da dann was programmieren müssen, für Module wie zum Beispiel sowas wie

[5:49] Quantitative Entscheidungslehre, mache ich auch immer alles mit Java. Das bietet sich da auch

[5:55] mal ganz gut an. Ich habe ja daneben bei Nachschule ein wenig gelernt, aber Java nach wie vor. Okay,

[6:03] sehr schön. Das passt zu mir. Inzwischen mag ich die Sprache auch ganz gerne, weil ich aber

[6:06] damit arbeiten muss. Und was ist noch? Das Stockholms-Syndrom. Wenn ich meinen Führer lerne

[6:12] zu lieben, so ist es auch eine Programmiersprache. Ich finde inzwischen ganz gut. Es ist ja auch

[6:15] gerade Java 10 rausgekommen mit coolen neuen Features. Also ich mag die Sprache inzwischen

[6:19] auch ganz gerne. Ja, sehr schön. Dann würde ich sagen, gehen wir mal ins Thema des heutigen

[6:24] Interviews, nämlich zum Thema Code Reviews. Ich finde, da wäre ein Einstieg ganz gut,

[6:28] wenn du ein bisschen erzählst, wie du zu dem Thema gekommen bist, denn du hast dich ja in

[6:31] deiner Bachelorarbeit damit auseinandergesetzt. Vielleicht kannst du mal so ein bisschen

[6:34] erzählen, worum es da eigentlich ging. Was hast du eigentlich so gemacht?

[6:37] Genau. Vor mittlerweile einem Jahr schon bin ich mit der Bachelorarbeit angefangen. Da hat

[6:43] man sich ja vorher überlegt, okay, was kann man schönes machen. Ich habe dann jedes Glück gehabt,

[6:47] dass ich mir erst mal ziemlich frei aussuchen konnte, okay, was möchte ich denn machen. Das

[6:52] muss natürlich hier reinpassen und auch ganz mehr wegbringen. Ich wollte gerne was machen oder mich

[6:57] mit Softwarequalität hier beschäftigen und bin dann auf Extreme Programming gestoßen, was Stefan

[7:03] ja auch schon im Rahmen der Ausbildung erklärt hatte. Ich habe mich dann darum gekümmert. Das

[7:11] Thema war die Qualitätssteigerung in Softwareentwicklungsprojekten durch den Einsatz von

[7:16] Extreme Programming ansetzen. Das Ziel war es halt, mit den Praktiken von Extreme Programming zu

[7:23] schauen, wie man hier die Softwarequalität oder die Werte, die hier gelebt werden, noch verbessern

[7:29] kann. Also ich finde XP immer ein wichtiges Thema. Wird auch häufiger mal in der Prüfung

[7:34] abgefahren, zumindest in der mündlichen. Kannst du mal was zu diesen Praktiken sagen? Was verbirgt

[7:40] sich eigentlich dahinter? Erst mal so als Einstieg. Das wurde von Kent Beck als Leben gerufen. Den

[7:48] kennt man ja eigentlich schon. Der hat 2000 ein Buch dazu geschrieben. 2015, weiß ich gar nicht,

[7:54] hat er eine neue Auflage gehabt. Das ist halt die Möglichkeit, eine agile Form des Modells in der

[8:03] Softwareentwicklung zu vereinen. Das zeichnet sich halt durch die Leichtigkeit aus und der

[8:08] Fokus liegt ja auf den Menschen, die die Software programmieren. Genau, das Einsatzgebiet ist im

[8:15] kleinen bis mittelgroßen Projekten, wie er das angibt. Und womit ich mich in meiner Bachelorarbeit

[8:20] stark beschäftigt habe, waren die Werte, Prinzipien und Praktiken, die aufeinander aufbauen. Ganz kurz,

[8:25] die Werte ist das Gefühl, das ein Entwickler bei der Entwicklung haben soll. Das ist dann zum Beispiel

[8:30] sowas wie Feedback. Ein Entwickler möchte eine Rückmeldung dazu bekommen, wie denn sein Code,

[8:34] was er gerade programmiert hat, war. Dann darauf aufbauen sind die Prinzipien. Das ist nicht so

[8:40] abstrakt wie die Werte. Und das ist dann sowas wie Menschlichkeit, wie zum Beispiel, was ich

[8:46] gerade schon erwähnt hatte, dass der Mensch soziale Bindungen zu seinen Projektmanövern hat und dass

[8:50] es da um die Menschen geht. Und daraus ableiten dann wieder die Praktiken, die dann sehr konkret

[8:54] sind, wie zum Beispiel das Test-Driven-Development. Also so ein schönes Thema, wo man ganz viel Zeug

[9:02] auswendig klären kann. Vor allem diese ganzen, ich weiß nicht, Praktiken, Prinzipien. Das kann

[9:06] man ja wirklich schön runterbeten. Ich meine, das wird in der IHK-Prüfung nicht gefordert,

[9:09] Gott sei Dank. Aber das würde ich dann immer in einer möglichen Prüfung mal abfragen,

[9:12] solche Sachen. Jetzt habe ich gerade so, als du gesagt hast, beim Wert hast du als erstes Feedback

[9:16] genannt. Das wäre auch der erste, der mir eingefallen wäre. Kann man jetzt sagen,

[9:19] dass es bei diesem Feedback auch tatsächlich in Richtung dieser Code-Values geht? Kann man das

[9:23] irgendwie miteinander Verbindung bringen? So, ich schreibe Code und ich hätte gern auch einen

[9:26] Feedback darüber, ob der Code gut ist. Kann man das daraus tatsächlich ableiten oder hat das jetzt

[9:30] nichts miteinander zu tun? Genau, das habe ich in meiner Bachelorarbeit auch gemacht. Also,

[9:35] das baut auch aufeinander auf. Die Werte, wie zum Beispiel Feedback oder Kommunikation,

[9:40] finden dann Einklang in der Praktik Code Reviews oder TDD. Dass man auch mit den

[9:48] anderen zusammen wirklich kommuniziert, über den Code auch mal spricht und natürlich Feedback

[9:54] ganz klassisch. Hey, schau dir mal meinen Code an und sag mir, was du gut findest,

[9:59] was du schlecht findest. Jetzt ist es ja so, dass wir bei der AO hier nicht unbedingt

[10:05] Extreme Programming auch im täglichen Einsatz haben. Wir haben ja nicht nur gewisse Praktiken

[10:09] daraus im Einsatz und dann war die Idee, im Rahmen dieser Bachelorarbeit auch mal zu schauen,

[10:14] ob Code Reviews bei uns auch zur Anwendung kommen könnten. Richtig? Genau, also ich habe dann geschaut,

[10:20] okay, welche Werte werden denn bei uns gelebt? So eine kleine Studie gemacht und daraus dann

[10:27] abgeleitet, okay, wir könnten die Werte aus dem Extreme Programming hier verbessern,

[10:32] wie zum Beispiel Kommunikation, Feedback, wenn wir bestimmte Tools einsetzen bzw. bestimmte

[10:38] Verfahren einsetzen und das eine war dann davon, ja, die Code Reviews. Genau. Ja, wir haben jetzt

[10:49] quasi schon ein bisschen öfter über Code Reviews geredet, über das Thema. Kannst du vielleicht mal

[10:52] ganz kurz eine Erklärung geben, was ist überhaupt ein Code Review oder was hast du dir da genau

[10:56] angeguckt? Gibt es da einfach ein Stückchen Code, ein anderer liest das und sagt was dazu oder gibt

[10:59] es da irgendwie etablierte Verfahren mit irgendwie langer Verfahrensbeschreibung? Wie sieht sowas

[11:04] überhaupt aus? Was ist ein Code Review? Ein Code Review ist erstmal eine manuelle Prüfung von

[11:09] Software ohne automatisierte Vorgänge. Es gibt dann zum einen den Ausauer, der den Code entwickelt

[11:15] hat und den Reviewer, der sich den Code auf Grundlage seiner Erfahrungen anschaut. Der

[11:20] untersucht den dann auf Fehler und schreibt Anmerkungen dazu. Es gibt da verschiedene

[11:24] Varianten, wie zum einen das Walkthrough, wo man gemeinsam beim Autor in kleinen Gruppen das

[11:31] IT-Code anschauen kann. Dann gibt es einmal das Review. Das ist ein Review mit einer Checkliste

[11:39] ohne den Autor. Ich gucke mir das dann als Reviewer an und habe dann eine Checkliste,

[11:43] die ich abarbeiten kann. Und das andere ist die Inspektion. Das ist dann ein ganzer Prozess,

[11:48] der meiner Meinung nach ein bisschen aufgebläht ist. Zum Beispiel gibt es da die Planungsphase,

[11:52] die Vorbereitungsphase und dann handelt man das alles nacheinander ab. Das ist

[11:59] mal jetzt die richtige Grundlage. Der Ziel von Code Reviews ist letztlich,

[12:06] dass man die Qualität erhöht? Oder warum mache ich das? Warum mache ich jetzt den Aufwand,

[12:10] dass jetzt jemand zweites noch über meinen Code rüberguckt? Kann ich nicht gut genug programmieren

[12:14] oder was ist da der Hintergrund? Ja klar, also erstmal kann ich die Code Qualität verbessern,

[12:19] da wenig Fehler gefunden werden können. Ein anderer Vorteil, den das Ganze noch hat,

[12:26] ist, dass der Entwickler weiß, beim Entwickeln, es schaut vielleicht jemand mal drüber, wenn es

[12:32] auch nicht direkt im Anschluss ist. Und dann weiß man, vielleicht sollte ich das besser

[12:36] programmieren. Da kann man auch komplexe Zusammenhänge dann sichtbarer machen. Wenn

[12:42] man zum Beispiel diese Checklisten hat, das soll erfüllt werden und das soll erfüllt werden,

[12:46] dann kann man diesen Code ja auch vergleichbar machen und ja auch die Zusammenhänge erkennen.

[12:51] Und was natürlich dann auch ein Vorteil ist, dass man das wartbar macht und da nicht nur ein

[12:59] Entwickler da drauf schaut und den Code versteht, sondern auch ein zweiter sich das anschauen muss

[13:03] und den Code ja auch verstehen muss, sodass man den dann auch wartbar machen kann. Also da jetzt

[13:10] aus meiner eigenen Erfahrung, ich habe selber bei der Evaluierung, wo wir gerade gleich noch

[13:13] drüber sprechen werden, ja auch teilgenommen. Gerade diesen zweiten Punkt mit der Selbstkontrolle

[13:16] finde ich sehr cool. Wenn man weiß, dass später noch mal jemand über den Code guckt,

[13:20] verhält man sich einfach anders, programmiert einfach besser. Das kann ich einfach so sagen.

[13:24] Also allein das ist es schon wert, sowas mal einzubauen. Da kommen wir vielleicht gleich

[13:28] nochmal einmal drauf zu sprechen. Okay, jetzt hast du schon drei verschiedene Möglichkeiten

[13:33] zum Code Review erzählt. Walkthrough, Review, Inspektion. Was davon wurde denn jetzt hier bei

[13:38] der Alta Umburger eigentlich umgesetzt? Haben wir alles ausprobiert oder nur das Einfachste

[13:43] oder wie sah das aus? Nee, also ich hatte ja lange Zeit, acht Wochen für meine Bachelorarbeit und wir

[13:49] haben dann geschaut, okay, was könnte man hier bei der AO am besten umsetzen. Wir haben uns dann

[13:53] dafür entschieden, ein Offline Review zu machen. Das heißt, einer alleine schaut sich den oder ein

[13:59] Reviewer schaut sich den Code eines Autors alleine an und das machen wir ohne Checklisten, weil diese

[14:04] Erstellung der Checkliste schon eine eigene Bachelorarbeit wert wäre. Ich habe dann dazu

[14:10] einen Leitfaden erstellt, weil viele Entwickler gar nichts oder beziehungsweise noch nicht so den

[14:14] klassischen, das klassische Review kannten, einen Leitfaden erstellt. Wenn du das machst, dann das.

[14:19] Ich habe dann auch noch einen Fragebogen zu jedem Review erstellt. Da stand dann sowas drin wie,

[14:24] hallo, ich bin der Autor und ich bin der Reviewer, wir schauen uns so und so viele Leits auf Code an.

[14:29] Dann sagt der Reviewer, ich habe so und so viele Fehler gefunden, ich habe so und so viele Anmerkungen

[14:33] gemacht, was ich mir überhaupt angeschaut habe, was mein Code das war. Dann gab es dann auch so

[14:39] Fragen wie, hast du einen technischen Mehrwert gehabt? Das durfte dann der Reviewer sowie auch

[14:43] der Autor beantworten. Genauso war das beim fachlichen Mehrwert. Also technischer Mehrwert

[14:49] wäre dann sowas wie, hallo, ich habe neue Sachen in Java gelernt und ein fachlicher Mehrwert wäre

[14:53] dann sowas wie, oh, ich kannte das noch gar nicht bei der Leistungsabteilung oder im

[14:59] Rechnungswissenkode. Genau, so sind wir erstmal rangegangen, dann haben wir eine Testphase

[15:07] gemacht über drei Wochen mit 17 Entwicklern und es wurde halt gesagt, okay, sollte jeder Entwickler

[15:15] einmal in der Woche ein Review machen und einmal reviewen und das war sozusagen auf freiwilliger

[15:22] Basis mit der Ansage, macht das mal bitte und wir haben dann 26 Reviews gemacht innerhalb der drei

[15:28] Wochen. Okay, das ist auf jeden Fall schon eine belastbare Datenbasis, die da zustande gekommen ist.

[15:38] Das finde ich schon mal sehr gut. Dann können wir mal gucken, was man da jetzt so daraus ableiten

[15:42] kann. Aber vorher würde ich noch einmal gerne auf diese Checkliste zu sprechen kommen, die wir jetzt

[15:48] zwar nicht benutzt haben, aber wie kann man sich das vorstellen, was wird auf so einer Checkliste

[15:51] denn draufstehen? Steht da sowas wie, keine Ahnung, habe ich alle meine Instanzvariablen

[15:56] private gemacht oder was sind die Inhalte so einer Checkliste? Ja, bei einer Checkliste kann

[16:05] man verschiedene Sachen machen, das hängt auch sehr von der Programmiersprache ab, aber man kann

[16:10] sich dann sowas anschauen, wie sind die Variablen benannt. Hat man in Java zum Beispiel einen

[16:17] CamelCase genommen, hat man die Programmiersprache idiomatisch benutzt, also so wie sie eigentlich

[16:23] genutzt werden sollte, kann man dann einbauen. Aber man kann auch ganze Algorithmen auseinandernehmen,

[16:30] wie zum Beispiel, was für unsere Programmiersprache, Natural, die wir jetzt gerade einsetzen machen, haben wir

[16:37] was Neues eingeführt, wie man quasi einen Try-Catch, wie man das aus Java kennt, in Natural, was es dort

[16:43] eigentlich nicht gibt. Und wir haben uns darauf geeinigt, dass wir das jetzt machen wollen, also quasi eine

[16:48] Best-Practice eingesetzt und man könnte dann innerhalb dieser Checklisten schauen, ok, hat der Entwickler

[16:53] das immer so umgesetzt, wie wir uns darauf geeinigt haben. Also ich finde an der Checkliste ganz schön, wenn man

[17:02] sowas hat, dass man auch in Richtung so eines einheitlichen Standards dann vielleicht kommt und ich

[17:07] könnte mir vorstellen, dass man so eine Checkliste am Ende dann auch nehmen kann und wenn man die

[17:10] Möglichkeiten hat, dass vielleicht sogar in ein automatisches Prüfprogramm oder sowas reinschubst, dass man am Ende gar

[17:15] keinen Menschen mehr braucht, der sich das anguckt, weil viele Sachen sind ja vielleicht wirklich sehr

[17:18] technisch, die man vielleicht mit so einer statischen Grundanalyse dann checken könnte oder so. Ja, das war

[17:23] auch dann die Aussage, so, das ist ja irgendwie blöd, wenn wir uns das angucken müssen, aber wir hatten ja wirklich,

[17:29] wir sind bei null gestartet, wir hatten noch keine statische Grundanalyse, keinen, gar nichts und dann haben wir

[17:33] gesagt, ok, wenn wir noch gar nichts haben und unsere Grund verbessern wollen, dann lasst uns doch auch diese

[17:36] technischen Sachen angucken, auch wenn das vielleicht ein bisschen blöd ist, aber ja, man möchte ja irgendwie

[17:41] die Grundanalyse verbessern, man muss ja irgendwo anfangen und bei uns war es jetzt zum Beispiel auch so, dass wir

[17:47] auf lange Sicht die statische Grundanalyse einführen wollen, ein Kollege macht das jetzt wahrscheinlich auch in

[17:52] seiner kommenden Bachelor-Arbeit, also wäre so eine Checkliste ein sehr guter Anfang, sowas zu machen.

[18:00] Aber man kann ja durchaus auch, wenn man keine Checkliste hat, nach den ersten paar Reviews quasi

[18:05] nur gemeinsam mehr arbeiten, dass man also sagt, hier, die Leute haben immer das Gleiche angemeckert, dann packen wir

[18:10] das doch vielleicht dann auf eine Checkliste für das nächste Review oder so, ja, richtig?

[18:13] Genau, das war bei uns auch so schön, dass ein Entwickler aus eigenem Antrieb gesagt hat, ein

[18:19] Wiki-Artikel erstellt hat bei uns im Wiki und dann gesagt hat, hallo, mir ist das und das bei den letzten Reviews

[18:27] aufgefallen, wir können uns da nicht irgendwie einigen und dann ist da so eine kleine Best-Practice-Liste

[18:32] erstellt worden, die dann auch von fehlenden Reviewern weitergeführt wurde und ja, das Ziel war es jetzt,

[18:39] die noch weiterzuführen und zu sagen, okay, hallo, das sind jetzt unsere Best-Practices und wir sind jetzt auch

[18:44] gerade dran, dass das noch weitergeführt wird und vervollständigt wird.

[18:48] Das hört sich für mich auf jeden Fall nach einem einfachen Start an, um in Richtung Kohlqualität was zu machen.

[18:53] Das kann auch, wie auch aus dem XP, wo es herkommt, recht agil gemacht werden. Man kann es gemeinsam erst mehr

[18:58] arbeiten, erst mal anfangen und irgendwie dann, ja, teilweise das Ganze vielleicht automatisieren oder auch

[19:03] überhaupt erst mal formulieren in einer Liste, wie auch immer. Eine Frage habe ich noch zu diesem Leitfaden, nur, dass

[19:09] wir das noch einmal sauber abgrenzen. Du hast jetzt für deine Bachelor-Arbeit so einen Leitfaden gemacht, auch

[19:13] damit man am Ende das so ein bisschen evaluieren kann. Hat es jetzt was gebracht oder nicht? Du hattest auch schon

[19:17] gesagt, da steht sowas drauf wie, habe ich durch das Review etwas gelernt? Das war für uns ja auch sehr wichtig, um zum

[19:21] Beispiel am Ende dann begründen zu können, ob wir die Code-Reviews dann auch langfristig weitermachen, weil das

[19:25] kostet ja auch immer Zeit, das darf man nicht vergessen. Also braucht man auch so ein bisschen empirische Daten, um

[19:29] zu sagen, das hat uns auch was gebracht. Richtig? Das heißt aber, wenn ich jetzt einfach so Code-Reviews nach dem

[19:36] Buch mache, habe ich da eigentlich nicht so einen Leitfaden, sondern das war jetzt etwas, was du dir quasi selber

[19:40] ausgedacht hast für deine Bachelor-Arbeit, ja? Genau, du meinst den Fragebogen, wie gerade ja schon gesagt. Ja, also das

[19:49] waren halt immer die gleichen Fragen, die der Autor bzw. der Review dann antworten musste. Mir war es halt wichtig, zu

[19:55] wissen, okay, in Natural, wie viele Lines of Code kann man überhaupt reviewen, weil wir überhaupt gar keine Ansatz

[20:02] hatten, wie viel schafft man denn überhaupt, wenn man das mit Java nicht vergleichen kann, weil es eine sehr

[20:06] gesprächliche Sprache ist. Wie viele Lines of Code haben wir gereviewt? Dann konnte der Reviewer dann nochmal sagen,

[20:16] ich habe so viele Anmerkungen geschrieben, ich habe so viele Fehler gefunden. Dann konnte der Autor nochmal sagen,

[20:21] ich habe die Fehler dann wirklich umgesetzt oder ich habe die Anmerkungen dann auch beachtet. Dann konnten der

[20:28] Reviewer und der Autor dann nochmal sagen, ich habe einen technischen Mehrwert gehabt oder einen fachlichen

[20:34] Mehrwert.

[20:36] Und dann konnte man noch sagen, okay, das hat mir jetzt gefallen oder das hat mir nicht gefallen in einem freien Textfeld.

[20:42] Genau, das habe ich mir dann selber überlegt, dass ich das gerne wissen möchte.

[20:48] Und es war dann auch nachher ziemlich cool, das auszuwerten.

[20:53] Genau, da kam dann auch bei unserer Studie heraus, dass wir 350 Anmerkungen und 18 Fehler in 30.000 Lines of Code gefunden haben oder geschrieben haben.

[21:05] Innerhalb von 26 Reviews, was ja schon sehr gut war, fand ich.

[21:12] Wir haben auch gesehen, dass es einen großen technischen Mehrwert gab für den Autor und den Reviewer.

[21:17] Also jeder konnte was vom anderen lernen.

[21:19] Und es gab auch einen fachlichen Mehrwert, der aber jetzt nicht so groß war, weil man sich erstmal da reinfinden muss,

[21:27] okay, Code Reviews und ich muss mir erstmal einen anderen Code anschauen, den ich überhaupt nicht kenne.

[21:34] Weil wir da auch so rangegangen sind, dass wir nicht gesagt haben, innerhalb der Abteilung bei unseren 17 Entwicklern,

[21:39] ach, die drei Entwickler arbeiten ungefähr an der gleichen Sache oder die anderen drei Entwickler,

[21:44] sondern da hat der Auszubildende den Senior Entwickler gereviewt und umgekehrt.

[21:49] Das war dann einfach mit einer Ziehung, wir haben gelost, wer wen reviewen soll.

[21:56] Um das halt möglichst empirisch auswerten zu können oder dass es da irgendwelche Verzerrungen gibt.

[22:04] Kann man das schon mal in ein, zwei Sätzen zusammenfassen, was dann so die Ergebnisse sind?

[22:07] Also du hast schon ein paar beeindruckende Zahlen genannt, was man alles so schaffen kann,

[22:10] in teilweise auch sehr kurzer Zeit.

[22:12] Kann man so eine allgemeine Sache als Feedback sagen, so hey, das war jetzt positiv, das hat uns was gebracht

[22:18] oder ist das eher so wishy-washy, kannst du da irgendwas zu sagen?

[22:25] Was ein großer Vorteil von dem ganzen war, was alle gesagt hatten,

[22:31] war, dass man überhaupt erstmal dazu gekommen ist, über Codequalität nachzudenken bei den Code Reviews,

[22:36] weil man sich den Undercode angucken musste und sich vielleicht geärgert hat,

[22:40] oh mein Gott, was hat der andere da gemacht oder sich vielleicht auch gefreut hat und gedacht hat,

[22:43] cool, mach ich nächstes Mal auch genauso.

[22:50] Wie auch Herr Rath schon gesagt, der Senior Entwickler hat auch mal mit dem Azubi darüber geredet.

[22:56] Also das heißt, die Teilnehmer sind sich auch schon tatsächlich auf Augenhöhe begegnet,

[23:02] egal ob ich jetzt gerade angefangen bin oder schon länger dabei bin,

[23:05] es ging um den Code und nicht darum, irgendwie die anderen Menschen in Anführungszeichen runterzumachen.

[23:10] Das heißt, das führt ja auch schon mal dazu, dass das Team am Ende besser zusammenarbeitet.

[23:14] Genau, man hat überhaupt auch erstmal mit anderen Leuten geredet,

[23:19] also das ging jetzt ja nicht nur um beim Mittagstisch über irgendwelche Sachen reden,

[23:24] das ging vom Privatleben natürlich auch super, aber man hat sich auch wirklich über die Sachen ausgetauscht,

[23:29] sei es jetzt technisch oder fachlich oder auch nur mal bei dem anderen am Arbeitsplatz gewesen,

[23:34] mit dem man überhaupt gar nichts zu tun hat.

[23:37] Also allein schon daher war das schon super.

[23:40] Wie auch gerade schon gesagt, die Best Practices waren auf jeden Fall auch eine tolle Sache, die da rausgekommen sind.

[23:48] Jetzt meinst du gerade schon, Mensch, da könnten sogar Azubis mitmachen

[23:51] und haben auch den Code von erfahrenen Entwicklern tatsächlich gereviewt.

[23:54] Kannst du da noch ein bisschen was zu sagen? Hat das gut funktioniert oder gab es da Probleme?

[23:59] Das hat richtig gut funktioniert, das hätte ich auch nicht gedacht.

[24:02] Das war auch am Anfang wirklich der schärfste Kreditpunkt,

[24:05] okay, wie sollen wir denn da alle miteinander Codereviews machen?

[24:09] Aber das hat richtig gut funktioniert.

[24:11] Wir hatten zum Beispiel einen Entwickler, der in Java programmiert hat,

[24:15] der auch schon mit dem Studium angefangen ist und wirklich schon seit 15 Jahren Java programmiert.

[24:22] Dann gab es einen Azubi von Stefan, der sich den Code dann angeguckt hat und gesagt hat,

[24:27] warum hast du denn das so gemacht und warum hast du denn das so gemacht

[24:29] und warum hast du denn nicht die neueste Java-Version benutzt?

[24:32] Das hat richtig gut funktioniert, da haben beide auch richtig was mitnehmen können.

[24:37] Was natürlich dann auch ganz gut war, ist, dass der Senior-Entwickler dem Azubi auch mal was sagen konnte,

[24:44] guck mal, ich habe das so gemacht, weil aus dem und dem Grund.

[24:47] Und dann lernt man auch nicht nur von seinem Ausbilder die Programmierung,

[24:51] also nicht nur von Stefan und Stefan sagt, das muss man so machen, sondern auch mal eine andere Meinung.

[24:55] Mir guck mal, so geht es auch oder so kann man es auch machen.

[25:00] Ja, dass man einfach auch mal eine andere Perspektive von einer Ausbildung hat.

[25:06] Hat dann aber auch wahrscheinlich ganz viel damit zu tun, wie man miteinander über den Code kommuniziert.

[25:11] Wenn dann jetzt der Senior-Entwickler dem Azubi sagt, was hast du da für einen Scheiß gemacht,

[25:14] ich glaube, das funktioniert dann nicht so gut, war das auch eine Erkenntnis

[25:17] oder gab es da grundsätzlich vielleicht auch zwischenmenschliche Probleme

[25:20] oder kann man einfach sagen, es haben sich alle wirklich nur auf den Code konzentriert

[25:23] und alle waren super happy, was gelernt zu haben oder gab es da vielleicht auch so ein paar,

[25:27] die gesagt haben, stimmt, ich habe hier wirklich einen Fehler gemacht

[25:30] und haben das vielleicht nicht so gut verkraftet.

[25:32] Also ich habe zumindest nichts mitbekommen, dass es da Probleme gab.

[25:35] Wir haben bei uns aber auch überhaupt nicht so die Probleme,

[25:40] wie Leute haben, die sich überhaupt gar nicht verstehen.

[25:43] Das war wirklich sehr harmonisch, so habe ich das zumindest wahrgenommen.

[25:47] Und ja, man kann es sich aber auch ein bisschen lockerer annehmen, die ganze Sache.

[25:54] Also man muss jetzt auch nicht sagen, oh mein Gott, das ist blöd

[25:57] und dann fünf Zeilen Anmerkungen zu schreiben,

[26:00] sondern man kann es sich auch mal witzig schreiben, nicht so hochgestochen,

[26:03] sondern was Stefan aber gerne schreibt zum Beispiel, geht das nicht streamiger.

[26:08] Also es ist tatsächlich so, Code Preview hat auch wirklich viel mit Kommunikation zu tun,

[26:18] kann ich auch aus eigener Erfahrung sagen, weil ich da ja mitgemacht habe.

[26:21] Also dieses typische Klischee, der Nerd, der in seinem Keller sitzt und Code produziert,

[26:26] das wird hier auf jeden Fall aufgebrochen, weil auch wenn es über den Code geht

[26:30] und wir haben ja auch versucht, das Ganze über eine Versionsverwaltung miteinander auszutauschen

[26:33] und man kommt dann auch schnell einfach nicht mehr weiter, wenn man nicht miteinander redet.

[26:37] Also der Anstoß, um einfach mal mit den Kollegen auch über etwas zu sprechen, war auf jeden Fall da.

[26:42] Ich persönlich fand das auf jeden Fall als Mehrwert.

[26:45] Dann SIPA, quasi gerade genau beim Thema, es kann eventuell auch für einige Mitarbeiter

[26:52] vielleicht ein bisschen schwierig sein, Code Reviews zu akzeptieren

[26:55] oder sich vielleicht auch auf den Fuß getreten fühlen oder wie auch immer.

[26:58] Also es ist ja nicht immer alles heile Welt.

[27:00] Gibt es vielleicht noch andere Probleme mit Code Reviews?

[27:03] Wenn wir uns ein bisschen so Vor- und Nachteile angucken, wir haben jetzt schon einiges gehört,

[27:06] da kann man irgendwie Fehler finden und auch so eine gemeinsame Basis vielleicht für diesen Code finden.

[27:12] Aber gibt es da auch irgendwie Nachteile bei den Code Reviews?

[27:15] Ja, die Entwickler fühlen sich natürlich erstmal kontrolliert.

[27:20] Oh Gott, es guckt jemand meiner Arbeit nach.

[27:23] Und dann ist es natürlich auch, was man vielleicht denkt, dass es ein Kostenfaktor erstmal ist,

[27:29] weil man ja wirklich eine zusätzliche Zeit oder Entwicklungszeit hat,

[27:32] die dann auch einberechnet werden muss.

[27:34] Die muss in den Entwicklungsprozess einberechnet werden.

[27:36] Da haben wir uns aber, oder ich habe mich mit meinem Chef abgestimmt und gesagt, ja, machen Sie das.

[27:42] Also da auf jeden Fall die Unterstützung geholt.

[27:45] Und was Stefan ja vorhin auch schon angesprochen hat, dass man einfach einen falschen Fokus setzt

[27:49] und immer nur finden möchte, oh mein Gott, was hast du denn da programmiert und du hast das falsch gemacht.

[27:54] Darum geht es gar nicht, sondern man sollte immer das Ziel verfolgen,

[27:58] gemeinsam die Codequalität zu verbessern und nicht zu sagen, der hat den und den Fehler gemacht.

[28:03] Bei der Einführung gibt es noch mehr Tipps, die ich geben könnte, die mir da aufgefallen sind,

[28:11] ist, dass es erstmal sowieso eine Ablehnungshaltung gibt.

[28:14] Also ich kann mich an das erste Gespräch erinnern, zu dem ich eingeladen habe,

[28:17] hallo, wir wollen jetzt Coderevies machen.

[28:19] Da saßen erstmal alle und okay, gut, mit was kommt sie denn jetzt?

[28:24] Aber nachdem man dann erstmal angefangen ist, dann erstmal alle am Ball ist,

[28:29] dann ist es auch wesentlich einfacher, als wenn man sagt, wir machen jetzt Coderevies und Punkt.

[28:32] Dann war es ganz gut, dass es mich als Kümmerer gab, sagen wir mal so,

[28:37] dass da wirklich einer ein Ansprechpartner war und dann auch gesagt hat, so ist das jetzt und zu den Terminen eingeladen hat.

[28:46] Dann sollte man nochmal schauen, dass man die Coderevies in den Entwicklungsprozess irgendwie integriert.

[28:56] Das haben wir jetzt bei der ersten Testphase nicht gemacht.

[28:59] Wir haben aber noch eine zweite Testphase gemacht, die dann über einen längeren Zeitraum ging

[29:05] und wo wir dann auch Sachen, die in der ersten Testphase bemägelt wurden, nochmal anders gemacht haben.

[29:11] Also man sollte sich auf jeden Fall dann auch um die Meinung der Entwickler kümmern

[29:16] und wenn die sagen, einmal die Woche ist ein Freelance-Review, dann sollte man darauf achten und sagen,

[29:20] okay, dann machen wir das jetzt anders.

[29:23] Worauf ich eigentlich hinaus wollte, ist die Integration in den Entwicklungsprozess,

[29:27] dass man schaut, okay, machen wir das jetzt nach der Entwicklung, vor dem Test,

[29:30] bevor wir das auf die QS bringen oder wie wollen wir das da einsetzen.

[29:36] Und was auch immer schön ist, der Einsatz mit anderen Praktiken zusammen,

[29:41] wenn man zum Beispiel noch ein Prep-Programming macht und das dann nochmal für jemanden reviewen lässt.

[29:46] Also wenn da kein schöner Code bei ihr rumkommt.

[29:49] Nein, aber das kann man auf jeden Fall mit anderen Praktiken noch miteinander verbinden.

[29:54] Dann konkret für ein Review ist es auch noch gut, also wenn ich jetzt wirklich Stefan meinen Code gebe

[30:00] und sage, guck dir das mal an, dass ich ihn erstmal einführe und sage,

[30:03] guck mal, es geht hier, darum geht es und nicht einfach nur sagen, mach mal.

[30:08] Und was auch ein großer Punkt war, war, dass kein perfekter Code notwendig ist.

[30:15] Also ein Code ist ja immer in der Entwicklung, immer in diesem Prozess drin und das muss nicht perfekt sein.

[30:24] Also wenn es perfekt ist, dann muss sich da vielleicht auch niemand mehr drum kümmern.

[30:28] Es geht aber auch um diese fachlichen Fehler.

[30:31] Und die fachlichen Fehler können ja auch im guten Code trotzdem noch drin sein.

[30:35] Also die sind ja trotzdem drin.

[30:37] Und es gibt auch hässliche Sachen, die dann von der fachlichen Sache sehr gut sind.

[30:43] Also darum geht es nicht und genau.

[30:48] Also das sind ja zwei schöne Stichwörter, wo ich nochmal nachhake.

[30:51] Einmal hattest du da gesagt, genau das Prep-Programming.

[30:53] Und jetzt genaue mich nochmal auf die Tools und solche Fehler zu finden.

[30:56] Also das Prep-Programming würde ich jetzt sagen, wäre das Code Review eine Ergänzung.

[30:59] Das heißt also nicht, wenn ich im Prep-Programming sitze, braucht kein anderer mehr drüber gucken,

[31:02] weil da habe ich ja quasi das Code Review schon mit eingebaut.

[31:05] Kann man so sagen, wenn ich Prep-Programming mache, kann ich auf Code Reviews verzichten?

[31:09] Nee, ganz und gar nicht.

[31:11] Ich finde, das ist eine schöne Symbiotik, dass das dann danach nochmal gemacht wird.

[31:16] Dann hat man nochmal eine Meinung oder nochmal einen Menschen, der darüber geguckt hat.

[31:20] Man kennt das ja auch zum Beispiel gut mit Test-Driven-Development-Communion.

[31:26] Also das schließt sich überhaupt nicht aus.

[31:32] Und dann meintest du jetzt gerade so, dass das Problem bei dem Code Review ja vielleicht genau ist,

[31:37] diese fachlichen Fehler zu finden, die ein Code-Checker zum Beispiel gar nicht finden kann.

[31:41] Das fand ich eigentlich auch eine ganz interessante Aussage,

[31:43] denn viele Entwicklungsprozesse da draußen beinhalten ja zum Beispiel sowas wie eine statische Code-Analyse schon.

[31:49] Dann sagt vielleicht auch der Style-Checker, Mensch, das hast du toll programmiert,

[31:52] aber ob auch das Richtige programmiert wurde, sagt er mir natürlich nicht.

[31:55] Also da finde ich auch nochmal den Hinweis ganz gut,

[31:57] dass zumindest meiner Meinung nach noch der Mensch nicht komplett durch den Computer ersetzt werden kann,

[32:02] zum Beispiel an dieser Stelle.

[32:04] Von daher, da fand ich den Hinweis auch sehr gut, das kann ich nur unterstützen.

[32:09] Aber wenn wir beim Thema Tools schon sind, jetzt hattest du auch gerade gesagt,

[32:12] wir haben es dann in der zweiten Phase versucht, auch in den Prozess zu integrieren.

[32:15] Haben wir da denn irgendwelche konkreten Werkzeuge benutzt,

[32:18] also irgendwelche Programme oder irgendwas, was das Code Review irgendwie unterstützen kann?

[32:24] Ja, das große Thema Tool kam dann auch auf,

[32:27] dass es natürlich schön wäre, wenn bei den Code Reviews ein Tool uns unterstützt.

[32:30] Wir sind erstmal angefangen und haben keins benutzt.

[32:33] Es gibt aber jede Menge, wie zum Beispiel Collaborator von Smart Bits, Crockable, Code Break.

[32:39] Es gibt jede Menge Sachen am Markt.

[32:42] Uns war es aber erstmal wichtig, dass unsere Anforderungen an das Tool erfüllt werden.

[32:46] Also wir brauchten auf jeden Fall eine IDE-Plugin für unser Eclipse,

[32:50] sodass wir da nicht an zwei Stellen schauen müssen, wo ist der Code.

[32:54] Dann wollten wir nicht, dass zwei Datenbanken nochmal gespeichert haben.

[33:00] Da sollte es eine Git-Integration geben und es sollte auch noch die Anforderungen erfüllen,

[33:06] dass man Gruppen erstellen kann, wie zum Beispiel,

[33:09] ich habe drei Leute in der Gruppe Produktmodellierung und drei Leute in der Gruppe Ausbildung,

[33:16] dass es auch gemixt werden kann, zum Beispiel noch in einer dritten Gruppe.

[33:20] Dann sollte man auch noch unterscheiden zwischen einer Anmerkung und einem Fehler,

[33:26] sodass man direkt die Fehler auch erkennt, dass eine Priorisierung sozusagen möglich ist.

[33:31] Und wir wollten, was uns ganz wichtig war, ist, dass es kein neues SCM ist.

[33:39] Wir haben uns zum Beispiel GitHub Enterprise in dem Zusammenhang angeguckt

[33:44] und das war uns dann halt zu overkill.

[33:50] Genauso wie das der Collaborator war, da war auch immer der Fokus darauf,

[33:54] dass ich mir den Code dann nochmal angucke.

[33:59] Also da war der Workflow so, der Autor gibt den Code zu dem Reviewer,

[34:05] der Reviewer guckt das danach und sagt, guck mal, hier ist der Fehler,

[34:08] dann geht das wieder zum Autor, der Autor korrigiert die Fehler dann

[34:13] und dann geht es nochmal zum Reviewer. Aber das wollten wir gerade nicht.

[34:16] Wir wollten nicht nochmal, dass der Reviewer sich das nochmal anschaut,

[34:19] sondern der Reviewer schaut das einfach nach und dann vertraut man darauf,

[34:22] dass der Autor das umsetzt.

[34:24] Und wenn du diesen anderen Workflow hast, wie es beim Collaborator der Fall ist,

[34:27] dann hast du halt immer diese zwei Ansichten, sodass der Reviewer sehen kann,

[34:30] okay, was hat er überhaupt geändert.

[34:32] Und das war uns viel zu much und deswegen war es schwierig, da ein Tool zu finden.

[34:37] Wir haben uns dann eins auch angeschaut, das war das Agile Review.

[34:43] Das ist wirklich Open Source, kann man bei GitHub runterladen.

[34:47] Das ist wirklich nur ein Eclipse Plugin, das einen Anker in den Code schmeißt,

[34:51] die Kommentare in XML dann speichert, also in separaten XMLs,

[34:55] die man damit einschicken kann.

[34:57] Das Eclipse Plugin interpretiert dann quasi diese Anker

[35:00] und versetzt die dann mit den Kommentaren.

[35:03] Das wird auch gerade noch immer weiterentwickelt

[35:06] und die Entwickler dahinter ändern da auch Sachen.

[35:11] Aber es hat sich jetzt herausgestellt, dass es für uns noch nicht so das richtige Tool ist.

[35:15] Wir haben das dann auch drei Wochen getestet und dann hieß es,

[35:18] ja, okay, lass uns das mal probieren.

[35:20] Aber das ist jetzt irgendwie noch nicht so das Nonplusultra

[35:23] und hemmt eher, als dass es bei uns in der Entwicklung einen Mehrwert bringt.

[35:28] Weil wir wollten uns auch nicht von einem Tool abhängig machen,

[35:31] dass sich die ganzen Kommentare dann, wenn ich mich von dem Tool löse,

[35:34] nur innerhalb des Tools zugänglich sind.

[35:42] Und wir haben uns dann auch auf eine andere Sache noch geeinigt,

[35:46] die was Schönes ist.

[35:48] Wir haben zwar bei uns in der Natural Entwicklung ein Snippet-Tool.

[35:51] Das ist quasi, ja, Stefan, kannst du das mal genau erklären?

[35:55] Ich glaube, du kannst das besser.

[35:57] Ja, also das Snippet-Ding ist eigentlich eine Erweiterung von den Codeschnipseln,

[36:01] die man auch so schon in der IDE kennt.

[36:03] Man kann sich eigene Snippets anlegen, wie zum Beispiel eine Vorschleife.

[36:06] Gebe ich ein, vor, Steuerung Leertaste in den Clip zum Beispiel,

[36:09] und der Ball hat mir halt eine komplette Vorschleife dahin,

[36:11] damit ich die nicht mehr tippen muss.

[36:13] Und wir arbeiten mit einem Codesnippet-Tool, was das Ganze noch so ein bisschen erweitert,

[36:17] wo man diese Snippets nämlich nicht einfach in seiner lokalen IDE konfigurieren muss,

[36:21] sondern einfach in einen Git-Repository packen kann

[36:23] und die Snippets dann auch im Team untereinander austauschen kann.

[36:26] Das war für uns ein sehr großer Vorteil,

[36:29] weil dann kann man so ein bisschen Best Practices in dieses Repo einstellen

[36:32] und jeder im Team hat die sofort verfügbar.

[36:35] Man kann sie sogar mit wenigen Tastendrücken halt in seinen Code einfügen.

[36:38] Das ist eigentlich so der Vorteil dieses Tools.

[36:40] Ist in Eclipse in neueren Versionen auch übrigens schon eingebaut.

[36:43] Das heißt SnipMatch, das kommt von CodeRecommenders, ist alles Open Source

[36:47] und das ist in jeder neuen Eclipse-Installation mit drin.

[36:51] Anstatt Steuerung Leertaste macht man dann, glaube ich, Steuerung Alt Leertaste

[36:54] und dann kommt halt so ein Pop-up und ich kann mir aus tausenden Snippets,

[36:57] die im Repo liegen, das passende dann raussuchen mit schöner Suchfunktion

[37:01] und allen möglichen Schnittschnacken.

[37:03] Genau, die schöne Sache haben wir genutzt,

[37:06] um überhaupt erstmal die Kommentare im Code einheitlich zu gestalten.

[37:10] Wir haben die Kommentare, die da gemacht wurden,

[37:13] oder auch die Anmerkungen, Fehler, die geschrieben wurden,

[37:15] einfach in Code-Kommentare gepackt und da haben wir gesagt,

[37:18] das ist ja irgendwie blöd, man erkennt diese Sachen,

[37:21] die aus dem Code-Review kommen, gar nicht unbedingt.

[37:24] Und deswegen haben wir einen Snippet, dass man einfach

[37:27] dieser Teil des Kommentars vereinheitlicht.

[37:31] Und da steht dann zum Beispiel

[37:34] AdReview, Autor Hollen vom 28.03.2018.

[37:39] Und das wird schon vorgeblendet, das muss ich auch nicht tippen

[37:42] und dann kann ich direkt dahinter schreiben, geht das nicht Streaminger.

[37:45] Und das ist dann halt schon mal ein Vorteil,

[37:48] was er für mal einheitlich hat.

[37:51] Das heißt, ich fasse jetzt mal zusammen, gerade wenn man über Tools redet,

[37:54] das mögen Softwareentwickler natürlich immer gerne, die neuesten heißen Tools einsetzen,

[37:57] aber man braucht fürs Review eigentlich so gut wie nichts.

[38:00] Man braucht eine Möglichkeit, sich den Code anzuschauen,

[38:03] man braucht eine Möglichkeit, seine Kommentare einzutragen.

[38:06] Kommentare gibt es eigentlich in der Programmiersprache,

[38:09] wirklich die Programmiersprachen-Kommentare, also Slash, Slash und dann legt man los.

[38:12] Und am besten hätte man natürlich noch eine Versionsverwaltung unten drunter,

[38:15] aber mehr braucht man eigentlich nicht.

[38:18] Du hast gerade schon gesagt, du hast dir einen Haufen Tools angeguckt,

[38:21] die sind teilweise richtig overkill, kosten auch teilweise Geld

[38:24] und haben trotzdem nicht das gemacht, was wir eigentlich haben wollten.

[38:27] Also zu guter Letzt sind wir wieder darauf zurückgekommen,

[38:30] dass man einfach einen Kommentar in den Code schreibt, committet und ist fertig. Richtig?

[38:33] Genau, das war jetzt für uns jetzt mal der beste Weg,

[38:36] wenn man jemandem ein Tool empfehlen kann, immer her damit.

[38:39] Ich bin ja generell für Sachen offen.

[38:42] Was uns irgendwie einen geilen, schnellen Schlangenmehrwert bietet.

[38:45] Ja, sehr schön.

[38:48] Also wenn ich hier meine Fragenliste mal durchgucke, da habe ich so ziemlich alles abgearbeitet

[38:51] rund ums Thema Code Reviews. Für mich wäre aber noch interessant,

[38:54] vielleicht so auch als Fazit für das Gespräch heute,

[38:57] wie geht es denn jetzt eigentlich mit Code Reviews bei uns im Unternehmen weiter?

[39:00] Wir haben jetzt eine Testphase gemacht, wir haben sogar auch noch eine zweite Testphase gemacht,

[39:03] wir haben uns Tools angeguckt, wir haben geschaut, wie lange hat es gedauert,

[39:06] was waren die Vor- und Nachteile und alles drum und dran.

[39:09] Was ist denn jetzt das Fazit? Was machen wir denn jetzt eigentlich in Zukunft?

[39:12] Wir haben nach der zweiten Testphase nochmal gesagt, wir wollen es gerne machen,

[39:18] wir haben immer noch den Mehrwert gesehen.

[39:23] Genau, wir haben uns dann darauf geeinigt, dass jeder Entwickler das so machen kann, wie er das, oder so oft und häufig machen darf, wie er möchte.

[39:31] Dass er sich selber die Person, mit der er das machen möchte, aussuchen kann.

[39:37] Und ja, mit dem Tool, wie gesagt, sind wir immer noch auf der Suche.

[39:44] Ich bin immer noch dabei, das nochmal immer nochmal zu pushen.

[39:48] Also wir haben uns darauf geeinigt, dass ich dann in meinen Besprechungen, die wir regelmäßig haben, nochmal sage, wie sieht das aus mit meinen Code Reviews und dass man dann nochmal dran erinnert wird.

[40:00] Es gibt immer Leute, die da wirklich keinen Mehrwert sehen und auch überhaupt nicht einsehen, was es da für einen Mehrwert gibt, weil die das vielleicht gerade nicht einsetzen können,

[40:12] weil sie keinen Code haben, den sie irgendwie neu machen oder vielleicht gerade andere Aufgaben, die wir da haben.

[40:17] Aber es sollte wirklich auch jedem selbst überlassen sein.

[40:20] Es sollte nicht so eine krasse Kontrolle sein, wie das jetzt auch in meiner Bachelorarbeit fast auch möglich war, äh nötig war, weil ich da natürlich eine empirische Sache rausziehen wollte.

[40:32] Und so geht es jetzt erstmal bei uns weiter.

[40:37] Man muss halt nochmal immer wieder schauen in den drei Monaten, wie sieht das wieder aus.

[40:42] Und ich muss mir auch noch ein paar Sachen überlegen, wie ich dann nochmal mehr dazu motivieren kann, das zu machen.

[40:49] Aber es ist immer ein stetiger Prozess, der dann nochmal ins Leben gerufen werden muss.

[40:54] Und ich habe mir zum Beispiel jetzt mal in die Loops geschrieben, Stefan zu fragen, wie das denn jetzt aussieht mit den Best Practices, wenn wir die jetzt nochmal besser einsetzen wollen.

[41:03] Das ist wirklich ein stetiger Prozess, den man irgendwie am Leben halten muss.

[41:12] Das glaube ich sofort, auch aus eigener Perspektive.

[41:17] Motivation, in fremden Code zu schauen, ist nicht immer da, weil es für mich natürlich erstmal einen Arbeitsaufwand darstellt,

[41:23] von dem ich selbst erstmal ja auch nie unbedingt Mehrwert habe, wobei man das vielleicht ein bisschen im größeren Kontext sehen sollte.

[41:29] Denn ich bin ja dafür zuständig, oder als jeder Entwickler ist man ja dafür zuständig, auch dafür zu sorgen, dass die Codequalität insgesamt im Unternehmen auch steigt.

[41:38] Und das kann man hier natürlich machen, auch wenn es für mich persönlich erstmal Arbeit ist.

[41:41] Und manchmal, und ich würde sogar sagen, nicht nur manchmal, lernt man ja auch wirklich was dabei.

[41:45] Ich finde das ein ganz tolles Tool, gerade auch für Azubis, wenn sie in fremden Code reinschauen.

[41:49] Und auch selbst, wenn es der Code von einem anderen Azubi ist, der vielleicht nicht ganz so viel weiter ist als man selbst.

[41:54] Aber einfach vielleicht andere Denkanstöße zu kriegen, andere Problemlösungsansätze zu finden, das fand ich eigentlich den zentralen Mehrwert bei dieser ganzen Geschichte.

[42:01] Und am Ende kommt dann sogar auch noch ein etwas besserer Code raus für das Unternehmen.

[42:06] Was mich vielleicht persönlich als Letztes noch einmal interessiert, hast du am Ende auch noch so eine Art monetäre Betrachtung gemacht?

[42:12] So gerade wenn man vielleicht in der Situation ist, dass man es nicht einfach selbst entscheiden kann, jetzt mal mit 17 Leuten Codevalues einzuführen.

[42:19] Gibt es da irgendwas Handfestes für die Chefs da draußen, wo man sagen kann, Mensch, probier das mal aus, das lohnt sich auch aus irgendwie, keine Ahnung, Zahlensicht.

[42:29] Ist sowas möglich?

[42:31] Ja, die Grundlage für die Revit, dass ich erstmal die Entwickler dafür motivieren konnte, okay, lass uns mal unsere Fehler anschauen, war so eine Betrachtung, wann sind Fehler am teuersten.

[42:42] Und die sind natürlich am Anfang, wenn es in der Entwicklung ist, am günstigsten und nachher, wenn die schon in produktiven Codes sind, natürlich dann umso teurer.

[42:50] Und allein schon deswegen war es ein Grund für unser Management zu sagen, ja, lass uns das machen, weil wir innerhalb von drei Wochen 18 Fehler gefunden haben, die ansonsten nicht aufgefallen wären.

[43:02] Und da kann man schon sagen, das ist ja auch ein monetärer Vorteil, weil diese nicht mehr irgendwann in zwei Jahren aufkommen müssen und sich der Entwickler danach schon wieder zwei Stunden reinarbeiten muss, weil er überhaupt gar nicht mehr weiß, was habe ich denn da gemacht.

[43:13] Und das kennt ja jeder, wenn man es programmiert hat, kann man gar nicht gegen gucken, dann hat man es schon wieder vergessen.

[43:19] Und das wäre dann auch noch ein Tipp, den ich herausheben möchte, auf jeden Fall das Management mit einzubeziehen und die davon zu überzeugen.

[43:28] Und bei mir war das jetzt nicht schwer, bei uns war es wirklich nicht schwer, weil es wirklich offensichtlich ist, okay, Code Reviews bringen da was.

[43:36] Genau, also das Management mit einbeziehen.

[43:41] Lassen Sie sich immer gerne von Zahlen lenken, was ja auch völlig okay ist.

[43:46] Und die hat man hier ja auch, genau wie bei Pair Programming, gibt es ja auch ein paar Studien, die dann zeigen, es ist nicht doppelt so teuer.

[43:51] Von daher aus meiner Sicht auch absolut empfehlenswert, das einfach mal auszuprobieren.

[43:56] Und man kann ja auch auf Entwicklerebene untereinander mal sagen, Mensch, lass mich doch mal reinschauen in den Code.

[44:01] Oder vielleicht sogar andersrum jemanden einfach fragen, ob er mal draufschauen kann.

[44:04] Vielleicht fühlt derjenige sich ja sogar so ein bisschen geschmeichelt, dass er mit seinem Wissen auch irgendwie beitragen kann.

[44:10] Und gerade aus Sicht eines Azubis, man kann ja auch selber eigentlich nur dadurch lernen, dass man Feedback von anderen kriegt.

[44:15] Also man kann ja so ein bisschen durch die Hintertür versuchen, die Code Reviews einzufühlen.

[44:21] Ja, jetzt haben wir aber wirklich alles abgehakt.

[44:24] Wir haben auch noch über die Zukunft und den aktuellen Stand bei uns im Unternehmen zum Thema Code Reviews gesprochen.

[44:29] Haben wir aus deiner Sicht noch irgendwas rund um das Thema vergessen oder haben wir eigentlich alles gut bearbeitet heute?

[44:36] Zumindest das, was ich erzählen wollte, haben wir abgehakt, denke ich.

[44:40] Sehr schön. Okay, hervorragend.

[44:42] Ja, wenn es zum Thema Code Reviews natürlich noch Fragen gibt, sind wir natürlich beide gerne bereit, die zu beantworten.

[44:47] Kontaktdaten findet ihr natürlich nachher in den Show Notes und so weiter.

[44:50] Auch die Tools, die wir heute gehört haben, insbesondere auch das Agile Review, was ja komplett open source ist,

[44:54] verlinke ich da natürlich gerne, dass man sich das mal angucken kann, wirklich einfach zu benutzen.

[44:58] Und zum Beispiel auch dieses Snipmatch-Tool, sehr, sehr hilfreich in der Praxis tatsächlich auch.

[45:03] Von daher packe ich alles rein, gerne mal nachschauen.

[45:06] Dann würde ich sagen, haken wir das Thema Code Reviews ab und kommen jetzt so zu meinem allgemeinen Teil,

[45:11] den ich eigentlich in jedem Interview am Ende habe, und zwar die Frage,

[45:14] nach Ressourcen rund um die Ausbildung.

[45:17] Ich frage ja eigentlich immer jeden hier, was vielleicht so das eine Buch ist,

[45:21] das man in Bezug zur IT oder zur Programmierung irgendwie weiterempfehlen kann.

[45:25] Wie ist das bei dir? Hast du jetzt zum Beispiel das Extreme Programming Explained von Kent Beck ganz oben auf der Liste?

[45:31] Oder welches Buch würdest du einem ITler da draußen empfehlen?

[45:34] Du kannst doch das, was ich jetzt antworten will, nicht schon vorausziehen.

[45:38] Es gibt schöne Zusammenfassungen. Es geht nicht nur hardcore um Programmierung oder nur um Code,

[45:45] sondern auch um zwischenmenschliche Sachen, was mir persönlich da auch sehr wichtig war,

[45:48] wie die Werte ja schon gesagt haben.

[45:51] Und es fasst wirklich schöne Sachen zusammen.

[45:54] Und ich würde sagen, das ist wirklich ein sehr, sehr gutes Thema.

[45:57] Ich würde sagen, das ist wirklich ein sehr, sehr gutes Thema.

[46:00] Ich würde sagen, das ist wirklich ein sehr, sehr gutes Thema.

[46:04] Und ich würde sagen, das ist wirklich ein sehr, sehr gutes Thema.

[46:07] Und ich würde sagen, das ist wirklich ein sehr, sehr gutes Thema.

[46:10] Das hat mir noch einmal… oder die Übersetzung davon fand ich jetzt nicht so gut,

[46:15] deswegen gerne auf Englisch.

[46:19] Wenn ich dir das jetzt vorweggenommen habe, das wusste ich jetzt.

[46:22] Das war tatsächlich nicht abgesprochen.

[46:24] Ich habe das Buch auch gelesen, ich fand es auch sehr schön.

[46:26] Du darfst gerne noch ein zweites nennen, wenn du möchtest.

[46:30] Ja, was ich gerade angefangen habe zu lesen, ist das Software Developers Life Manual.

[46:38] Das habe ich von Stefan sogar geschenkt bekommen zum Bachelor.

[46:41] Und es wird hier noch richtig cool geschrieben, auch auf Englisch,

[46:45] auch nur zu empfehlen, richtig witzig.

[46:48] Das ist auch ein Programmierer, der jetzt Lehrer ist.

[46:52] Wieso? Ich…

[46:54] John Sonmez, der Softskill-Mann.

[46:57] Wenn es um die Softskills beim Programmieren geht, ist er immer der erstgenannte.

[47:01] Genau, sehr witzig, nur zu empfehlen.

[47:05] Sehr schön.

[47:06] Wenn du noch nicht am Ende bist, dann lernst du ja bald noch was über Immobilieninvestments.

[47:10] Das hat mich etwas überrascht, als ich das gelesen habe.

[47:13] Aber ich kann es auch absolut empfehlen.

[47:16] Okay, sehr gut.

[47:18] Haben wir noch Fragen? Die anderen mit Ausbildung würde ich jetzt überspringen.

[47:23] Buchempfehlung haben wir dann durch.

[47:25] Quellenempfehlung und Tipps zur Aus- und Weiterbildung hatte ich auch geschenkt.

[47:29] Okay, klar, gerne.

[47:30] Hast du davon unabhängig noch irgendwelche anderen Tipps oder Hinweise oder Quellen

[47:35] oder was auch immer rund um Aus- und Weiterbildung im IT-Bereich?

[47:39] Muss jetzt vielleicht nicht das eine Buch hier sein, aber vielleicht noch etwas anderes,

[47:42] was du empfehlen kannst, ganz allgemein?

[47:45] Ich habe in meiner Dokumentation gelernt, wo ich meine Informationen herkriege.

[47:52] Und ich habe wirklich am Anfang meines Studiums gedacht,

[47:55] wissenschaftliches Arbeiten, oh mein Gott.

[47:57] Aber ich habe es wirklich für mich entdeckt.

[47:59] Ich habe jetzt für eine Aufarbeitung eines Themas zwei Bücher gelesen,

[48:03] zu dem Thema.

[48:05] Da geht es ja wirklich von einer Person, die sich tief damit beschäftigt hat,

[48:13] gibt es da dann Empfehlungen zu.

[48:15] Und das hilft mir im Moment immer sehr.

[48:19] Ich kriege meine auch überall her. Springerlenk, Gerührscouler.

[48:23] Also das habe ich für mich entdeckt.

[48:25] Und was ich auch für mich entdeckt habe, ist GitHub.

[48:29] Da hat der Kollege dann ja auch das Agile Revery Tool entdeckt.

[48:31] Also da gibt es so viele coole Sachen.

[48:35] Ja, also kann ich auch nur empfehlen, da zu stöbern und zu gucken,

[48:38] was gibt es denn da für Sachen.

[48:41] Also höre ich raus, dass du dich jetzt, ich weiß nicht, ob es früher schon so war,

[48:44] aber dass dein Lernstil eher ist, tatsächlich jetzt auch inzwischen Bücher zu lesen.

[48:48] Weil ich habe auch schon mit einigen gesprochen, die jetzt sagen,

[48:50] Bücher, weg damit, ich gucke mir nur noch YouTube-Videos an.

[48:52] Wie würdest du das bei dir so einschätzen?

[48:55] Also ich hatte das am Anfang der Ausbildung auch.

[48:57] Da hat Stefan sogar schon mal gesagt, hast du dir auch das und das Buch angeguckt?

[49:00] Nee, oben, schau doch mal rein.

[49:02] Und das hat sich jetzt wirklich geändert.

[49:04] Also klar schaue ich mir, google ich auch danach.

[49:06] Das wäre ja blöd, das nicht zu tun.

[49:08] Aber ich habe für mich entdeckt, dass in Büchern das Thema,

[49:12] wenn es ein Buch zu dem Thema gibt, das nochmal sehr gut aufgearbeitet ist

[49:17] und man den Aussagen, die da getroffen werden, auch trauen kann.

[49:20] Und nicht weil, wenn man es googelt, weil man es nochmal nachschauen muss.

[49:23] Und mir hat das da sehr gut geholfen.

[49:26] Vor allem auch bei der Arbeit kann ich natürlich keine YouTube-Videos gucken.

[49:29] Und deswegen sind da Bücher da empfehlenswert.

[49:35] Und dann kann man die auch im Studium dann ja auch noch rezitieren,

[49:39] was dann nochmal einen zusätzlichen Mehrwert bietet.

[49:41] Auf jeden Fall, ja. Das stimmt.

[49:43] Ich gucke bei meinen Prüflegungsarbeiten auch immer hinten nochmal auf die Quellenliste,

[49:47] ob die dann auch ein paar Bücher da stehen haben.

[49:49] Also ich kann ja immer nur sagen, unbedingt mal Bücher lesen.

[49:52] Finde ich sehr gut den Hinweis.

[49:54] Aber ich finde es auch mal interessant zu sehen, dass sich diese Meinung auch verändern kann.

[49:57] Ich habe jetzt bei dir zum Beispiel eher vielleicht nicht mit Büchern gestartet,

[50:01] später dazu so ein bisschen hinerwickelt.

[50:02] Ich habe andere Leute schon gesprochen, die halt inzwischen den Büchern abgeschworen haben,

[50:06] weil sie jetzt die neueren Sachen nur noch übers Internet lernen.

[50:08] Also ich finde es immer ganz interessant zu sehen, wie die Leute sich da teilweise auch entwickeln

[50:11] und was so die Vorlieben sind.

[50:12] Und was man so daraus eigentlich mitnehmen kann, ist,

[50:15] jeder muss für sich selbst entscheiden, wie er es am besten lernt.

[50:17] Das finde ich immer ganz spannend zu hören, wie die andere Leute das denn so machen.

[50:20] Okay, ja, vielen Dank für die Tipps.

[50:23] Dann packe ich das natürlich alles auch wieder in die Show-Notes.

[50:26] Dann wird heute eine lange Liste, habe ich so das Gefühl.

[50:28] Und wenn du sonst nichts mehr zu ergänzen hast, dann sind wir ja eigentlich fertig, oder?

[50:32] Ja.

[50:33] Okay, dann sage ich super vielen Dank, dass du dir die Zeit genommen hast.

[50:36] Wir haben heute ganz viel über Codereviews gelernt.

[50:38] Ich hoffe, dass der ein oder andere da draußen vielleicht das als Chance sieht,

[50:41] das einfach mal auszuprobieren.

[50:43] Ich habe so meine Azubis schon als Pflichtprogramm integriert.

[50:45] Die müssen alle zwei Wochen ein Codereview machen bei irgendeinem Kollegen

[50:48] und auch sich selber den Codereview lassen,

[50:50] weil ich das als enorm wichtiges Hilfsmittel empfinde, um sich auch selbst zu verbessern.

[50:55] Von daher, ja, vielleicht ist da jetzt so ein bisschen der Funke übergesprungen bei dem einen oder anderen.

[50:59] Also vielen Dank für deine Zeit.

[51:01] Und wir hören uns dann vielleicht in einem Jahr nochmal zum Thema Softwaredokumentation.

[51:05] Auch ein Lieblingsthema vieler Entwickler, glaube ich.

[51:08] Also erstmal vielen Dank.

[51:09] Gerne, gerne.

[51:14] So, das war das Interview mit Elena.

[51:17] Ich hoffe, es hat dir genauso gefallen wie mir.

[51:20] Codereviews haben wir jetzt, wie du ja auch mitbekommen hast, bei uns im Unternehmen etabliert.

[51:25] Und haben schon in kurzer Zeit wirklich spürbare Benefits davon gehabt.

[51:29] Also wirklich Bugs gefunden, die wir sonst erst auf der Produktion wahrscheinlich gesehen hätten.

[51:33] Oder halt einfach auch eine Diskussion über Coding-Standards.

[51:36] So, dass man irgendwie allgemeine Richtlinien hat, an die man sich bei der Formatierung zum Beispiel hält.

[51:40] Oder Variable-Benennungen oder, oder, oder.

[51:42] Also da sind so viele coole Sachen daraus gekommen mit relativ wenig Aufwand.

[51:46] Man muss sich einfach nur die Zeit nehmen.

[51:48] Man braucht kein Tool oder sonst irgendwas.

[51:50] Man muss einfach nur mal drüber gucken.

[51:52] Und es fördert auch die Kommunikation im Team und so weiter und so fort.

[51:56] Also meine ganz klare Empfehlung.

[51:58] Probier das mal aus.

[51:59] Bei meinen Azubis mache ich es ja auch so, dass sie sogar untereinander und ich natürlich auch bei denen regelmäßige Codereviews mache.

[52:05] Um einfach die Qualität zu verbessern.

[52:07] Und man lernt ja auch selber etwas dabei.

[52:09] Es geht also immer in beide Richtungen.

[52:11] Also, probier das doch mal aus.

[52:13] Und über deine Erfahrungen würden wir uns natürlich über ein Feedback freuen.

[52:16] Oder wenn du auch noch Fragen hast oder Anregungen, irgendwas zu ergänzen.

[52:19] Du kannst die Elena und auch mich natürlich jederzeit kontaktieren.

[52:22] Und der beste Einstiegspunkt dafür sind wie immer die Shownotes unter anwendungsentwicklerpodcast.de

[52:28] slash 123 für die 123. Episode.

[52:32] Kannst du die ganzen Inhalte auch nochmal nachlesen.

[52:34] Und auch Literaturempfehlungen links und so weiter dir anschauen.

[52:37] Also guck doch mal vorbei.

[52:38] Und du findest natürlich auch ein Kontaktformular und die Wege, wie du auch mit Elena in Kontakt treten kannst.

[52:45] Wir würden uns über all dein Feedback sehr freuen.

[52:50] Damit sage ich für heute vielen Dank fürs Zuhören und bis zum nächsten Mal.

[52:55] Tschüss.

Polyglot Clean Code Developer
About the Author
Ausbildungsleiter für Fachinformatiker:innen Anwendungsentwicklung, IHK-Prüfer und ehemaliger Hochschuldozent für Programmierung und Software-Engineering.

Schreibe einen Kommentar

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