• Thomas Kroth

Quick and Dirty! Oder doch lieber sauber programmieren?

Warum die Anwendung von Clean Code Prinzipien Ingenieuren viel Ärger erspart.



Das Berechnungsskript ist nicht da, wo man es vermutet – die Auswerteroutine liefert falsche Werte, aber der Fehler lässt sich nicht lokalisieren – der Code vom Kollegen ist total unübersichtlich! Haben Ihre Ingenieure genau solche Probleme? Kennen Sie derartige Situationen sogar selbst? Dann haben wir hier eine Reihe von Tipps für Sie auf Lager, das Thema nachhaltig anzugehen.


Dass Ingenieure schnell mal zum Programmierer werden, ist notwendig, denn sie müssen jeden Tag komplexe und umfangreiche Gleichungen lösen. Nicht selten bleibt bei diesem eher autodidaktischen Vorgehen das essenzielle Know-how eines Softwareentwicklers auf der Strecke. Um nachhaltige Software zu entwickeln, die dem gesamten Unternehmen einen langfristigen Mehrwert bringt, müssen Strukturen geschaffen und grundlegende Praktiken aus dem Bereich der Softwareentwicklung angewendet werden.


Gut gemeint ist nicht immer gut gemacht

Es ist in jeder technischen Ingenieursdisziplin das Gleiche: Formeln und Zahlen sind die Grundlage für Auslegungen und Ingenieure arbeiten täglich damit. Theorien und wissen-schaftliche Erkenntnisse stehen in Form von Gleichungen bereit, um für die Berechnung von wichtigen Kennzahlen angewendet zu werden.

In den meisten Spezialgebieten wird eine gewisse Menge an Gleichungen immer wieder benötigt. Insbesondere für solche hat es sich bewährt, diese in entsprechenden Berechnungsprogrammen als Skript zu programmieren. Aus Bequemlichkeit oder Unwissenheit entsteht dabei oft nachlässig programmierter Code. Es kommt nicht selten zu Szenarien wie den folgenden:

  • „Wo habe ich das Skript nochmal abgelegt?“

  • „Welche Version hat jetzt nochmal funktioniert?“

  • „Ich verstehe jetzt gar nicht mehr, wie das Programm funktioniert?“

  • „Hm, wie habe ich das damals nochmal gemacht?“

  • oder einfach nur „???“


Noch schwieriger wird es, wenn der Code von einem Kollegen stammt, der vielleicht das Unternehmen verlassen hat oder im Sabbatical weilt. Da ist Ärger vorprogrammiert.

Ist Ihnen das auch schon passiert? Diese Fragestellungen ergeben sich unabhängig von der Programmiersprache: ob MATLAB, Fortran, Python oder auch C++ ist am Ende egal. In jedem Fall ist es wichtig, schon von Anfang an die gängigen Fehler zu vermeiden.


Wie aus Zeitmangel enorme Schwachstellen im Code entstehen

Das Programmieren ist nicht die zentrale Arbeitsaufgabe eines Ingenieurs, deshalb muss es hier schnell gehen – Zeitsparen als Zielvorgabe. Dies führt zwangsläufig zu einer Arbeitsweise, welche anfänglich einen schnellen Erfolg bringt, mittel- und langfristig aber einen gravierenden Mehraufwand bedeutet.

Achtung – nicht nachmachen! Beliebte Taktiken, um beim Programmieren Zeit zu sparen:

  • Abkürzungen bei Variablen- und Funktionsnamen

  • Lange, unüberschaubare Funktionen

  • Mehrfaches Duplizieren von gleichem Code

  • Nicht ausreichend getesteter Code

  • Keine nachvollziehbare Versionskontrolle

Dieses Vorgehen erweist sich häufig am Ende als teure Schwachstelle. Es ist leider Standard in vielen Unternehmen und selbst in Forschungseinrichtungen nicht unüblich. Meist sind so entstandene Programme nicht langlebig. Sie helfen dem Entwickler nur für einen kurzen Zeitraum oder sogar nur für die aktuelle Aufgabenstellung. Kollegen oder gar das ganze Unternehmen haben im Grunde keinen Mehrwert.

Mit wenigen Mitteln zu nachhaltigem Code

Die grundlegenden Prinzipien um einen funktionierenden, nachhaltigen Code zu schreiben, sind unter dem Begriff Clean Code zu finden. Sie wurden von Softwareentwickler und Autor Robert C. Martin in seinem Buch Clean Code zusammengefasst.

Im Kern geht es darum, Code zu schreiben, der von jedem Programmierer gut zu lesen ist und dessen einzelne Bestandteile in zugehörigen Tests validiert sind. Nur so kann Code mit geringem Aufwand korrigiert und weiterentwickelt werden. Einen umfangreichen Einblick in diese Prinzipien ermöglicht der Artikel Prinzipien bei der Entwicklung von sauberem Code.

Für einen Ingenieur kann im ersten Schritt schon eine Auswahl dieser Prinzipien helfen, die Codequalität drastisch zu erhöhen:

  • Die Namen für Methoden und Variablen müssen selbstsprechend sein, sodass sich die Codezeilen wie ein Text lesen lassen – beispielsweise anstatt „c4cycl“ besser „counter_for_cycles“ oder als Camel Case „counterForCycles“.

  • Das Programm sollte in kurze Methoden (= Funktionen) aufgeteilt werden, sodass jede Methode möglichst nur eine konkrete Aufgabe erfüllt. Oft wird hier als Richtwert eine Anzahl von 4-6 Zeilen genannt.

  • Duplizierter Code sollte in jedem Fall vermieden werden. Soll im Code mehrfach die gleiche Aufgabe erledigt werden, wird dafür immer dieselbe Methode verwendet. Ändert sich diese Methode, so ändert sich der Code nur an einer einzigen Stelle im Programm.

  • Jede Methode sollte einen eigenen Test haben. In der Regel sind einzelne, kleine Aufgaben, sehr gut durch automatisierte Tests verifizierbar. Sind alle Methoden durch solche Tests abgedeckt, verringert sich das Fehlerrisiko auf ein Minimum. Die Grundlagen hierfür finden sich unter dem Stichwort Test Driven Development, kurz TDD. Weitere Infos: Testgetriebene Entwicklung

  • Zur Versionierung sollte eine geeignete Versionskontrolle wie z.B. GitLab verwendet werden. Hiermit kann der Code gesichert, Änderungen nachvollzogen und Kollegen in die Entwicklung mit eingebunden werden.

Die hier aufgezählten Mittel sind im Grunde schnell und einfach anwendbar. Lediglich das Thema Testen scheint im ersten Moment einen größeren Aufwand zu bedeuten. Dies zahlt sich aber durch eine hohe Codequalität mehrfach wieder aus. Fehler werden von Anfang an auf ein Minimum reduziert und zukünftige Änderungen oder Weiterentwicklungen am Code können ohne Bedenken durchgeführt werden.

Eine ordentliche Teststruktur hält die Codequalität auf dem anfänglich hohen Level.

Neben diesen Prinzipien spielen weitere Faktoren eine Rolle: Eine einheitliche Entwicklungsumgebung für die programmierenden Ingenieure ist eine wichtige Basis. Fast noch wichtiger sind der Austausch und die gegenseitige Unterstützung zwischen den Programmierern. Dies kann durch Pair Programming und Code Reviews gefördert werden. Programmieren ist keine Einzeldisziplin, Teamarbeit führt zu besseren Ergebnissen.


Und wie gehen Sie das nun am besten an?

Soll Ihr Unternehmen auch langfristig von den Skripten und Programmen Ihrer Ingenieure profitieren? Geben Sie Ihren Mitarbeitern eine Struktur und Werkzeuge an die Hand.

Im Allgemeinen ist eine kurz- bis mittelfristige Begleitung bei der Einführung der beschriebenen Prinzipien ratsam, um einen hohen und beständigen Mehrwert zu erzielen. Dies kann durchaus mit minimalem Aufwand in Form von bedarfsabhängigem Support erfolgen.




Gerne helfen wir Ihren Ingenieuren dabei, die Prinzipien des Clean Code zu verinnerlichen und nachhaltigen Code zu schreiben. Sprechen Sie uns an.



Dr. Anja Zonaras

Kundenbetreuung M. +49 (0)1525 20 17 570

E. zonaras@tesolva.de


Mehr Informationen finden Sie unter: www.tesolva.de



Folgen Sie uns auch auf LinkedIn und Xing, damit Sie keinen Beitrag mehr verpassen.

Quellen: Clean Code: https://de.wikipedia.org/wiki/Clean_Code

Prinzipien bei der Entwicklung von sauberem Code: https://entwickler.de/online/agile/clean-code-134128.html


Testgetriebene Entwicklung: https://de.wikipedia.org/wiki/Testgetriebene_Entwicklung


Clean Code Developer: https://clean-code-developer.de

133 Ansichten

Aktuelle Beiträge

Alle ansehen