Frustrierter Mann in Anzug schlagt durch Laptopbildschirm

Programmieren lernen ist vor allem eine Zeitfrage. Es kann auch mal frustrierend sein, wenn man Fehler nicht findet und danach sucht. Das kann man dem Kollegen auf dem Foto deutlich ansehen. Doch mit der richtigen Arbeits- und Vorgehensweise kann man sich den ein oder anderen Ärger sparen.

1. Versuch, neues Wissen gleich krampfhaft aufsaugen zu wollen

Einer der häufigsten Fehler: Von Anfang an alles aufsagen wollen. Viele Anfänger versuchen gleich in den ersten Vorlesungen, bei den ersten Seiten im Buch oder dem Anfang von einem Tutorial einzelne Stichwörter zu behalten. Das funktioniert zum einen eh nicht. Auf der anderen Seite nimmt man sich die Chance, ganz entspannt den Beispielen und Erklärungen zu folgen.

Man muss auch sehen: Es demotiviert unglaublich. Es kommt gar nicht richtig in einen Lesefluss oder ähnliches. Klar darf man z.B. mit einem Textmarker arbeiten. Wir empfehlen aber ausdrücklich: Besser erst einmal komplett lesen oder zuhören und vor allem: verstehen!

2. Zu viel theoretisch Arbeiten

Ein großer Faktor bei der Programmierung ist die Praxis. Das ist mit dem Lernen einer Sprache vergleichbar.

Nehmen wir als Beispiel die englische Sprache: Man kann Bücher über Grammatik lesen, englische Lieder hören und Filme im Originalton hören. Ja, selbst Bücher und Texte auf Englisch lesen ist ein Ansatz. Es ist und bleibt trotzdem schwer auf Anhieb die passenden Sätze zu formen, wenn man nicht regelmäßig übt. Egal ob mündlich oder schriftlich, eigene Aussagen fallen deutlich schwerer.

Das lässt sich ebenso auf die Software Entwicklung übertragen. Man muss selbst “Hand anlegen” und aktiv werden. Nur so lernt man Programmieren. Daher also: Theorie ist gut, aber nur begleitend. Man lernt viel mehr durch die Praxis.

3. Keine eigenen Projekte umsetzen

Wer mit Büchern, Videos oder Tutorials arbeitet, findet immer Code-Beispiele. Wie sonst sollte man konkrete Aspekte einer Programmiersprache erklären? Um ein Gefühl für die Syntax und die Sprache selbst zu entwickeln, ist es sinnvoll den Quellcode abzuschreiben und ihn zu implementieren. Dabei macht man unweigerlich Fehler, an denen man wachsen kann. Aber: Nur Code abtippen reicht nicht aus. Das ist ein ähnliches Problem wie zu viel Zeit mit der Theorie zu verbringen.

Fundierte Programmiererfahrung bekommt man durch eigene Projekte. Mit einer leeren Datei und nur den eigenen Ideen anzufangen, ist eine komplett andere Sache. Man muss sich über den Aufbau Gedanken machen, Quellcode strukturieren und auch die Software selbst implementieren. Dabei lernt man unendlich viel. Hier passt der Vergleich zu den gesprochenen Sprachen wieder sehr gut: Eine Unterhaltung auf Englisch zu verstehen, ist etwas komplett anderes als diese selbst zu führen.

4. Nicht ausreichende Befassung mit Software-Entwurf und der Architektur

Das Sprachgefühl und die Syntax sind der erste Schritt. Inhaltliches Wissen rund um Methoden, Klassen und der gelieferten Bibliothek sind der zweite.

Die große Kunst bei der Software-Entwicklung ist aber nicht nur eine saubere Implementierung von Methoden. Viel schwieriger ist ein geeigneter Software-Entwurf, der auch später anpassbar ist, übersichtlich strukturiert und auf einer guten Architektur aufbaut. Es ist also wichtig, sich zusätzlich mit der Software-Architektur zu befassen. Das beinhaltet unter anderem auch Aspekte wie Design Patterns.

5. Versuchen mit ein und der selben Sprache alle Probleme lösen zu wollen

Ein häufiger Anfängerfehler, die sich gerade mit der ersten Sprache sicherer fühlen und diese gut beherrschen: Man ist schnell geneigt, alle Probleme mit der Sprache lösen zu wollen. Theoretisch kann man bspw. mit PHP auch Serveranwendungen umsetzen, die im Hintergrund arbeiten. Über die Socket Funktionen kann man bspw. einen Webserver realisieren. Aber nur weil man theoretisch auch eine Schraube mit einem Hammer versenken kann, spricht in der Praxis doch vieles dagegen.

Es ist natürlich nicht falsch zu experimentieren. Auch der Webserver ist sicher ein sehr umfangreiches Projekt, bei dem man sehr viel lernen kann. Zum einen wird man einiges über PHP erfahren. Auf der anderen Seite muss man sich mit dem HTTP-Protokoll befassen. In der Praxis ist jedoch später das Ergebnis mit an Sicherheit grenzender Wahrscheinlichkeit einem Apache-Webserver unterlegen.

6. Zu lange nur mit der gleichen Sprache befassen

Eine Gefahr lauert, wenn man mit einer Sprache erst einmal so richtig “warm geworden ist”. Man kann schnell von dem Weg, sich umfassend auf dem Gebiet der Software-Entwicklung auszubilden, abkommen. Sicher ist es angenehm sich intensiv mit einer Sprache zu befassen, vor allem wenn man erst einmal die Grundlagen beherrscht und nicht mehr ständig die Dokumentation benötigt. Man landet wieder in der Komfortzone. Unser Tipp: Da muss man schnell wieder raus.

Die durchschnittliche Empfehlung lautet, dass man pro Jahr eine neue Sprache lernen kann. Innerhalb von einem Jahr kann man sich ausreichend mit den unterschiedlichen Aspekten befassen und einige Erfahrung sammeln. Danach sollte man sein Repertoire erweitern.

7. “Nur” mit Skriptsprachen arbeiten

JavaScript, PHP und Co sind wunderbare Sprachen, die für bestimmte Zwecke ein geeignetes Mittel darstellen.  Ein vollständiger Programmierer sollte jedoch nicht nur Skriptsprachen kennen, sondern sich auch mit anderen Gebieten auseinander setzen. Das rundet zum einen das Profil ab. Aber auch für die Arbeit mit Skriptsprachen lernt man dazu. Verschiedene Sprachen legen unterschiedlichen Wert auf verschiedene Aspekte. Viel Wissen lässt sich von der einen auf die andere Sprache übertragen. Das Ergebnis kann bessere Software, kürzere Entwicklungszeit oder höhere Software-Qualität sein.

Neben den reinen Skriptsprachen ist es daher mittelfristig gut, sich zusätzlich auch kompilierte Sprachen wie Java oder C/C++ anzuschauen. Zumindest für das eigene Verständnis, ist auch ein Ausflug in die Assembler Welt durchaus sinnvoll.

8. Zu wenig Arbeit mit einem Debugger

Soll ein Fehler nachvollzogen werden, werden im ersten Ansatz häufig die Variablenwerte an unterschiedlichen Stellen betrachtet. Nahe liegt, diese einfach bei der Ausführung ausgeben zu lassen. Das ist jedoch sehr umständlich und manchmal gar nicht möglich. Außerdem lernt man dabei auch nicht so viel.

Statt also System.out.println, echo, print usw. zur Fehlersuche zu benutzen, sollte man sich mit Debugging von Beginn an befassen! Dazu wird direkt im Editor der Programmfluss nachvollzogen. Zur Laufzeit kann man dann an konkreten Stellen die Variablenwerte einsehen und Zeile für Zeile nachvollziehen, was passiert. So lernt man eigene, aber auch fremde Software im Detail kennen.

9. In die falsche Richtung arbeiten

Motivation ist ein ganz entscheidender Faktor. Nur wer nachhaltig am Ball bleibt, kann erfolgreich sein. Das ist so ähnlich wie bei einer Diät: Es gibt realistische und seriöse Ansätze und Ernährungsweisen, die deutlich schneller Ergebnisse ermöglichen. Allerdings ist es gleichzeitig auch schwieriger diese Diäten durchzuhalten. Das Problem: Es ist schwerer sich über Wochen und Monate komplett daran zu halten. Eine etwas weniger effektive Methode ist besser, wenn man dabei ausreichend motiviert bleibt.

So ist es bei der Entwicklung auch! Grundlagen und Hintergrundwissen sind toll. Ein vollständiger Programmierer sollte sich mit der Technologie auskennen. Es bringt im Alltag einem Webentwickler allerdings wenig, wenn er sich deshalb ein Jahr lang mit Assembler befasst. Davon hat er noch nicht einmal an seinem Traum gearbeitet, eine Sprache lernen mit der er Software für das Web schreiben kann.

Gleiches gilt für andere Bereiche ebenso: Warum erst C/C++, HTML, JavaScript oder Python lernen, wenn man eigentlich Android Apps entwickeln möchte? Hier empfiehlt sich der Einstieg in Java. Das macht viel mehr Spaß.

Bei aller Liebe zu Hintergründen und Grundlagenwissen, sollte man das Ziel also nicht aus den Augen verlieren.

10. Keine Arbeit mit automatisierten Tests

Software muss getestet werden. Da führt kein Weg dran vorbei. Wenn es sich um kleinere Projekte handelt, ist das auch gar kein Problem. Man kann die wenigen Funktionen überblicken und manuell testen. Wird die Software allerdings nur etwas größer und umfangreicher, kann man nicht mehr alle Aspekte berücksichtigen.

Ein häufiger Fehler ist, sich mit Unit-Testing und Test-Driven-Development erst viel zu spät zu befassen. Das wird gern als etwas gesehen, was man als einzelner Entwickler nicht braucht. Als etwas, dass in Unternehmen interessant ist. Aber, Software-Qualität hat mehrere Facetten. Zum einen wird natürlich wirklich jede Methode, Funktion und Logik getestet. Man weiß also auch nach Änderungen, ob es Probleme gibt. Dabei werden vor allen Dingen Seiteneffekte abgefangen, die sich auf unerwartete Stellen im Quellcode auswirken können. Zudem lernt man aber auch, sich bei seiner Logik auf das Minimum zu beschränken. Man muss sich mit dem eigenen Code noch einmal genau befassen, um ihn mit Tests abzudecken. Das ist sehr lehrreich.

Daher also: Unit-Testing ist unbedingt auch etwas ganz am Anfang der Karriere. Wenn man mit der eigenen Sprache sicherer wird, kann und sollte man ruhig mal einen Blick in diese Welt riskieren!

11. Verzicht auf Versionsverwaltung

Versionsverwaltung mittels Git ist toll. Das gilt bei den ersten Projekten ebenso wie später, wenn mehr Routine vorhanden ist. Speziell am Anfang kann man einfach mal einen Stand “einfrieren” und mutig ausprobieren. Wenn es nicht klappt, rudert man mit nur einem Befehl wieder zum alten Stand zurück! Das bedeutet, dass alle Änderungen in Dateien rückgängig gemacht werden können. Außerdem protokolliert man seine Änderungen gleichzeitig. Das ist von unschätzbarem Wert.

Sicher, man muss sich ein wenig Zeit nehmen um mit Git warm zu werden. Dazu bietet sich bspw. unser kostenloser Git Kurs an.  Eine moderne Entwicklungsumgebung bringt in der Regel aber gleich Unterstützung für Git mit. Bei der täglichen Arbeit läuft also das meiste im Hintergrund ab.

12. Zu früh aufgeben bzw. nicht am Ball bleiben!

Eines darf man in jedem Fall nicht machen: Aufgeben! Nur wer am Ball bleibt, schafft es. Dabei ist das eigentlich gar nicht so schwer! Man sollte nicht übertrieben an die Sache heran gehen! Vielleicht einfach als Ziel setzen, sich zweimal die Woche eine Viertelstunde Zeit zu nehmen. Bei Interesse darf es auch mehr werden, aber die zwei Mal 15 Minuten sind Pflicht. Daraus entsteht eine Angewohnheit, die sich automatisch ausbaut. Versprochen!

Neben der eigenen Disziplin ist auch die mächtige Wirkung der ganzen Materialen ein Aspekt. Schaut man sich die Software-Welt heute an, wirkt alles schnell sehr überwältigend. Es gibt eine Menge Programmiersprachen, viele Teilbereiche und immer neue Technologien. Genug, um sich ein Leben lang nur mit dem Lernen zu befassen.

Programmieren lernt man nicht von heute auf morgen. Es ist kein Sprint, viel mehr ein Marathon. Eigentlich ist es sogar eine lebenslange Reise, da es immer etwas zu entdecken gibt.

Schreib einen Kommentar

Your email address will not be published.