Einfach, schnell und effektiv Programmieren üben. So geht's!

Üben ist eine der wichtigsten Tätigkeiten um professionelle Softwareentwicklung möglichst effizient zu erlernen. Ohne das praktische Umsetzen kannst du zwar Wissen aufnehmen, aber du behälst es nicht wirklich lange und dir fehlt die Erfahrung wie du das Wissen anwenden sollst. Das kennst du vielleicht von grundlegenden Konzepten wie der Objektorientierung. In der Theorie hört sich das erstmal noch irgendwie logisch an (zumindest nach einiger Zeit ;), aber wenn du deine erste Klasse finden sollst oder dich entscheiden musst zu welcher Klasse eine Methode gehört, dann bist du bestimmt schon mal ins Schwitzen gekommen. Mir geht es nach über 13 Jahren Softwareentwicklung manchmal noch so.

An diesem Punkt hilft Erfahrung und die bekommst du durch Übung. Allerdings solltest du nicht “nur” irgendwas üben. Sondern du kommst am schnellsten weiter, wenn du fokussiert übst. Arbeitest du beispielsweise an einem neuen Projekt (und willst eigentlich Objektorientierung üben), dann beschäftigst du dich mit vielen Aufgaben gleichzeitig. Du musst das Problem (also die Anwendungsdomäne) verstehen, du musst dir Lösungen überlegen, du arbeitest vielleicht an einem Plan, du beschäftigst dich mit neuen Technologien und so weiter. Du machst also vieles was dich ablenkt. Besser gesagt du erledigst Aufgaben die für das Projekt wichtig sind, aber dich von deiner eigentlichen Übung ablenken.

Voraussetzungen für effektives Üben

Willst du wirklich fokussiert üben, dann solltest du folgende Eingangsvoraussetzungen schaffen:

Eine für dich niedrige Einstiegshürde - Wenn du gerade anfängst mit Softwareentwicklung, dann braucht es unter Umständen schon einige Zeit, bis du ein neues Projekt in deiner Entwicklungsumgebung gestartet hast. Bist du schon etwas erfahrener, dann überlegst du vielleicht erstmal wie du dein Projekt strukturierst. Alles das ist zwar wichtig, aber nicht notwendig, wenn du beispielsweise üben willst wie du eine foreach Schleife realisierst. Je weniger Vorbereitung du benötigst um so schneller übst du tatsächlich. Außerdem bedeutet mehr Vorbereitung auch, dass du mehr Motivation brauchst!
Ein klares Übungsziel - Überlege dir bevor du anfängst was du genau üben willst. Im Artikel Coding Kata - Üben, aber bitte mit Ziel zeige ich dir wo du Übungen findest und das du die selbe Übung immer wieder machen kannst. Wichtig ist dabei immer, dass du dir ein klares Übungsziel setzt und dann auch kontinuierlich überprüfst ob du wirklich noch dabei bist oder gerade etwas machst, was mit der Übung eigentlich nichts mehr zutun hat.
Eine Übung ist ein Prototyp - und Prototypen sollten weggeschmissen werden. Es gibt so vieles was du am Quellcode “richtig” oder “schön” machen kannst. Das ist jedoch für eine Übung nicht relevant (es sei denn du übst genau das). Ich sage mir immer, dass die Übung ein Prototyp ist und den schmeiße ich nach der Übung einfach weg. So sammeln sich bei mir weder hunderte von kleinen angefangenen Projekten, noch muss ich mir überlegen was ich im Quellcode alles beachten muss um ihn später wieder verstehen zu können. Bei der Übung geht es wirklich darum Erfahrung zu sammeln und dafür brauchst du das Resultat nicht.
Fang klein an - In unserer “höher, weiter, schneller Gesellschaft” haben viele Leute verlernt sich mit den Details zu beschäftigen. Du auch? In meinen Kursen und Trainings sehe ich immer wieder, dass angehende Entwickler nicht genau wissen wie eine Methode erstellt wird, aber schon komplexere Aspekte wie Vererbung und Polymorphismus lernen. Das kann zwar teilweise gut sein, aber warum nicht einfach mal die Grundlagen üben? Wenn du in 10 Minuten 5 Methoden erstellt hast, dann kannst du immer noch etwas schwierigeres machen. Fängst du erstmal mit den kleinen Dingen an, dann hast du schnell Erfolgserlebnisse und kannst bei Bedarf auch nach 10 Minuten wieder aufhören. Wichtig ist eine gute Balance. Übst du nur was du bereits beherrschst, dann kommst du auch nicht weiter!
Mach Pausen - Wenn du wirklich klein anfängst und auch nur 10 Minuten übst (das reicht, wenn du es regelmäßig machst), dann brauchst du eher keine Pause. Nach 20 Minuten würde ich aber auf jeden Fall eine Pause machen. Zum einen ist intensives Üben wirklich anstrengend und insbesondere deinen Augen hilft es, wenn du mal für einen Moment etwas anderes fokussierst. Zum anderen gibt es soviele Ablenkungen. Es gibt so unendlich viele spannende Technologien, Methoden, Bibliotheken, … Da passiert es immer wieder, dass du beim Üben etwas tolles findest und dich davon ablenken lässt. Wenn du nach 20 Minuten eine Pause machst und dabei oder danach für ein paar Sekunden überlegst ob du noch das machst was du eigentlich machen wolltest, kannst du wenigstens bewußt entscheiden ob dir deine Übung oder was anderes wichtiger ist.
Reflektiere nach der Übung - Nimm dir nach jeder Übung einen Moment Zeit zum Reflektieren. Dabei gehst du die Übung nochmals bewußt durch und überlegst was genau du gelernt hast, was dir immer noch unklar ist, wie das Geübte mit anderen Dingen die du gelernt hast in Verbindung steht und so weiter. Wenn du richtig schnell voran kommen willst, dann kannst du auch ein kleine Übungstagebuch verfassen. Dabei geht es weniger darum, dass du dir das später alles nochmals anschaust, als viel mehr darum, dass dir das Aufschreiben beim Reflektieren hilft.

Beispiel: In wenigen Minuten eine Übung umsetzen

Hast du bei der Masse der Voraussetzungen einen Schrecken bekommen? Hast du schon gar keine Lust mehr zum Üben? Dann schau dir meinen üblichen Ablauf einer Übung an. Daran wirst du sehen, dass Üben nicht viel Zeit benötigt. Im folgenden zeige ich dir die einzelnen Schritte die ich bei jeder Übung umsetze anhand eines ganz konkreten Beispiels. Als kleiner Bonus kannst du die Übung sogar gleich mitmachen. Los geht’s:

1. Minute: Ziel definieren

In dieser Übung möchte ich die wichtigsten Methoden und Eigenschaften der Klasse Dictionary<> anwenden. Ich kenne diese Klasse zwar, aber ich habe sie bisher noch nicht häufig verwendet und möchte so etwas mehr Erfahrung damit sammeln.

Zusätzlich möchte ich noch etwas das Erstellen von Methoden üben. Das kann ich zwar schon ganz gut, aber in diesem Fall versuche ich den Methodenkopf ohne weitere Hilfe zu schreiben um zukünftig schneller entwickeln zu können. Wenn du bei jedem Befehl in einem Beispiel oder Artikel nachschauen musst, kostet dich das sehr viel Zeit. Beim Einstieg ist das okay, aber wenn du besser werden willst, dann solltest du versuchen die Syntax die du immer wieder verwendest auswendig aufschreiben zu können.

Um diese beiden Ziele in einer Übung umzusetzen, habe ich mir die Function Kata - Zeichen zählen ausgesucht. Du kannst natürlich auch den entgegengesetzten Weg gehen und dir eine Übung aussuchen und dann definieren was genau du damit üben willst.

Wichtig ist einfach nur, dass du ganz bewußt ein oder zwei kleine Ziele definierst. Hast du eine Übung bereits mehrfach gemacht, kannst du auch größere Ziele definieren.

Dokumentation: Ich habe mir für diese Übung eine Notiz in Evernote angelegt. Darin schreibe ich in max. 2 Sätzen meine Übunsgziele auf und verlinke die Aufgabenbeschreibung. So kann ich später nochmals sehen was ich genau gemacht habe.

2. + 3. Minute: Projekt vorbereiten

Um eine möglichst niedrige Einstiegshürde zu haben, werde ich die Übung im C# Pad umsetzen. (Eine Einführung ins C# Pad findest du in diesem Artikel).

Also erstelle ich mir dort einfach eine Klasse und eine erste Methode die ich aufrufen kann um meine Methode zum “Zeichen zählen” auszuführen. Wie ich das genau gemacht habe, siehst du hier.

Auch bei der Verwendung des C# Pad ist ein wenig Vorbereitung nötig. Allerdings finde ich es wesentlich einfacher als erst Visual Studio zu starten, ein Projekt anzulegen usw.

HINWEIS: Du kannst den im C# Pad erstellten Quellcode einfach ausführen. Wenn du diesem Link folgst. Dann führe folgende Schritte aus und du siehst die Ausgabe des initialen Programms:

Drücke Go -> Cursor erscheint in einer neuen ersten Zeile
Gebe ZeichenZaehlen.Ausfuehren() ein -> damit sagst du, dass die statische Methode Ausfuehren der Klasse ZeichenZaehlen ausgeführt werden soll. Wenn du in einer Entwicklungsumgebung arbeitest, würdest du diese Zeile in die Main Methode schreiben.
Drücke nochmals Go -> Die Zeile ZeichenZaehlen.Ausfuehren() wird nun ausgeführt und du siehst die Ausgabe.

Jetzt bist du dran: Der Artikel ist schon ganz schön lang und wenn meine ganze Theorie korrekt ist, dann solltest du in wenigen Sekunden das Grundgerüst für die Übung ausführen können. Öffne einfach diesen Link und führe die eben beschriebenen 3 Schritte selber aus. Ich warte hier auf dich ;-).

Zwischenfazit: In 3 Minunten, wenn das alles für dich neu ist auch ein paar Minuten mehr, hast du bereits dein Übungsziel definiert und das Grundgerüst fertig. Nun kannst du anfangen die eigentliche Übung umzusetzen.

4. bis 10. Minute: Übung durchführen Iteration #1

Als nächsten Schritt habe ich mich entschieden die Methode ZeichenZaehlen wie in der Aufgabestellung zu definieren und diese Methode dann aufzurufen. Damit ich gleich sehen kann ob die Ausgabe auf die Konsole funktioniert, werde ich erstmal einen festen Eintrag in das Dictionary einfügen.

Jetzt bist du dran: Wenn du selber die ersten Schritte dieser Übung umsetzen magst, dann klicke auf diesen Link, erstelle die Methode ZeichenZaehlen und rufe sie aus der Methode Ausfuehren auf. Wenn du glaubst, dass alles soweit okay ist, dann führst du deinen Quellcode wieder wie eben beschrieben aus. Ziel sollte sein, dass du eine Ausgabe bekommst die ungefähr so aussieht: D: 1. Das bedeutet, dass das große D einmal in der Zeichenkette vorkam. Dabei schummeln wir bei der Ausgabe momentan etwas, weil noch kein tatsächliche Berechnung stattfindet.

Wie du in dieser Musterlösung sehen kannst, habe ich folgende Schritte ausgeführt und dabei einige Erkenntnisse gewonnen:

Methode definieren - Okay, der Methodenkopf war in der Aufgabenstellung bereits beschrieben und somit war das wirklich einfach. Da die Methode Ausfuehren eine statische Methode ist, habe ich mich entschieden die Methode ZeichenZaehlen ebenfalls als static zu definieren, damit ich sie aufrufen kann.
Dictionary anlegen - Jeder Eintrag in einem Dictionary<TKey, TValue> besteht aus einem Schlüssel und einem Wert. Da es sich bei dem verwendeten Dictionary um ein generisches handelt, muss sowohl für den Schlüssel (char) wie auch den Wert (int) der Datentyp angegeben werden.
Fixen Eintrag hinzufügen - Die Add Methode erwartet ein Objekt von KeyValuePair welches die passenden Datentypen haben muss. Die Klasse KeyValuePair hat einen Konstruktor dem ich gleich die passenden Daten (D als Buchstabe für den Schlüssel und 1 als die Anzahl bzw. den Wert) mitgeben kann.
Elemente des Dictionary ausgeben - Wie jede Collection kann ich mit foreach mir jedes Element im Dictionary ansehen. Jeder Eintrag ist natürlich wieder ein Objekt von KeyValuePair welches Eigenschaften für den Schlüssel und den Wert anbietet.

Damit habe ich diese Iteration erstmal erledigt und einen guten Zwischenstand erreicht. Jetzt gönne ich mir einen Schluck Wasser und schau einmal nach draußen damit meine Augen sich etwas entspannen können. Bis gleich ;-).

Dokumentation: Häufig passiert es mir in dieser Zeit, dass ich beim Suchen (beispielsweise wie eine Methode genau verwendet wird) über Interessante Klassen, Methoden, Artikel, … stolpere. Diese schreibe ich mir auf einen Schmierzettel, oder in die Notiz bei Evernote und mache dann mit der Übung weiter. So habe ich meinen Gedanken festgehalten, aber er hält mich nicht von der Übung ab.

Zwischenfazit: Nach 10 Minuten habe ich bereits 2 Methoden angelegt, ein Dictionary angelegt und die Add Methode verwendet sowie die Ausgabe von Elementen eines Dictionary gemacht. Damit habe ich eigentlich meine Übungsziele schon erreicht. Alles was jetzt noch kommt ist die Kür.

11. bis 20. Minute: Übung durchführen Iteration #2

Natürlich will ich auch die Aufgabe lösen und ich will auf jeden Fall noch üben wie ich feststelle ob gewisse Einträge in einem Dictionary existieren und wie ich Werte ändern kann. Also auf in die nächste Runde!

Jetzt bist du dran: Zum Schluß will ich dich noch ein wenig herausfordern. Ohne das ich weitere Hinweise gebe, kannst du jetzt ja mal probieren die Methode ZeichenZaehlen so anzupassen, dass sie für die Zeichenkette “Das darf nicht sein” die passende Anzahl der enthaltenden Buchstaben ermittelt. Dazu kannst du an diesem Stand wieder aufsetzen. ACHTUNG: Bei der beschriebenen Lösung in der Aufgabenbeschreibung hat sich scheinbar ein Fehler eingeschlichen. Die Anzahl an Leerzeichen ist 3 und nicht wie dort beschrieben 2!

Musterlösung: Meine Lösung findest du hier. Auch bei dieser Iteration habe ich wieder einige Erkenntnisse erlangt und will dir auch die von mir ausgeführten Schritte erklären:

Buchstaben einer Zeichenkette durchlaufen - Wenn du dir das C# Tutorial Deutsch zum Thema der Datentyp string angeschaut hast, dann weisst du, dass ein string nichts anderes als ein Feld von char ist. Somit kannst du die einzelnen Buchstaben eines string mit dem Indexoperator [] zugreifen und auch die foreach Schleife auf einen string anwenden.
Prüfen ob ein Schlüssel existiert - Die Klasse Dictionary bietet verschiedene Methoden an um zu überprüfen ob Einträge existieren. Erst hatte ich die Methode TryGetValue. Diese versucht einen Wert für einen angegebenen Schlüssel zu holen. Das ist jedoch nicht wirklich was wir brauchen. In den Beispielen zur Klasse Dictionary auf MSDN wird gezeigt wie die Methode ContainsKey verwendet wird. Das hilft dann besser um festzustellen ob ein Schlüssel vorhanden ist.
Wert setzen / verändern - Das ich auf den Wert eines Eintrags zugreifen kann mit dem Indexoperator [] war mir bekannt. Allerdings habe ich durch diese Übung gesehen, dass ich auch den += Operator in diesem Zusammenhang benutzen kann um den Wert zu erhöhen. Achtung: Bitte beachte den Datentyp des Wertes! In diesem Fall ist das int und somit geht das hier. Wenn der Datentyp des Wertes eine von dir definierte Klasse ist, dann wird das nicht funktionieren, es sei denn du hast den += Operator implementiert.

Dokumentation: Auch jetzt passiert es immer wieder, dass ich Ideen und Fragen habe. Beispielsweise frage ich mich wirklich wie das mit dem += Operator funktioniert. Kann ich den so einfach für eine Klasse definieren? Was würde es für eine eigene Klasse bedeuten? Wie kann ich 2 Autos addieren bzw. um einen festen Wert erhöhen? Auch diese Punkte schreibe ich wieder auf und widme mich danach wieder der Übung.

21. Minute: Reflektieren

Auch wenn du nur ganz wenig Zeit hast, ist es aus meiner Erfahrung enorm wichtig, dass du dir einmal ganz bewußt machst, was dir die Übung gebracht hat. Du kannst auch darüber nachdenken ob du die vorgestellten Voraussetzungen für effektives Üben eingehalten hast.

Für diese Übung habe ich mir beispielsweise folgende Fragen gestellt und entsprechend beantwortet:

Habe ich mein Übungsziel klar definiert und erreicht? - Die Definition war nicht wirklich schlecht, aber sie hätte auch noch etwas konkreter sein können. Die Klasse Dictionary ist von ihrer Funktionalität recht umfangreich. Ich bin mir also nicht sicher ob ich wirklich die wichtigen Eigenschaften und Methoden verwendet habe. Klar ist, dass ich sowohl das Dictionary verwendet habe wie auch Methoden erstellt habe. Somit habe ich also meine Übungsziele erreicht. Für die nächste Übung werde ich mir nochmals überlegen wie ich die Übungsziele klarer definieren kann. Außerdem sollte ich das Thema Dictionary weiterhin auf meiner Übungsliste behalten, damit ich weitere Eigenschaften und Methoden lerne anzuwenden.
Wie lange habe ich für die Übung gebraucht und habe ich das erwartet? - Hättest du mich vor der Übung gefragt wie lange ich brauche, dann hätte ich gesagt max. 10 Minuten. Wie du siehst ist es doch ein wenig länger geworden. Dabei geht es mir bei dieser Beobachtung nicht um eine Bewertung sondern um das Feststellen. Für die nächste Übung kann ich mir nun überlegen ob ich mir ein kleineres Ziel definiere oder mehr Zeit einplane. Beides ist für mich okay. Es geht mir nur um meinen persönlichen Fortschritt!
Kann ich die Einstiegshürde noch verringern? - Ich musste mich erstmal mit C# Pad bekannt machen. Daher wird es bei der nächsten Übung sowieso einfacher und schneller sein. Darüber hinaus sollte es möglich sein ein initiales Projekt (das was in den Minuten 2 und 3 gemacht wurde) vorzubereiten. Damit kann ich noch schneller starten.
Habe ich kleine Schritte gemacht? - Absolut. Für meinen Kenntnisstand war die Größe der Schritte perfekt. Vielleicht hätte ich sogar einen Zwischenschritt weg gelassen. Ich fand allerdings wichtig dir zu zeigen, dass sehr kleine Schritt möglich sind.
Habe ich Pausen gemacht? Was haben mir die Pausen gebracht? - Ich habe Pausen gemacht und mich dabei sogar bewegt. Das Resultat davon ist, dass ich mich momentan recht fit fühle und nicht ausgelaugt wie sonst manchmal nach intensiver Arbeit. Da spielen natürlich viele Aspekte rein, aber ich bin überzeugt, dass die Pausen ein wichtiger Faktor sind.
Was mache ich mit den aufgeschriebenen Fragen? - Sind die Fragen eher so, dass ich etwas nachlesen / recherchieren muss, oder kann ich vielleicht einfach etwas ausprobieren? Je nachdem kann ich mir aus den Fragen neue Übungen definieren oder sie auf meine ToDo-Liste schreiben.

Die Fragen über die du reflektierst können sich von Übung zu ändern oder auch gleich bleiben. Für mich ist wichtig, dass ich konkrete Aufgaben aus meinen Antworten ableite. So werde ich beispielsweise für mich nochmals recherchieren und überlegen wie ich ein Übunsgziel optimal definieren kann und vor allem welche Aspekt ich wirklich üben will und muss.

Das Reflektieren hat einen weiteren wesentlichen Vorteil. Es ist für mich ein klarer Abschluss der Übung. Sonst kommt es häufig vor, dass ich über offene Punkte noch viele Stunden später nachdenke. Habe ich mir jedoch eine oder wenige Minuten gegönnt um zu reflektieren ist die Übung für mich klarer abgeschlossen.

Fazit

Respekt! Du hast dich durch wahnsinnig viele Zeilen gearbeitet. Danke, dass du immer noch bei mir bist!

Ich hoffe ich konnte dir vermitteln für wie wichtig ich das Thema Üben im Kontext des Lernens von professioneller Softwareentwicklung erachte. Ich habe dir einerseits gezeigt welche Voraussetzungen du schaffen kannst um einfach, schnell und effektiv zu üben. Andererseits hat dir meine detaillierte Beschreibung einer Übung hoffentlich gezeigt wie das ganze in der Praxis umgesetzt werden kann und vor allem, dass Üben weder langweilig noch langwierig sein muss.

Für mich steht im Mittelpunkt, dass du so oft wie möglich fokussiert übst. Dann wirst du nämlich sehen, dass du richtig schnell voran kommst. Das Erfahrung sammeln durch die Übungen hat noch einen wichtigen Vorteil. Du wirst wesentlich sicherer. Das wiederum hat zur Folge, dass dir Softwareentwicklung noch mehr Spaß macht.

Viel Spaß beim fokussierten Üben

Jan

PS: Wenn dir dieser Artikel und insbesondere der praktische Teil gefallen hat, dann hinterlasse doch einen Kommentar oder schreib mir eine Mail. Dann werde ich zukünftig mehr Übungen in diese Richtung anbieten.