Breakpoint Wilson: Selbstkontrolle in der Softwareentwicklung

Rückspiegelprogrammierung
Kommentare

Rücksicht nehmen ist etwas, das im Alltag selbstverständlich ist. Zumindest meistens – denn hin und wieder ist man so besessen von dem, was man macht, dass man sich keine Gedanken über andere macht. Dabei kann es schnell zu einem ernsten Problem werden, wenn man zu überzeugt von der eigenen, genialen Lösung ist …

Gerade die besonders engagierten oder gestressten Autofahrer unter euch werden folgende Situationen kennen: Gekonnt in einem Zug von der linken Spur ganz rechts rüber, um die Ausfahrt noch zu bekommen. Geschickt mal eben über den Standstreifen rechts am Stau vorbeigeballert. Mit Augenmaß gerade noch so noch mal über die rote Ampel gekommen. Es ist ein großartiges Gefühl, wenn man gut ist – Man würde sich am liebsten selbst auf die Schulter klopfen.

Applaus, Applaus!

Wer unmittelbarer Zeuge dieser fahrerischen Glanzleistung werden durfte, wird seinen Kindeskindern noch davon zu erzählen wissen. Eben schnell die durch den Fahrtwind zerzauste rechte Augenbraue mit etwas Spucke auf dem Finger in Stromlinie gestrichen, Ellenbogen aus dem Fenster, und dann wieder volle Konzentration auf den Straßenverkehr. Und natürlich der Kontrollblick in den Rückspiegel, man muss ja schließlich wissen, ob das Publikum noch applaudiert.

Doch statt reihenweise Fans siehst du dort einen schimpfenden Verkehrsteilnehmer; der fand die Motorsportakrobatik offensichtlich ganz und gar nicht lustig. Jetzt und bei näherer Betrachtung muss man zugeben, dass die Aktion sich zwar ziemlich geil angefühlt hat, aber objektiv betrachtet doch irgendwie dumm war. So etwas kennen wir in der Softwareentwicklung auch. Deshalb geht es in diesem Breakpoint Wilson um die „Rückspiegelprogrammierung“.

Code im Rückspiegel

Schaut man nach etwas Zeit auf seine Lösungen, graust es uns meist selbst davor.

Stellt man Menschen das obige Verkehrsbeispiel vor, trifft man in der Regel auf verständnisvoll nickende Köpfe. Die Einsicht unter programmierenden Menschen hinsichtlich ihrer eigenen Stunts korreliert hingegen leider nicht mit den Ergebnissen der ersten Gruppe. Die Prinzipien sind allerdings verblüffend ähnlich: Ganz oft kommt es in der Softwareentwicklung zu Situationen, in denen einzelne oder mehrere Personen ihre Programmierkunst feiern.

Oftmals geht es dabei um besonders lupenreine Lehrbuchlösungen, hochperformanten Code oder offenkundig verrückte Hacks. Schauen diese Menschen rückblickend und nach etwas Zeit über ihre ehemaligen Ergebnisse, graust es ihnen selbst davor. Ihnen wird bewusst, dass sie sich von der eigenen Begeisterung und anderen Emotionen haben verführen lassen.

Selbsteinschätzung

Ganz klar: Wer seinen sechs bis zwölf Monate alten Code noch immer als perfekt betrachtet, hat vermutlich generell eine überdenkenswerte Selbsteinschätzung. Dennoch gibt es hier einen klaren Unterschied zur „Rückspiegelprogrammierung“, denn in der professionellen Softwareentwicklung gehen wir ohnehin schon davon aus, dass wir uns stetig verbessern wollen. Somit akzeptieren wir ein langsames und steigendes Unwohlsein gegenüber vergangener Arbeit. Wir begrüßen dieses Gefühl sogar, laden es zu uns nach Hause ein und servieren ihm Tee. Meist in Form von Pair-Programming, Peer-Reviews, Refactorings und Co.

Dieses gewisse Schamgefühl ist ein regelrechter Freund, der uns als Fortschrittsindikator dient. Das setzt selbstverständlich voraus, dass man den Code erst einmal eine Weile ruhen lässt und sich später nochmal Zeit dafür nimmt.

Abklingzeit

Code klingt nicht ab – es ist die Begeisterung darüber.

Man sagt auch, Code müsse zunächst erst einmal „abklingen“, erst dann könne man ihn mit einem frischen Blick erneut angehen. Was dabei allerdings tatsächlich abklingt, ist nicht der Code, sondern unsere eigene Begeisterung darüber, was wir geschaffen haben. Das ist ziemlich menschlich.

Kleine Menschen beispielsweise rennen ihren Eltern mit dem Töpfchen entgegen und sind stolz auf das, was Sie da gemacht haben. Sie wollen anerkannt und gelobt werden, und das ist so auch sehr richtig und wichtig! Sie sind begeistert über eine soeben entdeckte Fähigkeit – das ist total natürlich. Kurzum: Menschen funktionieren einfach so.

Wenn ein großer Mensch nun erwachsen und mündig werden will, dann gilt es allerdings, sich einiger diese Impulse bewusst zu werden; sich selbst zu Gunsten anderer im Zaum zu halten. Man darf stolz sein auf seine Arbeit, man darf es aber damit nicht übertreiben. Daher ist es ratsam, eine gewisse emotionale Achtsamkeit zu trainieren. Auch und gerade bei der Softwareentwicklung.

Rückspiegel zur Selbstkontrolle

Wer früh und oft Fehler macht, kann schneller daraus lernen und bessere Ergebnisse erzielen.

Wie das Autofahrerbeispiel schon vermittelt, handelt es sich bei der „Rückspiegelprogrammierung“ um eine Art Methode zur Selbstkontrolle. Sie ermöglicht es, sich nicht erst nach geraumer Zeit, sondern bereits frühzeitig mit den eigenen Entscheidungen und Ergebnissen zu beschäftigen.

Betrachten wir das Ganze mal rein logisch: Ohne weiteres gelangen wir ca. alle sechs Monate zu einer grundsätzlichen Einsicht. Angesichts der Geschwindigkeit unseres Berufs ist das schon ein recht langes Erkenntnisintervall. Stellen wir uns aber jetzt einmal vor, wir könnten ein Erkenntnisintervall um fünfzig Prozent oder noch mehr verkürzen, sprich: wesentlich früher damit beginnen, Folgefehler zu vermeiden, um auf Dauer noch besser im eigenen Handwerk zu werden.

Ehrlich gesagt möchte man früh und oft Fehler machen, denn so lange es nicht immer wieder dieselben Fehler sind, lernt man viel daraus und beginnt früher, bessere Ergebnisse zu liefern. Im besten Fall macht einen das also wesentlich früher zu einem erfahrenen Softwareentwickler.

Gefahrensituationen

Sobald du während deiner Arbeit deinen Code für besonders genial und ausgebufft hältst, mach eine Pause und sprich mit jemandem darüber!

Die ganze Verkehrsmetapher birgt für mich persönlich eine ganz besondere Erkenntnis: In den beschriebenen Verkehrssituationen ging es vor allem immer um Menschen, die sich während der Situation besonders gut, talentiert und toll gefunden haben. Erfahrungsgemäß sind auch genau diese Situationen in der Softwareentwicklung die gefährlichsten Momente.

Eine gute Daumenregel lautet: Sobald du während deiner Arbeit deinen Code für besonders genial und ausgebufft hältst, mach eine Pause und sprich mit jemandem darüber. Lass deine Begeisterung ein wenig abklingen und dir von einer vertrauten Person sachliches Feedback geben. In der Regel verrennt man sich nämlich in Schönheit und Perfektionismus oder verliert vor Begeisterung andere wichtige Dinge aus den Augen. Beispielsweise, dass andere Menschen deinen Code auch genauso gut verstehen müssen wie du selbst, oder dass Wartbarkeit und Zielerfüllung in diesem ganz speziellen Fall Priorität vor deiner eigenen Selbstverwirklichung haben.

Rückspiegelprogrammierung

Wie bei den katastrophalen Autofahrern, die denken „verdammt, da war ich aber gerade echt gut“ teilen wir uns die „Straße“ mit anderen Menschen, auf die wir Rücksicht zu nehmen haben. Wir schreiben Code nicht nur für uns oder die Maschine, wir schreiben Code für und mit anderen Menschen. Daher sollten wir es vermeiden, dass unsere vermeintlichen Meisterwerke anderen zu schaffen machen. Kommen dir bei der Softwareentwicklung also solche oder ähnliche Gedanken in den Sinn, ist es Zeit für einen Realitätscheck mit dem Rückspiegel.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -