Eine Webseite erstellen: Das musst du lernen

Wer sich heutzutage im Internet präsentieren will, braucht nicht nur die sozialen Medien. Mit einer eigenen Webseite hat man eine ganz individuelle Präsentation unabhängig der großen Netzwerke wie Facebook, Youtube und Xing.

Egal ob du eine App programmieren möchtest oder einen Kleidungsladen bei dir im Viertel aufmachen willst:

Mit einer Webseite kannst du fremden Besuchern zeigen, was du tust. Wenn du es richtig machst, kannst du sogar mit einer eigenen Webseite Geld verdienen.

Was du alles machen und lernen musst, um deine erste Webseite erstellen und online zubringen erfährst du in diesem Artikel, damit du danach direkt loslegen kannst. Folgende Schritte führt man bei Erstellung der Webseite durch.

  • Von der Idee zum Papier: Vorbereitung
  • Vom Papier zur Webseite: Website programmieren
  • Ab ins Internet: Hochladen und Testen
  • Fortgeschrittene Themen: Weiterentwicklung

Von der Idee zum Papier

Bevor du dich an die Tastatur setzt und alle möglichen Versuche unternimmst, möglichst schnell eine Webseite aufzubauen (wer möchte dieses Thema nicht möglichst schnell hinter sich bringen?), solltest du dir Gedanken zum Inhalt, Struktur und dem Aussehen deiner Webseite machen. Wenn du also deine Idee von einer Webseite hast, starte Weiterlesen

programmieren lernen warum alle mit hallo welt anfangen

Richtig programmieren lernen: Warum alle Tutorials und Kurse mit Hallo Welt anfangen und worauf du achten solltest

programmieren lernen warum alle mit hallo welt anfangenEs gibt eine so große Informationsmenge im Internet zum Programmieren lernen, dass man als Anfänger oft nicht weiß, welches von den ganzen Tutorials, Kursen und Büchern man eigentlich nehmen soll. Wenn Programmieren lernen doch so einfach ist, wieso gibt es dann so viele unterschiedliche Anbieter? Ich selbst habe in meiner Lernphase und auch heute noch (man lernt nie aus) immer wieder diverses Material zum Programmieren lernen und bestimmten Softwaretechnologien durchgearbeitet. Die inhaltlichen und qualitativen Unterschiede sind sehr breit gestreut und für mich teilweise sogar erschreckend gewesen. Meine schlimmste Erfahrung war immer die, wenn ich mit in einem Kurs oder ein Tutorial war und dann merken musste, dass ich nach dem Durcharbeiten nicht mit meinem Projekt starten konnte, weil mir noch dieses oder jenes Wissen fehlte. Zeitverschwendung und die notwendige Menge an Inhalten haben meine Lernerfahrung ziemlich erschwert. Du sollst nicht in der gleichen Falle landen, wie ich damals: Denn unter den vielen Angeboten gibt es sie, die Kurse, die perfekt auf dich und deine Bedürfnisse zugeschnitten sind.

Ich möchte dir kurz erklären, welche Unterschiede diese Angebote haben und worauf du achten solltest, wenn du überlegst ein kostenloses oder gar kostenpflichtiges Angebot in Anspruch zu nehmen. Damit sollst du möglichst das beste Lernerlebnis haben und deine Idee bald umsetzen können.

Zielgruppe – Anfänger, Umsteiger oder Techniker?

Eigentlich kein Wunder: Die Auswahl des Materials hängt erstmal von dir ab. Du solltest zunächst einmal wissen welches Vorwissen du bereits mitbringst. Hast du bereits schon mal eigenständig programmiert? Oder hast du bisher keine Berührungspunkte damit? Von deinem Vorwissen hängt bereits ab welches Lernmaterial sich für dich eignet. Denn je nach Erfahrungslevel kannst du schon eher technische Kurse belegen, welche die Grundlagen nur noch kurz durchgehen. Aber als Anfänger oder Einsteiger, kannst du dabei schon ziemlich angehangen werden.
Ist ein Kurs wirklich für Anfänger geeignet oder steht das nur auf der Verpackung? Bevor du ein Tutorial oder einen Kurs anfängst solltest du dich versichern, dass der Kurs auf deine Bedürfnisse zugeschnitten ist. Wie kann man das Überprüfen? Es sollte eine Art Schnupperkurs oder kostenloses Tutorial geben, welches einen Einblick aus dem Kurs mitbringt.  Dort solltest du bereits deinen ersten Lernerfolg feiern können, zum Beispiel in dem du bereits etwas kleines Programmieren konntest.  Bleibt dieser Lernerfolg im kostenlosen Bereich aus, solltest du kritisch hinterfragen, warum das so ist. Eventuell ist das geforderte Vorwissen zu hoch angesetzt, auch wenn „Für Anfänger“ und „Programmieren lernen“ dran steht. Gibt es kein kostenloses Lernmaterial vorab? Bevor du da die Katze im Sack kaufst, gebe ich dir folgenden Tipp: Schau doch mal in die Kursübersicht des Materials. Wenigstens das sollte man vorher einsehen können, ohne dass man sich registrieren muss. Dort wirst du eventuell Begriffe sehen, mit denen du nichts anfangen kannst. Werden diese Begriffe kurz erläutert? Oder ist es eine reine Auflistung? Du solltest zumindest etwas mit den Begriffen und Erläuterungen etwas anfangen können. Falls du gar nichts mit der Übersicht anfangen kannst solltest du überlegen, ob du bereits genug Vorwissen hast. Die Konsequenz ist im schlimmsten Fall, dass du die gezeigten Beispiele einfach nur abtippst, anstatt diese zu verstehen. Auf diese Art kann es sehr lange dauern Programmieren zu lernen, denn du lernst nicht, wie du die Grundlagen auf eigenen Problemlösungen anwenden kannst.

 

Warum alle Tutorials mit Hallo-Welt anfangen und was du erwarten solltest.

Mein Lieblingsbeispiel, das „Hallo Welt“-Programm möchte ich dir kurz beschreiben, denn in fast jedem Kurs und Tutorial findet man dieses Start-Programm. Wenn du ein Hallo-Welt-Programm schreibst und ausführst, dann macht dieses nicht mehr als „Hallo Welt“ auf dem Monitor auszugeben. Dieses Programm zeigt dir eigentlich NUR, dass alle deine Programme zum Programmieren und Entwickeln ordnungsgemäß funktionieren. Wenn dein Hallo Welt-Programm funktioniert, dann fängt das Programmieren lernen erst an. Ich vergleiche das mal kurz mit dem Autofahren lernen in der Fahrschule. Wenn du das erste Mal in einem Auto sitzt und den Motor startest, ist das quasi dein „Hallo Welt“-Programm. Du startest den Motor und das Auto ist bereit zum losfahren. Nur weil du den Motor starten kannst, heißt das noch lange nicht, dass du nun im Straßenverkehr und mit der restlichen Technik des Autos  klarkommen wirst. Ein Kurs sollte dir eigentlich im Vorfeld (also im Idealfall schon kostenlos), eine Anleitung geben, wie du die Voraussetzungen schaffst um deinen Computer startklar zum Programmieren zu machen.
Dazu kommt noch eine weitere Komponente, denn spätestens dort musst du dich für eine Programmiersprache entscheiden und ich sage es direkt: Es gibt keine beste und einfachste Programmiersprache. Die heutigen modernen eingesetzten Programmiersprachen basieren auf denselben Prinzipien und Grundlagen. Es gibt definitiv Unterschiede, aber je nach Vorwissen, sind diese noch nicht wichtig für dich. Wenn du von 0 an startest, willst du erstmal die Grundlagen verstehen bevor du dich mit den Details auseinandersetzt. Wenn es also um die Auswahl der Programmiersprache und damit letztendlich auch um den Kurs geht, kannst du darauf achten, wie einfach es ist, dein Hallo Welt Programm startklar zu machen.
Jede Programmiersprache hat ihren eigenen Einsatzzweck, das heißt du wählst die Programmiersprache danach was du nach dem Lernen programmieren willst. Ideal ist, wenn die erste Programmiersprache möglichst für viele Einsatzzwecke verwendet werden kann, denn dann kannst du viele Erfahrungen mit deiner ersten gelernten Sprache machen und bekommst schon viele Ergebnisse damit. Irgendwann stößt du definitiv an die Grenzen der ersten Programmiersprache und musst irgendwann auf eine andere Programmiersprache wechseln. Wenn man mit der ersten Programmiersprache allerdings bereits sehr viel programmieren kann, kannst du deinen Umstieg verzögern.  Und damit wären wir beim nächsten Thema: Die Dauer zum Programmieren lernen, ich gebe dir mal einen Satz zum kritischen Hinterfragen: Von 0 zum Profi in 30 Tagen. Egal ob es hier um Programmieren oder etwas anderes geht, ist es realistisch für dich? Sicherlich kann man in 30 Tagen viele Erfahrungen machen und sehr viel lernen. Aber wenn jeder in 30 Tagen zum Profi werden kann, würden Unternehmen heute Probleme haben um professionelle Programmierer zu finden? In 30 Tagen wird man nicht zum Profi-Software Entwickler, selbst in 300 Tagen würde ich das bezweifeln. Aber das schöne ist, je nachdem was du mit dem Programmieren anfangen willst, musst du gar kein Profi werden. Die Grundlagen zu erlernen und anwenden zu können ist sicherlich in ein paar Wochen möglich, die tatsächliche Dauer hängt aber unter anderen von deiner eigenen Lerngeschwindigkeit ab. Also Vorsicht bei Zeitangaben in Programmierkursen, diese sind lediglich eine Zeitschätzung und können gewaltig daneben liegen.
Zu all diesen Punkten kommt noch die eigene Erwartungshaltung dazu. Du lernst programmieren, weil du eine bestimmte Idee im Kopf hast, die du gerne umsetzen möchtest. Oder du möchtest die Technik hinter Software verstehen. Egal welche Motivation du hast, du willst am Ende eines Kurses ein konkretes Ergebnis sehen. Wenn du Programmieren lernen willst, kannst du nicht erwarten, nach einem Kurs oder Tutorial ALLES über das Programmieren zu wissen. Dafür gibt es ganze Studiengänge. Aus dem Grund solltest du ganz gründlich prüfen, welches konkrete Ergebnis du nach einem Kurs/Tutorial erwarten kannst. Insbesondere bevor du Geld ausgibst oder viele Arbeitsstunden investierst.

Programmieren lernen – Was ist das konkrete Lernziel?

Im Abschnitt vorher habe ich es bereits angesprochen. Programmieren ist zu komplex, das man es mit einem Kurs vollumfänglich verstehen kann. Man muss sich auf ein Thema konzentrieren und dabei hilft es sich den Weg so einfach wie nur möglich zu machen. Das erste was hilft ist die eigene Idee zu nehmen. Du verfolgst ein bestimmtes Ziel welches du mit dem Programmieren erreichen willst. Nur wenige Leute lernen Programmieren, weil sie sich für das Programmieren selbst interessieren. Das Programmieren ist nur Mittel zum Zweck, auch wenn es ziemlich interessant und spannend sein kann. Das Lernziel sollte sein, der Umsetzung deiner Idee näher zu kommen und das so spezifisch wie es nur geht. Wenn du ein Videospiel schreiben willst, solltest du im Kurs nach Erlernen der Grundlagen ein Videospiel schreiben können. Dir sollte nicht nur das Programmieren an sich beigebracht werden, sondern wie du es einsetzt um deine Idee umsetzen zu können. Was bringt es dir, wenn du weißt wie man einen Hammer benutzt, aber ihn nicht einsetzen kannst, weil du nicht weißt wie man ein Haus baut? Wie kannst du prüfen, ob nun der Kurs, der dir gefällt, dich näher an dein Ziel bringt? Wenn es nicht bereits in der Kursbeschreibung steht, dann kontaktiere einfach denjenigen, der den Kurs zu Verfügung stellt. Frage einfach nach ob man nach dem Kurs  x oder y umsetzen kann. Du hast dann eine belastbare Aussage. Leider gibt es leere Versprechungen bei Kursen, denn „Programmieren lernen“ ist so breit, dass man das quasi auf jedes Buch, Video und Tutorial einfach draufschreiben kann. Programmieren lernen als Versprechung, reicht nicht aus, du solltest vorher wissen was du konkret lernen wirst. Einfache Faustregel: Ist das Versprechen realistisch? Wenn dir ein Tutorial verspricht: „Programmieren lernen und das nächste Facebook bauen“ solltest du hinterfragen ob das tatsächlich realistisch ist.

Die Kunst, Programmieren zu lehren

Das Schreiben von Computerprogrammen unterscheidet sich ganz enorm vom davon, wie man jemanden beibringt Computerprogramme zu Schreiben. Das ein Programmierer noch lange kein guter Programmierlehrer sein muss, darauf gehe ich später nochmal ein. Worum es hier geht, ist die Art und Weise wie der Kursinhalt gestaltet ist. Da du ja bereits eine kostenlose Vorschau des Tutorials zur Verfügung hast, kannst du schnell erkennen wie die Erklärungen der teilweise komplexen Zusammenhänge gestaltet sind. Siehst du von Anfang nur den Bildschirm des Lehrers, könnte es eventuell etwas schwierig werden, die theoretischen Zusammenhänge zu verstehen. Nur durch Zeigen wie man eine Software installiert und dort etwas vorgegebenen eintippt ist wie, ein IKEA-Regal mit Anleitung zusammenzubauen. Das eine Regal wirst du definitiv zusammengebaut bekommen, du hast auch noch die Möglichkeit minimale Anpassungen zu machen. Aber wenn du im Anschluss nur lediglich Holz, Schrauben, eine Säge und einen Schraubendreher zur Verfügung hast,  bist du direkt aufgeschmissen und weißt nicht wo du anfangen sollst. Zum Programmieren gehört nicht alleine das Eintippen von Code in den Computer. Der Großteil der Arbeit findet  in deinem Kopf und auf dem Papier statt. Das solltest du in einem Kurs lernen können, die abstrakten Abläufe und Gedankengänge um mittels Programmiersprache zum Ziel zu kommen. Dazu gehört, dass Erklärungen nicht ausschließlich innerhalb von Programmquelltexten durchgeführt werden, denn dann wird vorausgesetzt, dass du diese Gedankengänge bereits verinnerlicht hast. Du wirst ausserdem schnell merken,  ob die Erklärungen technisch sind, also viele Fachwörter beinhalten, die du noch nicht kennst. Besonders am Anfang ist es schwierig mit Fachwörtern zu arbeiten, da man sich auf viel zu viele Dinge konzentrieren muss. Ein guter Lehrer kommt ohne Fachwörter aus und erklärt dir komplexe Zusammenhänge an bildlichen, für den Anfänger gut nachvollziehbaren, Beispielen. Erst dann wird in die Technik gewechselt. Merke: Erklärungen mit einfachen Beispielen. Nur anhand des Beispiels wirst du natürlich noch nicht Programmieren können. Jetzt ist es wichtig das Wissen in die technische Ebene umzuwandeln. Nun wird dasselbe nochmal anhand der Technik erklärt und es wird ein Praxisbeispiel gezeigt. Du solltest beim Programmieren einen AHA-Moment erleben. Merke: Programmieren nach der Erklärung mit Praxisbeispielen.
Wenn du in einem Buch oder Kurs lediglich, den Code nur abtippen musst, dann hättest du dir den Code auch einfach herunterladen können. Der Effekt wäre derselbe, man kann so auch Programmieren lernen aber es dauert wesentlich länger. Es gibt Programmierer, die das sogar bevorzugen, aber zu dem Punkt kommen wir beim nächsten Abschnitt.

Wie lernst du gerne? Das richtige Lehrmaterial auswählen

Während jemand gerne mit Büchern lernt, lernt der andere lieber mit Videos. Es gibt also unterschiedliche Lerntypen. Umso wichtiger ist es, das für dich passende Lehrmaterial auszuwählen. Beim Programmieren lernen ist es allerdings nicht mit einem Buch oder einem Video getan. Beim Programmieren lernen gibt es verschiedene Bereiche, die manchmal einen Wechsel des Lehrmaterials erfordern. Vielleicht schaust du dir zwar gerne Erklär-Videos an, aber möchtest dennoch beim Bearbeiten einer Aufgabe nochmal in den Text schauen. Also was sollte ein guter Kurs an Material zur Verfügung stellen damit du optimal lernen kannst? Es sollte anfangen mit einem Lernprogramm, welches dich interaktiv an bestimmte Themen im Programmieren heranführt. Es sollte genügend Beispiele enthalten und dich zum Mitarbeiten anregen. Dazu sollte das Lernprogramm und die Themen per Video und Skript erläutert werden. So hast du zumindest schonmal eine gute Mischung. Die Videos und Skripte sollten mittels Text, Illustrationen und Animationen die Themen vermitteln. Damit du das gelernte direkt anwenden und auch überprüfen kannst sind Aufgaben und dazugehörige Lösungen unbedingt notwendig. Mit Aufgaben sind allerdings keine Abtipp-Arbeiten gemeint sondern, Mitmach- und Mitdenk Übungen, in denen man tatsächliche Probleme lösen muss. Irgendwann möchtest du allerdings das Gelernte in die Praxis umsetzen und benötigst dafür Beispielprogramme und Vorlagen zum Loslegen.  Damit du nicht nach dem Kurs irgendwo stecken bleibst, sind weiterführende Informationen und Links zwingend notwendig.  So eine Mischung führt bei jedem Lernenden zum optimalen Erfolg, denn du benutzt nur das was du selbst zum Lernen benötigst aber hast die Möglichkeit zu wechseln, wenn es notwendig ist. Liefert dir ein Kurs so eine qualitative Mischung an Inhalten, greif zu.

Wer ist dein Lehrer und Meister?

Bevor man sich von jemandem Programmieren beibringen lässt, sollte man einmal prüfen, wer den eigentlich dort das Material erstellt hat. Jeder kann behaupten, dass er dir Programmieren beibringen kann, aber kann er es wirklich? Ein Beispiel: Wenn du Auto fahren kannst, bist du in der Lage jemanden anderen optimal Auto fahren beizubringen? Vielleicht wird der eine oder andere Versuch klappen. Diejenigen, die sich darauf spezialisiert haben und Wert darauf legen, dass du die Programmiergrundlagen wirklich verstehst, werden dir eher ein Thema verständlich beibringen können. Wie kannst du das Überprüfen? Eine einfache Internetrecherche klärt schnell afu: Wie lange und wieviel Erfahrung hat der Anbieter in der Programmierwelt? Gibt es Referenzen oder kann man öffentliche Profile über den Anbieter finden? Was macht  der Anbieter hauptberuflich, konzentriert er sich nur auf ein Thema oder gibt es auch noch andere Bereiche ausser dem Programmieren? Je nachdem kann das ein Vorteil oder Nachteil sein. Ein weiterer Punkt zur Überprüfung ist, wieviel Material stellt der Anbieter neben seinem Tutorial, Kurs oder Buch zur Verfügung? Bringt dich bereits dieses Material weiter und hilft dir auf deinem Weg? Über einen Blog, Facebook-Page oder einen Youtube-Kanal kannst du übrigens auch schnell rausfinden, ob der Anbieter bereit ist Support zu geben. Denn das ist ein wirklich wichtiger Punkt: Steckst du einmal beim Lernen fest und kommst nicht mehr weiter, solltest du den Anbieter irgendwie kontaktieren können und um Support bitten. Das ist fast noch viel mehr wert als das Material selbst. Der Support kann von E-Mail über Skype und WhatsApp laufen, du solltest den Weg dafür bestimmen können.
Wenn du gar nichts über den Anbieter finden kannst außer das Lehrmaterial selbst und es auch sonst keine auffindbaren Aktivitäten ausser Werbung zu finden sind ist Vorsicht geboten. Hier könnte eventuell nicht dein Lernerfolg im Fokus stehen.

Was kostet ein guter Kurs? Oder kann man es kostenlos lernen?

Hierüber streiten sich alle Programmierer bis heute und wahrscheinlich bis in alle Ewigkeit. Meine Erfahrung ist, wenn man genug Vorwissen hat, kann man sich vieles mit kostenlosen Inhalten erarbeiten. Merkt man dann aber, dass doch nicht genug Grundwissen vorhanden ist, fängt man wieder  von vorne an und hat im schlimmsten Fall ein paar Stunden verschwendet. Ausserdem habe ich kein kostenloses Material gefunden, welches dir die absoluten Grundlagen erklärt, es war immer notwendig noch ein weiteres Buch oder ähnlich dazuzukaufen. Nichts ist wirklich kostenlos, denn hinter kostenlosen Inhalten, verbirgt sich immer eine bestimmte Absicht des Anbieters. Das können verschiedene sein: Werbung, Marketing, o.ä. Du musst die finden, die bereit sind dir kostenlos zu helfen. Selbst bei angeblichen kostenlosen Tutorials, wird Werbung gezeigt. Das ist erstmal nicht schlimm, solange es nicht mehr Werbung als Inhalt gibt.  Du kannst das über die Anbieter-Webseite überprüfen: Wird dort übermäßig viel Werbung gezeigt oder sind die Inhalte nicht aussagekräftig? Bei kostenlosen Inhalten, weiß man nie wie weit man eigentlich kommt und wie hoch die Qualität des Inhaltes ist.
Dann gibt es z.B. Kurse und Bücher, die dich einmalig etwas kosten aber dafür quasi ein Komplettpaket sind. Wie  oben beim Abschnitt Material erwähnt, sollte die Mischung der Inhalte gut sein und da kann so ein Kurs schnell mal etwas teuerer werden. Hier hast du die Entscheidung zwischen zielgerichtetem qualitativ hohem und schnellem Lernen gegenüber fehlerbehafteten langsamen aber kostenlosen Lernen.
Für den schmaleren Geldbeutel gibt es Angebote bei denen man monatlich einen festen Betrag bezahlt und solange Zugriff auf die Inhalte hat wie man die monatliche Gebührt zahlt. Meistens ist dies etwas teuerer als ein Einmalpreis und du hast den Nachteil, dass du mehr zahlst je länger du brauchst. Dafür haben diese Anbieter ein sehr breites Themenspektrum aus dem du wählen kannst.
Prinzipiell kann man sagen, dass man bei kostenlosen Angeboten potentiell länger braucht um ans Ziel zu kommen. Man braucht aber auch kein Vermögen in Live-Seminare investieren, wenn man nur die Grundlagen erlernen will. Wenn man Qualität und eine Erfolgsgarantie haben will, sollte man lieber etwas mehr Geld in die Hand nehmen. Ein paar Euro mehr und du bist schneller am Ziel. Das ist dir zu viel Risiko, weil du nicht weißt ob du es schaffen kannst? Worauf du bei kostenpflichtigen Kursen achten solltest, ist eine Geld-zurück-Regelung. Kannst du dein Geld zurückzuverlangen, wenn dir der Kurs nicht gefällt oder du es mit dem Programmieren einfach nicht hinbekommst? Wieviel Wochen hast du Zeit um das Geld zurückzufordern? Wenn du dir unsicher bist, ob du das Programmieren lernen kannst, sollte dieser Zeitraum mindestens 6 Monate betragen. Nur so kannst du dir sicher sein, etwas zu kaufen was dir auch tatsächlich nutzt.  Sollte etwas nicht passen und sogar der Support versagen, bleibst du wenigstens nicht auf deinem Geld sitzen.

 

Fazit – Checkliste für die Auswahl deines Lehrmaterials

Den richtigen Kurs zu finden ist nicht einfach, es gibt zu viele Angebote für die verschiedensten Bedürfnisse. Hier nochmal einmal kurz zusammengefasst die wichtigsten Punkte als Checkliste:

  • Entspricht der Inhalt deinem Vorwissen? Prüfe mittels Kursübersicht und kostenlosen Material
  • Wie einfach ist es mit dem Inhalt zu starten? Gibt es einen kostenlosen Startpunkt bei dem man direkt loslegen kann?
  • Passt die Programmiersprache zu deinem Vorhaben? Mein Tipp: Am Anfang lieber eine universellere Programmiersprache lernen (z.B. Javascript)
  • Ist die Dauer für das Lernvorhaben realistisch? Wird mit einer kurzen Zeit gelockt?
  • Welches konkrete Programm wirst du umsetzen und kann du danach mit eigenen Sachen weitermachen?
  • Wie wird das Wissen vermittelt? Werden Fachwörter anschaulich und vereinfacht erklärt?
  • Kann man das Gelernte auch in der Praxis einsetzen? Wenn wie ist der Lernweg von Theorie bis zur Praxis?
  • Wie ist das Kursmaterial aufgebaut? Gibt es verschiedene Möglichkeiten die Themen zu erlernen?
  • Gibt es Beispielprogramme und Programmvorlagen, mit denen man nachher weitermachen kann?
  • Wieviel Erfahrung hat dein Lehrer und welche Referenzen beweisen, dass er das Programmieren lehren kann? Gibt es Support falls du nicht mehr weiterkommst?

Die Frage mit dem Geld bleibt dir überlassen, aber wenn du darüber zweifelst und du dir vielleicht nicht alle Punkte selbst beantworten kannst, dann schicke diese Fragen doch an den Kursanbieter, dieser sollte dir diese Fragen beantworten können.  Damit bist du auf jeden Fall auf der sicheren Seite und deinem Vorhaben steht nichts mehr im Weg. Hast du bereits Erfahrungen mit „Programmieren lernen“-Angeboten? Was hat dich gestört und wie wünscht du dir Programmieren zu lernen?

Grundwerkzeuge der Programmiersprachen

Vielleicht hast du schon mal von diesen Grundelementen gehört, die in jeder Programmiersprache fest verankert sind. Ohne diese Elemente wird es schwierig für dich zu programmieren, denn die nächste Ebene darunter ist bereits Maschinensprache. Selbst wenn du mit Maschinensprache programmierst musst du mit diesen Grundwerkzeugen arbeiten damit du die grundsätzliche Logik deines Programms festlegen kannst. Logik ist auch hier das richtige Stichwort, diese Grundlemente sind, wenn man diese verstanden hat, einfach zu merken und anzuwenden. In diesem Artikel möchte ich dir kurz erklären was diese Grundelemente machen und wie diese funktionieren. Dazu gibt es ein Beispiel mit der Programmiersprache Scratch damit du es besser verstehst. Wenn man es mit einer „einfachen“ grafischen Sprache erstmal verstanden hat, ist der Wechsel zu einer textbasierten Sprache wie Javascript relativ einfach. Hier ein kleiner Ausschnitt wie die Programmierumgebung von Scratch aussieht:

Programmieroberfläche von Scratch

Befehle

Ein Befehl ist eine Anweisung an den Computer, der Computer bzw. die Bibliothek, die du verwendest weiß wie man diesen Befehl abarbeitet. Schreib man mehrere Befehle untereinander weg, erhält man die sogenannte Befehlsfolge. Das bedeutet eigentlich nur, dass Befehle von oben nach unten nacheinander abgearbeitet werden. Wenn man viele Befehle immer wieder benutzen muss kann man sich neue Befehle schreiben, die aus den Befehlen bestehen.  An der Stelle sollte ich dir ein kleines Bild zeigen, dass es etwas besser erklärt. Du hast einen kleinen Roboter, den du per Programm steuerst. Das ganz sieht folgendermaßen aus:

Einzelbefehle und Befehlsfolge

Dort siehst du die 4 Befehle, die diesen kleinen Roboter steuern.

  • Warte 1 Sekunde: Das Programm wird eine Sekunde warten. Der Roboter bewegt sich nicht.
  • Drehe dich (im Uhrzeigersinn) um 90 Grad: Der Roboter dreht sich um 90 Grad (immer rechts)
  • Drehe dich (gegen den Uhrzeigersinn) um 90 Grad: Der Roboter dreht sich um 90 Grad (immer links)
  • Gehe 50er Schritt: Der Roboter „bewegt“ sich in Blickrichtung um 50 Grad

Dein Computer weiß durch das Programm, wie diese Befehle abzuarbeiten sind. Mit der Programmiersprache (hier Scratch) kannst du diese Befehle kombinieren und nacheinander abarbeiten lassen. Schaue dir folgendes Bild an. Du siehst einmal die Einzelbefehle und dazu dann die Befehle, wie sie nacheinander abgearbeitet werden sollen. Stell dir mal vor wie sich der Roboter bewegen würde, indem du die Befehle Schritt für Schritt durchgehst. Siehe folgendes Bild:

Das schöne ist, dass du mehrere Befehle zusammenfassen kannst zu neuen Befehlen und dann nur noch diese neuen Befehle ausführen musst. Lass uns mal einen neuen Befehl – geheRechts bauen, in Scratch sieht das so aus:

Neuer Befehl geheRechts

Wir würden einen neuen Befehl schreiben und diesen zum Beispiel 4 Mal aufrufen. Damit würde sich der Roboter 4 Mal im Kreis drehen. Falls du das nachher mal ausprobieren willst, den Link für das Scratchprojekt erhälst du nachher nochmal. Das ist auch schon alles was man zu Befehlen erstmal wissen muss. Bei Programmiersprachen wie Javascript kommen noch ein paar Details dazu, die man beachten muss, aber das ist dann nur noch Fleißarbeit. Wichtig ist zu verstehen wie Befehle abgearbeitet werden.

Operatoren

Ein Operator  ist Teil einer Operation, wenn ich von Operationen spreche, spreche ich von Rechenoperationen oder logischen Operationen. Das bedeutet im Klartext, dass Programme in der Lage sind Rechenaufgaben zu lösen, Größer als/Kleiner als Vergleiche durchzuführen und Verknüpfungen wie UND/ODER Operationen auszuwerten. Wofür braucht man das? Lass uns mal ein Beispiel durchgehen. Du hast ja gesehen, dass es den Befehl gibt um 50 Pixel zu gehen, welche für den Roboter dann ein Schritt wären. Möchte man hier nun mehrere Schritte gehen, müsste man den Befehl öfter aufrufen. Oder man rechnet 5*50 Und gibt diesen Wert in den Befehl ein. Und so bewegt sich der Roboter gleich um mehrere Schritte, in dem man den Wert einfach multipliziert.

Operationen und Operatoren

Es gibt viele andere Operatoren, im Bild werden dir ein paar der wichtigsten gezeigt. Diese Operationen funktionieren alle nach dem gleichen Schema.

Variablen

Stell dir vor dein Roboter müsste nach ein paar gefahrenen Schritten, alleine wieder an den Ursprungspunkt zurückkehren. Da ist ein bisschen schwierig, wenn er sich nicht merken kann, welche Schritte er bereits gefahren ist. Oder der Roboter müsste 3 Bälle aufsammeln und diese dann in ein Lager bringen. Irgendwie muss er sich bestimmte Informationen merken können. Dafür gibt es Variablen. Sobald man eine Variable definiert (also „erfindet“), kann man da Werte drin speichern und auslesen. Das ist wie, wenn man sich ein Notizblock nimmt und sich dort Informationen notiert und diese später liest. Schau dir das Bild an, dann sollte es klarer werden.

Variablen

Eingabe und Ausgabe

Hiermit ist alles gemeint wie du (also der Mensch/Computerbenutzer) mit dem Computerprogramm interagiert. Eingaben sind alles was an Daten in den Computer hineingehen, z.B. Tastatureingaben, Mausbewegung, Joystickknopf drücken. Mit der Ausgabe sieht es genau andersrum aus, hier geht es darum welche Informationen du vom Computer erhältst. Hiermit sind gemeint Bildschirmausgaben, Daten in Form von Dateien oder sogar Druckausgaben.
Jede Programmiersprache behandelt die Eingaben und Ausgaben etwas anders, aber im Prinzip gibt es in jeder Programmiersprache diese Eingaben und Ausgaben zu behandeln. Letztendlich bestimmt der Programmierer, was mit den Eingaben passieren soll und wie die Ausgabe auszusehen hat.

Tastatureingabe

Entscheidungen

Bei der Tastatureingabe gibt es bereits eine programmbasierte Entscheidung nach dem WENN …. DANN-Muster. Also Wenn etwas passiert ist, dann tue etwas. Im Fall der Tastatureingabe war das WENN Taste Leertaste gedrückt DANN gehe 50er-Schritt.

Entscheidung
Diese Entscheidungen können allerdings noch erweitert werden. Zum Beispiel kann man Zahlenvergleiche eingeben oder andere Dinge überprüfen. Man gibt also eine Bedingung ein und wenn diese erfüllt, also WAHR ist, dann sollen bestimmte Befehle ausgeführt werden. Hier können fast alle Operatoren verwendet werden, die einen WAHR oder FALSCH – Wert zurückliefern, z.B. bei Vergleichen.

Schleifen

Stell dir vor, du hast einen Befehl geschrieben in dem dein Roboter nach Bällen suchen soll. Du möchtest, dass dein Roboter SOLANGE nach Bällen sucht bis er mehr als 3 gefunden hat. Er muss also den Befehl sucheBälle wiederholen. Mit einer Schleife kann man dies erreichen und diese ist auch nicht so schwierig zu verstehen, denn sie ist ähnlich zu Entscheidung.

Schleifen bzw. Wiederholungen

Es funktioniert in etwa so: WIEDERHOLE sucheBälle SOLANGE BIS gesammelteBälle > 3. Von diesen Schleifen gibt es verschiedene Arten, diese unterscheiden sich eigentlich nur in der Art wann die Bedingung ausgewertet wird. Wichtig ist hier jedoch, dass man versteht, dass die Befehle innerhalb der Schleife wiederholt werden solange eine Bedingung erfüllt ist.

Fazit

Das war eine kurze Beschreibung der wichtigsten Grundelemente einer modernen Programmiersprache. Es gibt noch ein paar Elemente mehr, die dir Arbeit abnehmen oder dich mit der Arbeit unterstützen, aber die Grundwerkzeuge hast du nun schon mal kennengelernt. Nur durch das Kennen dieser Elemente wirst du noch lange nicht programmieren können, dafür musst du definitiv erstmal damit arbeiten. Sie finden sich in jeder Programmiersprache wieder und wenn du die Funktionsweise erstmal verstanden hast, kannst du richtig schnell auf andere Programmiersprachen wechseln. Die Grundelemente sind für sich erstmal einfach zu verstehen. Der Knackpunkt bei diesen Grundelementen ist, wie man diese kombinieren muss. Je nachdem welche Aufgaben oder welches Feature man lösen/programmieren will muss man diese Elemente miteinander verwenden. Die nächste Schwierigkeit ist dann wie man mit dessen Hilfe nun tatsächlich seine Programmidee umsetzt. Dies würde allerdings den Rahmen dieses Artikels sprengen.  Wie versprochen findest du hier noch den Link zum Scratch Projekt, am besten probierst du dort ein bisschen rum. Die Sprache Scratch ist zwar hauptsächlich für Kinder gemacht worden, aber auch als Erwachsener hilft diese Programmiersprache ein paar Grundlagen zu erlernen.

Objektorientierung: Was ist das?

Was ist Objektorientierung?

In diesem kurzen Artikel sollst du lernen was Objektorientierung ist und was du darüber wissen musst. Jeder Softwareentwickler, der mit dem Programmieren Geld verdient muss wenigstens wissen wie man objektorientiert denkt. Es gibt auch andere Methoden, aber dies ist momentan eine der beliebtesten Methoden wie man Software erstellen kann.

Das Wort Objektorientierung

Wenn man sich das Wort Objektorientierung alleine ansieht, merkt man schnell, dass hier zwei Wörter in einem stecken. Das Wort Objekt und das Wort Orientierung. Übersetzt heißt das, man konzentriert sich auf Objekte, also alle Überlegungen die der Programmierung dienen orientiert sich an Objekten. Was ist ein Objekt?

Schau dich mal in deinen Zimmer um. Alles was um dich herum steht ist ein Objekt. Die Tastatur, dein Schreibtisch, die Zimmertür, deine Deckenlampe, dein Bleistift. Das alles sind Objekte. Objekte die man anfassen und sehen kann. Damit wir Entwickler unsere Software leicht verständlich aufbauen können versuchen wir diese Objekte auch in unserer Software nachzubilden. Was heißt das denn?

Dafür möchte ich ein kleines Beispiel mit dir durchgehen. Denk mal an das Haus in dem du gerade sitzt. Nimm ein Blatt Papier und versuch mal eine Skizze von diesem Haus aufzuzeichnen. Du brauchst die Zeichnung niemanden zeigen, aber zeichne das Haus auch, wenn es du nicht gut im Zeichnen bist. Wichtig ist, dass man alle Fenster und Türen einer Hausseite sieht. Ob es aus Stein oder aus Holz ist interessiert in der Zeichnung nicht. Sobald du das Haus gezeichnet hast, lies weiter…

Und wie sieht dein Haus aus? So wie dieses? Du hast gerade objektorientiert gearbeitet! Du hast dich auf Objekte aus deiner realen Welt konzentriert und hast ein Modell davon erstellt. Deine Skizze zeigt nicht alle Details eines echten Hauses aber jeder Mensch würde sofort erkennen, dass es sich um ein Haus handelt.

Von der realen Welt in ein Modell

Das Hausbeispiel zeigt dir, wie du bei der Objektorientierung denken musst. Um das ganze noch ein bisschen zu vertiefen, zeige ich dir noch ein Beispiel. Nehmen wir ein Auto. Nein du musst jetzt kein Auto zeichnen. Aber denk mal an blaues Auto und versuch mal an alle Details zu denken, die in so einem Auto stecken. Das Aussehen ist noch relativ einfach, Man hat 4 Räder, eine Karosserie ein paar Fenster, Türen, Ausselspiegel sowie Vorder- und Rückleuchten. Aber das ist ja eigentlich noch nicht alles. Wenn man genau hinguckt sieht alleine bei einem einzelnen Rad: Reifen, Felge, Radschrauben, Antrieb, Bremsscheibe und einen Bremssattel. Und schaut man noch genauer hin, also zum Beispiel eine Radschraube, hat man auch hier wieder viele Details wie: Schraubenlänge, Schraubendicke, Gewinde, Mutter und das Material. Und wir reden hier von einer nur von einer Art Schraube am ganzen Auto! Dabei haben wir noch nichtmal über Hersteller und Modell des Wagens gesprochen! Puh… ok, worauf will ich hinaus?

Man kann sich bei der Objektorientierung in Details verlieren. Und würden wir Software so detailliert schreiben, wie wir grade das  Auto analysiert haben, dann würden unsere Programme nie fertig werden. Aus diesem Grund konzentrieren wir uns nur auf die Details die uns in der Software interessieren. Um auf das Beispiel zurückzukommen, wir erstellen ein kleines Modell von unserem Auto. Und dabei konzentrieren wir uns nur auf die Details die für uns wichtig sind. Beispiel Nummer 3: Wir nehmen wieder das große Auto aber erstellen nun ein Modell davon. Also stell dir doch mal das große Auto als kleines Spielzeugauto vor. Schau mal wieviele Details plötzlich verschwinden. Klar wir haben immer noch 4 Räder, aber um Schrauben brauchen wir uns jetzt nicht mehr kümmern. Sehr wahrscheinlich wird in dem kleinen Spielzeug auch kein funktionsfähiger Motor verbaut sein. Beim Spielzeugmodell des Autos geht nur darum dass es so aussieht, wie das Original und dass es 4 drehbare Räder hat, damit man damit spielen kann. Und so macht man es auch in der Software. Man kümmert sich nur um die Details, die für das Funktionieren deines Programmes wichtig sind.

Nur die Details sind wichtig, die du wirklich brauchst

Halten wir fest: Wir haben Objekte(das Auto) die soviele Details(Räder) haben können, dass die einzelnen Details(das Rad) wiederrum Objekte sein könnten. Allerdings interessieren uns nicht alle Details. Das ein Rad mit Schrauben(wiederrum Objekte) befestigt wird, ist bei einem Spielzeugauto völlig egal. Also können wir diese Objekte einfach ignorieren. Aber woher weißt du, welches Details für überhaupt wichtig sind? Wer sagt dir, dass die Radschraube nicht wichtig für dein Programm ist? Es hängt davon ab, was du später mit diesem Objekt machen möchtest. Dein großes Auto ist natürlich sehr komplex, denn es muss den täglichen Straßenverkehr meistern. Möchtest du nur ein Spielzeugmodell davon haben, fallen viele Details weg. Selbst wenn man es in der selben Größe bauen würde wie das Original, würde es den Anforderungen der Strasse nicht gerecht werden. Ohne Motor müsstest du es schieben. Nehmen wir ein anderes Beispiel vom Auto, dein kleines Spielzeugmodell reicht dir nicht aus. Du möchtest dieses Spielzeugmodell fernsteuern… Und schon kommen neue Details dazu. Du brauchst immer noch 4 Räder und das Auto sollte ebenfalls Aussehen wie das Original. Was brauchst du nun an Details damit aus deinem Spielzeug ein ferngesteuertes Auto wird? Mach dir mal kurz Gedanken darüber, dann lies weiter.

Details beschreiben

Um aus deinem Spielzeug ein ferngesteuertes Auto zu machen, brauchst du nicht nur die Fernbedienung: Dein Modell braucht einen Motor, der die 4 Räder drehen kann. Eine Lenkung, damit das Auto nach Links oder Rechts gesteuert werden kann. Eine Art Funkmodul, welches die Befehle der Fernbedienung annimmt. Grob beschrieben würde dies so passen. Wenn du an eine ähnliche Lösung gedacht hast, bist du goldrichtig. Auch hier kann man sich wieder in Details verlieren. Welche Art von Motor und Antrieb wird gebraucht? Woher bekommt der Motor seine Energie? Akku oder Benzin? So tief wollen diesmal nicht gehen. Es geht einfach darum, dass du lernst wie man Objekte ansieht und analysiert und zwar immer bis auf die Ebene die notwendig ist. Wenn du nur mit dem Ferngesteuerten Auto rumfahren willst, ist dir nur wichtig, dass der Akku voll ist, dass dass Auto funktioniert und du die Fernbedienung benutzen kannst. Bist du der Modellbauer, dann interessierst du dich wiederrum für die Details in dem Modell. Wenn du Hersteller für ferngesteuerte Autos bist, dann interessieren dich sogar noch viel mehr Details. Wichtig, ist für dich, dass du lernst Objekte zu analysieren und deren Details herausfinden kannst, bis zu der Ebene die dich interessiert bzw. die notwendig ist. Wenn es für dich notwendig ist in den Motor deines Motor zugucken, benötigt du dafür viel Detailwissen. Details an Objekten nennt man auch Eigenschaften. Denn nicht immer ist ein Details auch noch ein Objekt. Dein Auto hat 4 Räder, ein Rad ist ein Objekt. Allerdings gibt es 4 davon. 4 Räder sind eine Eigenschaft deines Autos. Und dies ist eine Eigenschaft die auf alle Autos zutrifft.

Objekte, Eigenschaften und Funktionen

Die Eigenschaft, dass ein Auto 4 Räder hat ist an sich ja kein Objekt. Sondern es gibt 4 Objekte die zusammen diese Eigenschaft bilden. Aber gibt noch eine kleine Besonderheit in den Details deines Autos. Denn deine Objekte sind zwar keine Lebewesen, aber Sie können etwas tun. Ein Auto kann fahren. Und auch hier gelten wieder die gleichen Regeln für die Details. Ob dich interessiert was alles im Auto passiert damit es fährt, hängt wieder davon ab was dein Objekt letztendlich machen soll. Ein Spielzeugauto muss angeschoben werden, das kann nicht fahren. Das ferngesteuerte und das echte Auto können aber alleine fahren. Sie können auch beschleunigen, lenken und auch bremsen. Die Türen kann kann man öffnen, schließen. Fenster auf und zu machen usw.  Also auch hier nicht in den Details verlieren. Das was ein Objekt also machen kann, nennt sich in der Software Entwicklung Funktion oder Methode. Denn in deinem Programm würdest du deinem Objekt Befehle geben und damit genau diese Funktionen benutzen. Ich erkläre dir das ganze gleich anhand eines Rennspiels. Dort wirst du auch ein Auto brauchen. Kommt gleich 😉

Was du dir hier also merkst ist folgendes : Objekte haben Eigenschaften und Methoden. Und Objekte können aus anderen Objekten bestehen.

Die Gedanken, die du dir beim Modell des Auto gemacht hast, wirst du dir in Zukunft immer bei der Programmierung machen. Wir Softwareentwickler denken immer in Objekten, aus diesem Grund heißt es Objektorientierung. Man orientiert sich an Objekten. Alles was irgendwie komplex ist, ist ein Objekt. Ich hoffe dieser Begriff ist dir spätestens jetzt nicht mehr fremd.

Objekte die man nicht anfassen kann

Also wir Software Entwickler beschreiben alles gerne in Objekten aus der realen Welt. Das Beste Beispiel dafür ist die E-Mail. Mail ist zu deutsch ein Brief, das E steht für „electronic“ also elektronisch. Eine E-Mail ist also nichts anderes als ein elektronischer Brief. Ob hier wohl jemand objektorientiert gedacht hat? Einen Brief kann man anfassen, eine E-Mail naja erst wenn man sie ausdruckt, aber darum gehts hier nicht.

Ich weiß, der Artikel ist schwer genug, allerdings ist dieser Abschnitt der wichtigste für die Software Entwicklung. Nicht alle Objekte, die man in der Software Entwicklung findet kann man auch in der Realwelt anfassen. Du wirst immer wieder Objekte finden, die etwas komplizierter aufgebaut sind und es etwas dauert bis man Sie versteht. Zum Beispiel ein Mausklick. Ist dies für dich ein Objekt? Eigentlich nicht, es ist eine Art Ereignis und das kann man nicht anfassen, das passiert einfach. Allerdings kann man mit Ereignissen arbeiten. Wenn dein Wecker morgens klingelt ist das Klingeln zum Beispiel ein Ereignis und jeder weiß er dann tun muss. Man muss aufstehen. Auch wenn man das Ereignis nicht direkt anfassen kann, würde man beim Programmieren dieses als Objekt verwenden. Denn auch dein Ereignis „Wecker klingelt“, hat viele Details die man beachten kann. Erstens wäre da die Uhrzeit, wann das Ereignis stattfindet. Und ohne Wecker kein klingeln also auch hier wieder ein Objekt, dieses könnte man wiederrum anfassen. Wir Software Entwickler nennen alles was irgendwie eine Struktur oder Details aufweist Objekt, unabhängig davon ob es sichtbar oder anfassbar ist. Ich hab es dir versprochen, lass uns mal anfangen ein Rennspiel objektorientiert zu sehen. Wenn du es wirklich lernen willst, überleg dir doch mal welche Objekte in einem Rennen so auftauchen (auch nicht anfassbare). Und versuch dabei natürlich daran zu denken, dass wir hier ein Computerspiel schreiben wollen. Also ist es wichtig an die Objekte zu denken, die du bei einem Computerspiel so brauchst. Nimm dir am besten mal 10 Minuten Zeit dafür. Wenn du absolut keine Idee hast, schau dir mal ein paar Ausschnitte aus Formel1-Rennen an oder versuche mal ein Rennen auf einem Blatt Papier zu zeichnen. Wir würde dein Spiel auf dem Bildschirm aussehen?

Objektorientiert denken: Wir modellieren ein Rennspiel

Lass uns einmal schauen, wie ein Rennen so aufgebaut ist. Ok wir haben eine Rennstrecke und diese hat Geraden und Kurven. Der Belag der Strecke interessiert uns erstmal nicht. Für jede Gerade und Kurve gibt es aber ein paar Detail die interessant sind, z.B. die Länge der Gerade und der Winkel der Kurve. Zusammengesetzt ergeben diese die Rennstrecke. Dann haben wir die Autos, jedes Auto muss fahren und lenken können. Wie das Auto aussieht hängt allerdings davon ab wie das Spiel aufgebaut ist. Haben wir eine Carerrabahn im Spiel, dann sind es kleine Modelle. Wollen wir ein 3D-Spiel machen, dann brauchen wir viele Details über das Aussehen. Haben wir ein 2D-Rennspiel bei dem wir das Spielfeld von oben sehen, brauchen wir das Aussehen des Autos von oben. Hier hängen die Details wieder mal vom Fall ab wie das Ergebnis aussehen soll. Zurück um Rennen, das Rennen läuft über ein paar Runden und die Autos fahren über die Rennstrecke. Das Auto welches zu erst über die Ziellinie fährt hat gewonnen. Auch in diesem Satz verstecken sich Objekte. Die Ziellinie ist definitiv wichtig um herauszufinden wer der Gewinner ist. Dies wäre an sich ja nicht das Auto sondern der Fahrer des Autos. Da wir hier ein Videospiel schreiben wollen, haben wir auch keine echten Fahrer sondern Computerbenutzer. Hier verschwimmt nun langsam das echte Rennen zum Videospiel. Immer wieder stoßen wir mit unseren Objekten an Details, die zum Computer gehören. Also fangen wir an auch die Objekte zu finden, die wir in einem Rennspiel erwarten. Das heißt die Rennstrecke muss irgendwie auf dem Bildschirm gezeichnet werden. So auch die Autos. Die Autos müssen sich über den Bildschirm und die Rennstrecke bewegen. Wie hängt wieder rum davon ab ob es ein 2D oder 3D Rennspiel ist. Die Autos müssen beschleunigen, bremsen und lenken können. Dafür ist in unseren Computer kein Gaspedal zuständig, sondern die Tastatur oder ein Gamepad. Also überlegen wir weiter, um das Auto zu beschleunigen muss der Nutzer eine Taste auf der Tastatur drücken. Was würdest sagen, ist die ein Detail, welches wichtig für dein Computerspiel ist? Genau. Du merkst, dass dein Auto-Objekt sich ziemlich von dem echten Auto unterscheidet. Es ist nicht wichtig, dass es 4 Räder hat. Hier ist wichtig, welche Tasten es beschleunigen. Was passiert eigentlich bei der Beschleunigung? Die Geschwindigkeit wird erhöht. Diese Information könnte wichtig sein in einem Rennspiel, zum Beispiel, wenn man sie anzeigen möchte. Das sind jetzt nur ein paar Details, zum Rennspiel gehören. Ich wollte dir hier zeigen, wieviel dazu gehört, wenn man anfängt ein Computerspiel objektorientiert zu modellieren.

Wichtig in dieser Übung ist, dass du lernst in Beispielen zu denken um deine Objekte, Eigenschaften und Methoden zu erhalten. Erst wenn du ein gutes Beispiel durchdenkst, wirst du sehen welche Objekte es gibt, wie sie zusammenhängen und welche davon du wirklich benötigst. Mit dem Objekt modellierst du deine Software. Beim Rennspiel merkst du, dass man sich selbst dort schnell in Detail verlieren kann. Wenn du dich also schonmal gefragt hast, warum man nicht in einem Rennspiel einfach aus dem Auto aussteigen kann, dann versuch doch mal mit Objekten zu modellieren, was du eigentlich alles passieren muss. Man sollte sich vorher überlegen, was das Programm eigentlich können soll, damit man die Objekte genau darauf ausrichten kann.

Objekte im Computer

Wir haben jetzt über Objekte in der echten Welt gesprochen und schon bereits ein paar Ideen für Objekte in einem Rennspiel gesehen. Nun, aber wie kommen unsere Objekte nun in den Computer? Dafür gibt es in jeder Programmiersprache bestimmte Sprachelemente. In Javascript zum Beispiel heißen diese tatsächlich Objekte. Allerdings bestehen Objekte im Programmcode aus Variablen. Was Variablen sind lernst du in meinem Kurs. Für einfache Objekte kann man Variablen nehmen. Und unser Computer kennt ein paar Variablentypen. Damit kann man Text und Zahlen abbilden. Wenn wir also unsere Geschwindigkeit im Objekt notieren wollen, nehmen wir eine Zahlvariable mit dem Namen Geschwindigkeit. Wenn wir die Maximalgeschwindigkeit nehmen, ist dies auch eine Zahl. Wollen wir das Auto aber auf dem Bildschirm darstellen brauchen ein Objekt welches uns hilft, auf den Bildschirm etwas zeichnen zu können. Die kleinste Einheit im Computer ist die Variable. Erst wenn deine Variable zu komplex wird brauchst du mehrere und kannst diese dann zu Objekten zusammenfassen. Wie das funktioniert lernst du in meinen Kursen.

Fazit

In diesem Artikel hast du gelernt was Objektorientierung ist. Alles was Details hat, und irgendwie strukturiert ist, ist ein Objekt. Egal ob man es anfassen kann oder nicht. Worauf man genau achten muss bei der Programmierung sollte hier nur kurz angerissen werden. Dafür werde ich noch weitere Artikel veröffentlichen. Mich würde aber interessieren, welche Objekte du deinem Rennspiel so gefunden hast. Schreib es einfach in die Kommetare!

Programmieren im Team: Vorgehensmodelle

Programmieren im Team – Vorgehensmodelle

Was ist denn ein Vorgehensmodell? Damit in deinem Programmierer-Team nicht alles schief läuft, müsst ihr euch auf bestimmte Regeln einigen. Regeln, die bestimmten wie Ihr zusammenarbeitet und wer welche Arbeit macht. Heutzutage wird Software kontinuierlich entwickelt, das heißt ist eine Version erstmal veröffentlicht, wird gleich an der nächsten Version gearbeitet. Dabei wird nicht alles neuprogrammiert, es werden Fehler behoben und neue Features eingebaut. Damit das auch einwandfrei klappen kann, kann nicht jeder Programmierer einfach an dem arbeiten wo er grad Lust drauf hat. Hier muss strukturiert und geplant vorgegangen werden und hier sind wir letztendlich wieder beim Begriff Vorgehen. Das Vorgehensmodell schlägt Regeln vor, wie ein Team in der Softwareentwicklung zusammenarbeiten sollte. Es gibt sehr viele Vorgehensmodelle für Teams, ich möchte dir kurz 3 davon vorstellen.

Extreme Programming (XP)

Dieses Modell setzt Kommunikation im Team an die vorderste Stelle. Es wird davon ausgegangen, dass man zu anfangs noch nicht weiß, was alles programmiert werden soll. Also versucht man so schnell wie möglich eine einsatzfähige Software zum Nutzer zu bringen. Dieser kann seine Rückmeldung geben und kann somit direkt auf die Programmierung Einfluss nehmen.

Ein wichtiger Bestandteil ist die Verwaltung von Anforderungen. Das heißt zum einen das Gespräch mit dem Nutzer, welche Funktionen er benötigt. Diese Anforderungen müssen dann in die Planung aufgenommen werden. Dabei wird geplant welche Funktionen in welche Version der Software hineinkommen, welche Funktionen letztendlich in eine Version hineinkommen, wird unter anderen mit der Kundenzufriedenheit entschieden. Die Funktionen die in einer Version gemacht werden, werden dann in User-Stories beschrieben. Jede User-Story wird abgeschätzt,das heißt es wird geschätzt wie lange der Programmierer für diese Funktion braucht.

Die Entwicklung läuft dann ungefähr so: Jeden Tag trifft man sich kurz und spricht über den aktuellen Arbeitsstand. Danach wird programmiert, allerdings gemeinsam. Dies nennt sich Pair-Programming, es sitzen immer zwie Entwickler an einem Platz und wechseln sich ständig ab. Dies ist ist sicherlich noch nicht alles über Extreme Programming aber für den ersten Einblick sollte dies reichen.

Scrum

Mikroschaubild der ScrumprozessesScrum geht davon aus, dass die Programmierung einer Software zu komplex ist um alles bis ins kleinste Detail durchzuplanen. Es müssen immer wiederkehrende Schleifen durchlaufen werden um sich langsam an das anzunähern was der Nutzer eigentlich haben will. Dabei werden alle Features in ein Product-Backlog geschrieben, welches vom Product Owner gepflegt wird. Dann geht es zu den Sprints. Ein Sprint ist eine immer gleich lange Zeitspanne, zunächst wird in einem Sprint-Backlog festgelegt welche Features erfüllt werden sollen. Die Entwickler können dann starten in einem Sprint alle Features zu erfüllen, dabei treffen diese sich täglich um kurz zu sprechen. Dieses Daily-Scrum dauert ca. 15 Minuten, es wird geklärt was im letzten Tag erledigt wurde, Wo es Probleme gab, und was bis zum nächsten Tag erledigt wird.

Ist der Sprint durch, wird im Sprint-Review präsentiert, welche Features nun entwickelt worden sind. Mit einer Sprint Retrospektive wird besprochen was im letzten Sprint gelernt wurde und was sich verbessern lässt.

Das das Scrum auch gelebt wird, wird von einem Scrum-Master geprüft. Er hilft dem Entwicklerteam durch Führen durch Dienen.

Kanban

Neben dem eigentlichen Kanban-Vorgehen werden sogenannte Kanban-Boards (ein normales Whiteboard) verwendet, auf welchen alle Aufgaben und Probleme in Form von Karteikarten oder Post-Its gesammelt werden. Dabei wird der gesamte eigene Entwicklungsprozess auf dem Kanban-Board in Spalten visualisiert. Die bestehenden Karteikarten werden in die jeweils passenden Spalten einsortiert.

Danach wird festgelegt wie hoch der Work-In-Progress sein darf. Was bedeutet das? Pro Spalte wird festgelegt wie viele Karteikarten maximal in diese Spalte landen dürfen. Diese Grenzen bewirken, dass man alle Probleme anpackt und nichts liegen bleibt. Es wird also nicht mehr drumherum gearbeitet.

Dieser Flow führt beim richtigen und konsequenten Einsatz dazu, dass eine kontinuierliche Verbesserung der Arbeit im Entwicklungsteam stattfindet.

Fazit

Diese Kurzbeschreibung der Vorgehensmodelle sollte nur ein kleinen Einblick in das Geben, was dir bei der Arbeit im Team so vor die Augen kommen wird. Diese Vorgehensmodelle werden bei der professionellen Programmierung eingesetzt. Auch zu erwähnen: Diese Vorgehensmodelle schließen sich nicht gegenseitig aus! Es ist durchaus möglich, dass ein Team mit Scrum und einem Kanban-Board arbeitet und gleichzeitig noch Ansätze aus dem Extreme Programming nutzt. Wie sieht es bei dir aus? Hast du bereits Erfahrungen mit Vorgehensmodellen für die Arbeit im Team?

 

Programmieren im Team: Versionierung

Programmieren im Team – Versionierung

Je größer deine Programme und Projekte werden, umso mehr wirst du irgendwann mit einem Team programmieren. Dafür gibt es ein paar Regeln und Methoden um sich erstens, die Arbeit gegenseitig nicht kaputt zu machen und zweitens die Arbeit so zu managen, dass sich keiner in die Quere kommt(und evtl. etwas doppelt programmiert). Nur so schafft ihr es, das Programm zu entwickeln welches ihr euch vorstellt und dies in einer akzeptablen Zeit. Zwei Themen und passende zwei Technologien möchte ich dir heute kurz vorstellen, damit du weißt was im Team auf dich zukommt.

Was ist Versionierung? Hier gibt es zwei Anwendungsfälle, zum einen solltest du deine Software in verschiedenen Versionen veröffentlichen. So können deine Nutzer immer sehen welche Version sie benutzen und prüfen ob es Updates gibt. Das andere ist das Programmieren zusammen mit deinen Teamkollegen. Stell dir mal vor du und dein Kollege arbeiten an einem Feature (weil dieses viel Arbeit macht). Jeder von euch hat eine Kopie des gesamten Quellcodes, oder ihr arbeitet gemeinsam auf einem Server. Und nun passiert es: Ihr bearbeitet die gleiche Datei; und das auch noch gleichzeitig. Wer jetzt zuerst abspeichert hat seine Änderungen drin, der andere kann von vorne beginnen. Damit so etwas nicht passiert, gibt es Versionsverwaltungssysteme wie Subversion und Git.

Subversion

Subversion oder kurz SVN ist ein zentrales Tool zum Verwalten des Quellcodes. Somit brauchst du einen Server auf dem der Subversion-Server läuft. Jeder der dann damit arbeiten möchte braucht einen SVN-Client. Diese gibt es grafisch, aber auch auf Kommandozeilenebene. Ist der Server einmal eingerichtet gibt es ein paar Workflows um mit dem Quellcode und SVN zu arbeiten. Hier eine Auflistung der Kommandozeilenbefehle und eine kurze Erklärung dazu.

Neuen Quelltextordner im SVN erstellen

Mit svn mkdir kann man auf dem Server einen neuen Ordner anlegen. Von diesem Ordner kann man sich nun eine Arbeitskopie holen und Dateien hinzufügen.

Arbeitskopie holen

Mit svn checkout kann man sich eine Arbeitskopie vom SVN-Server holen, das heißt wenn du noch keine Arbeitskopie hast, verwendest du svn checkout.

Arbeitskopie speichern

Hast du deine Änderungen gemacht und möchtest diese auf dem Server sichern, verwendest du svn commit -m „Dein Kommentar zur Änderung“. Der Parameter -m steht für Message. Das heißt jede Änderung, die du einpflegst, musst du mit einem Kommentar bestücken.

Quelltextdateien hinzufügen und löschen

Wenn du neue Dateien hinzufügen oder löschen möchtest verwendest du svn add und svn delete. Hier musst du darauf achten, dass du deine Änderungen noch mit svn commit speichern musst! Ansonsten hast du die Dateien nur in deiner Arbeitskopie als hinzugefügt oder gelöscht markiert.

Arbeitskopie aktualisieren

Wenn du mit mehreren Kollegen an einem Projekt arbeitest, kann es durchaus öfter vorkommen, dass du mal einen neuen Stand des Quellcodes benötigst. Diesen aktualisierst du mit svn update. Jetzt kommt’s, SVN wird nun die aktuellste Kopie auf dem SVN-Server herunterladen und mit deinen Änderungen zusammenfügen. Im Regelfall funktioniert dies super. In gewissen Ausnahmen kann es aber zu Problemen kommen, dann markiert dir SVN, die Dateien mit einem Konflikt.

Konflikte

Konflikt bedeutet lediglich, dass du und dein Kollege die selbe Codezeile verändert haben. Nun musst du mit deinem Kollegen sprechen und klären was dort passiert ist. Hier ist Kommunikation das Zauberwort! Manchmal ist es aber auch direkt ersichtlich, was passiert ist und man kann den Konflikt von alleine lösen. Ist der Konflikt gelöst führst du den Befehl aus: svn resolve deineDatei.code. Beim resolve musst du immer die Datei mitangeben.

Zweige (Branch und Merge)

Wenn es öfter zu Konflikten kommen sollte, liegt dies daran, dass du und dein Kollege zu nah an den selben Features arbeitet. In diesem Fall ist es vielleicht sinnvoller einen Entwicklungszweig zu erstellen. Ein Zweig also ein Branch ist eine Kopie eines Ordners, welche aber später wieder in den ursprünglichen Ordner zusammengeführt werden kann. Dies macht man mit den Befehlen svn copy und svn merge.

Git

Ein weiteres und sehr verbreitetes Versionsverwaltungssystem ist Git. Git ist im Gegenteil zu SVN ein verteiltes System. Bei Git klonst (kopierst) du den Original Quellcode lokal auf deine Platte mit git clone. Danach gibt es 3 verschiedene Stellen. Der Originalcode (HEAD genannt), den Index (Stage), und deine Arbeitskopie. Der Index ist eine Zwischenstufe. Mit git add schlägst du deine Änderungen vor (in den Index). Mit git commit kannst du deine Änderungen in die HEAD-Kopie einpflegen. Allerdings bist du immernoch lokal! Erst mit git push kommen deine Änderungen auf den entfernten Server. Um deine Kopien zu aktualisieren verwendest du git pull.

Fazit

 

Dass du an diesem Punkt noch nicht direkt mit SVN und git loslegen kannst, sollte dir klar sein. Dies sollte jetzt nur eine kleine Einführung in die Versionierung gewesen sein, eine umfassende Einführung gibt es auf Anfrage. Außerdem gibt es natürlich noch andere Systeme, die ich hier nicht behandelt habe. Nun hast du einen kleinen Einblick in die Versionsverwaltung bekommen. Wie sieht es bei dir aus? Hast bereits Erfahrungen in der Arbeit im Team bekommen? Kommentiere unten und lass uns darüber diskutieren!

Der Softwareentwicklungsprozess, der zyklisch abgearbeitet werden kann.

Der Softwareentwicklungszyklus

Wenn du an diesem Thema angekommen bist, hast du bereit 95% Prozent davon gelernt wie man wirklich professionelle Software erstellt. Mit dem Programmieren solltest du an dieser Stelle kein Problem mehr haben.

Hier geht es nur noch darum die Erstellung der Software strukturiert zu durchlaufen. Das heißt, Software wird immer nach dem gleichen Prozess erstellt. Je nach dem wie oft man diesen Prozess durchläuft wird die Software besser oder schlechter, aber eigentlich sollte diese besser werden.

Ausserdem ist es wichtig, dass am Ende des Prozesses auch die Software herauskommt die du dir ausgedacht hast, oder für die dich dein Kunde bezahlt. Kommt am Ende des Prozesses nicht das heraus was dein Kunde will, bleibt dein Konto einfach leer.

Bestandteile des Softwareentwicklungszyklus

Damit du den ganzen Prozess kennenlernen kannst, bekommst du nun eine kleine Vorstellung der wichtigen Bereiche. Wichtig ist zu erwähnen, dass dieser Zyklus immer wieder durchläuft. Also einmal am Ende angekommen,  geht es immer wieder von vorne los!

Software Entwicklungsprozess

Anforderungsanalyse und Planung

Was ist denn eine Anforderungsanalyse? Klären wir erstmal den Begriff Anforderung an sich. Im übertragenen Sinne ist eine Anforderung ein Wunsch oder eine Idee für eine Funktion bzw. ein Feature in einem Computerprogramm. Dabei haben Anforderungen selbst bestimmte Kategorien. Eine Anforderung kann funktional und nicht funktional sein. Funktional ist zum Beispiel: „Der Roboter soll Bälle aufsammeln.“, hier ist also die Funktion gemeint. Nichtfunktionale Anforderungen können sein: „Der Roboter soll die Bälle INNERHALB VON 2 MINUTEN aufsammeln.“, hier kommt also eine Eigenschaft dazu. Die Aufgabe muss innerhalb bestimmter Rahmenbedingungen erfüllt werden, in diesem Fall geht es um Performance. Diese Anforderungen haben natürlich Auswirkungen auf die gesamte Entwicklung deines Programmes, denn du als Programmierer musst dir auch noch überlegen, wie dein Roboter die Aufgabe schnell erledigen soll. Bei der Anforderungsanalyse geht es darum herauszufinden, welche funktionalen und nichtfunktionalen Anforderungen für dein Programm gefordert werden. Wenn du selbst diese Anforderungen vorgibst ist es vielleicht noch einfach. Aber sobald du einen Auftrag von einem Kunden bekommst, solltest du schon genauestens herausfinden was er eigentlich will.

Diese Anforderungen werden dann in einen Plan gesteckt. Welche Anforderung ist am wichtigsten? Was muss eigentlich zuerst programmiert werden? Sobald du weißt, was alles gefordert wird, kannst du auch einschätzen wie lange du programmieren wirst. Ein Roboter der Bälle aufsammelt? Ein Aufgabe für 2 Stunden Arbeit. Der soll das innerhalb von 2 Minuten machen? Dann setz lieber nochmal eine Stunde drauf.

Mit der Planung wirst du also auch Aussagen über deine Terminplanung machen können. Aber das Thema geht dann schon fast ins Projektmanagement hinein.

Konzept und Design

Deine Anforderungen sind klar und der Plan steht auch. Du weißt nun, dass du die 20 Funktionen innerhalb von 3 Monaten programmieren willst. Das wird deine Version 1.0. Dies ist schon eine Art Konzept. Also gehst du los und fängst an dieses noch weiter auszuarbeiten, in dem du beschreibst, wie du all diese Anforderungen ausprogrammieren willst. Je nach Größe deines Programmes bietet es sich hier an, vermehrt UML-Diagramme zu verwenden. Wichtig ist, dass du dich an der Stelle auf die Anforderungen konzentrierst. Steht dein Grundkonzept, ist es für dich ein leichtes das Design aufzustellen. Zumindest, wenn du objektorientiert arbeitest. Hier verwendest du die Objektorientierte Analyse und das Objektorientierte Design und dein Design festzulegen.

Implementierung und Test

Ist dein Design soweit fertig, kannst du mit der Programmierung anfangen. Ganz klar, programmierst du hier wieder objektorientiert und dazu gehören natürlich auch die Tests. So stellst du sicher, dass dein Programm von Anfang an stabil bleibt. Ideal ist es ebenfalls, pro Anforderung einen eigenen Test zu schreiben. So kannst du im besten Fall direkt prüfen ob die Anforderungen bereits erfüllt werden. Allerdings ist das Testen von Anforderungen nicht immer ganz einfach.

Release und Wartung

Hast du alle relevanten Funktionen fertig programmiert, bist du bereit dein Programm freizugeben. Das bedeutet du musst dein Programm irgendwie veröffentlichen oder sonst wie herausgeben. Dafür gibt es die unterschiedlichsten Systeme. Im einfachsten Fall bietest du die ausführbare Datei (also deine Exe, oder App, usw.) einfach zum Download an. Bei Android kannst du deine App direkt im Store veröffentlichen, das ist sogar noch einfacher.

Egal wie, sobald Leute deine Programme benutzen, wirst du eine Rückmeldung sehr oft bekommen. Du kannst testen was das Zeug hält, aber eins ist sicher. Deine Software wird Fehler enthalten. Irgendein Benutzer wird es schaffen, den Knopf so zu drücken, dass dein Programm abstürzt. Kein Grund aufzugeben! An der Stelle ist es wichtig, dass du deine Software warten kannst und alle Fehlerbehebungen gleich wieder in deine veröffentlichte Version packst.

Installation und Schulung

Deine Benutzer müssen, auf der anderen Seite dein Programm installieren können. Sie sind keine Softwareentwickler wie du, Sie brauchen Hilfe und Anleitung um die Installation durchzuführen. Nicht immer ist es also ratsam nur die Ausführbare Datei zum Download anzubieten. Die Akzeptanz deiner Benutzer würde sich an dieser Stelle extrem mindern. In vielen Fällen wirst du also ein Installationsprogramm benötigen, welches du mit deinem Programm anbietest. Und damit ist es nicht getan. Nur weil dein Nutzer das Programm nun starten kann, ist er noch lange nicht in der Lage es zu benutzen.

Je nach Größe und Funktionsumfang, brauchst du Handbücher, Tutorials oder sogar ganze Schulungen für deine Benutzer. Nichts ist schlimmer als ein Benutzer der aufhört deine Programme zu benutzen, weil er deine Software nicht versteht. In jeden Videospiel sind heutzutage kleine Tutorials eingebaut, also hilf deinem Nutzer dein Programm zu verstehen.

Fazit

Mit der alleinigen Programmierung hat der Softwareentwicklungszyklus nicht mehr viel zutun. Viel mehr geht es hier um das große Ganze. Dazu kommt, dass es sehr kurze Entwicklungszyklen gibt. In der Agilen Softwareentwicklung, kann es dir passieren das dieser Zyklus wöchentlich durchläuft. Nur so kriegt man es hin sich auf Situationen und Wünsche deiner Kunden einzustellen.

Wie sieht es bei dir aus? Hast du bereits Erfahrungen mit dem Softwareentwicklungszyklus gemacht? Kommentiere unten und lass uns darüber sprechen!

Was sind Entwurfsmuster und wofür braucht man die?

Entwurfsmuster, Refactoring und Clean Code

Entwurfsmuster sind vorgefertigte Klassenstrukturen, die häufig in großen Programmen auftauchen. Wenn du hier angekommen bist, hast du bereits viel über das Programmieren gelernt und bist bereits in der Lage richtige Programme zu schreiben. Allerdings möchtest du deine Programme größer gestalten, sie sollen mehr Funktionalität haben als andere Programme.

Ab diesem Punkt kommst du in Probleme hinein die nur mittels weiterer Techniken gelöst werden können. Entwurfsmuster lösen Standardprobleme von komplexen Programmen. Refactoring ist die Arbeit die du erledigen musst um deinen Code zu warten oder zu reparieren, nur so schmeißt du Designfehler raus. Clean Code ist die Arbeit, deinen Code nicht nur so zu schreiben, dass er nur funktioniert sondern, dass dieser sauber also lesbar ist.

Mit diesen Methoden kannst du dann schon professionelle Software schreiben. Gehen wir kurz durch die drei Themenbereiche durch.

Entwurfsmuster

Das ist die hohe Kunst der Programmierung. Das beste Beispiel für ein Entwurfsmuster ist das Command-Muster. Was macht dieses? Weißt du wie man ein Rückgängig oder einen Wiederholen-Befehl programmiert? Nein? Dies funktioniert mit dem Command-Muster. Also was machen Entwurfsmuster? Sie geben dir Lösungen für Standardprobleme aus der objektorientierten Programmierung. Dabei unterteilen sich die Entwurfsmuster in 3 Hauptbereiche, es gibt auch noch weitere Bereiche, allerdings sind diese erstmal die wichtigsten.

  • Erzeugungsmuster: Abstract Factory, Singleton, Builder, Factory Method, Multiton, Prototype, …
  • Strukturmuster: Adapter, Bridge, Container, Decorator, Facade, Flyweight, Composite, Proxy, …
  • Verhaltensmuster: Observer, Visitor, Interpreter, Iterator, Command, Memento, Nullobject, Strategy, Mediator, State, …

Die Erzeugungsmuster lösen Probleme bei der Erstellung von Objekten aus Klassen. Dabei gibt es verschiedene Fälle mit denen man neue Objekte erstellen kann. Die wohl bekanntesten sind der Singleton und die Factory. Der Singleton stellt sicher, dass immer nur ein Objekt einer Klasse erstellt werden kann. Die Factory ist wie eine Fabrik, sie produziert Objekte und gibt diese an den „Kunden“ zurück.

Die Strukturmuster helfen dir, dein Programm sauber aufzubauen und zu strukturieren. Wenn du einem anderen Entwickler erklärst, du hast einen Container programmiert, weiß er ganz genau wovon du sprichst.

Die Verhaltensmuster lösen eine bestimmte Aufgabe. Der Observer zum Beispiel ist dafür da, ein bestimmtes Objekt zu beobachten (observieren) und dann anderen Objekten Bescheid zu sagen, wenn sich etwas ändert. Bei vielen Sprachen ist der Observer als Event oder Delegate implementiert. Mit dem Commando-Muster kann man, wie bereits erwähnt, den berühmten Rückgängig-Befehl und auch noch andere Funktionen programmieren.

Alleine für Entwurfsmuster gibt es ganze Bücher. Du wirst sicherlich nicht alle Muster benötigen, aber mit der richtigen Erfahrung wirst du diese von alleine benutzen wollen.

LEIDER gibt es auch das Gegenteil von Entwurfsmustern, das sind die sogenannten Antipattern. Das sind Lösungen in Programmen die zu Fehlern führen und schlecht wartbar sind. Auch du wirst irgendwann mit solchen Antipattern zutun haben. Wie du damit umgehst, lernst du im Refactoring.

Refactoring

Mit dem Refactoring wird das Warten also das Reparieren von Programmcode gemeint. Allerdings werden hier keine Programmierfehler repariert sondern sogenannter schlechter oder stinkender Code (nicht Kot!!!). Beim Refactoring lernst du, wie du schlechten Code so umstrukturieren kannst, dass dieser wieder sauber ist. Dabei steht die Funktionalität deines Programmes nicht im Vordergrund sondern andere wichtige Punkte in deinem Quelltext. Diese sind:

  • Lesbarkeit
  • Übersichtlichkeit
  • Verständlichkeit
  • Erweiterbarkeit
  • Keine Codeduplikate
  • Testbarkeit

Damit man dies erreichen kann, gibt es ein paar Methoden und Techniken. Diese fanden beim Umbenennen von Variablen und gehen bis hin zum kompletten Umstrukturieren des Quellcodes. Diese Techniken stammen von Martin Fowler.

Clean Code

Mit Clean Code also sauberen Quelltext ist genau das Gegenteil von schlechten Code gemeint. Der Software Entwickler Robert C. Martin hat diesen Begriff geprägt. Sauberer Quellcode, aber auch saubere Software ist stabiler und wartbarer. Dafür muss diese nicht nur funktionieren, sondern auch intuitiv verständlich sein.

Das hört sich jetzt vielleicht kompliziert an, ist es aber gar nicht. Du musst einfach bedenken, dass du deine Quelltext ungefähr 10 Mal öfter liest als schreibst. Das heißt jeder geschriebene Codezeile wird ungefährt 10 Mal gelesen. Aus diesem Grund sollte deine Software auch dementsprechend leicht zu lesen sein, oder? Um dies zu erreichen setzt man zum einen Entwurfsmuster ein, macht Refactorings seiner Programme und wendet beim Programmieren ein paar Prinzipien an die leicht zu erlernen sind.

Allerdings erfordert Sauberer Code eine sehr hohe Disziplin. Denn wenn es mal schnell gehen muss, neigt man dazu schlechten Code zu produzieren. Folgend schonmal 2 Prinzipien:

Aussagekräftige Namen

Verwende IMMER aussagekräftige Namen für Funktionen, Klassen und Variablen. Wenn du dies tust werden sogar Kommentar fast überflüssig. Verwede lieber einen langen Variablennamen, der seinen Zweck beschreibt, als ein nichtssagenden Kommentar.

2 Regeln für Funktionen

1. Die Funktion sollte sehr kurz sein.

2. Wenn sie kurz ist, sollte sie noch kürzer sein.

Mit diesem 2 Prinzipien lasse ich dich erstmal alleine, denn auch zu diesem Thema gibt es ganze Bücher. Wichtig ist, dass du bei diesem Thema lernst wie man stabile und wartbare Programme schreibt. Du kannst das tollste Spiel auf der ganzen Welt programmiert haben, aber wenn es 3 Jahre dauert um einen Fehler zu lösen, wirst du damit nicht erfolgreich werden.

 

Fazit

In diesem Lernbereich lernst du die richtige professionelle Softwareentwicklung. Wenn du in der Lage bist Entwurfsmuster zu benutzen und sauberen Quelltext zu schreiben, dann hast du eigentlich schon fast alle wichtigen Techniken drauf, die es dir ermöglichen wirklich professionelle Programme zu schreiben. Ab dieser Stelle ist es eigentlich nur noch deiner Kreativität und deinem Fleiß überlassen, die Programme zu schreiben die du dir ausdenkst. Allerdings gibt es noch weitere Themen die wichtig sind. Wie ist es zum Beispiel mit Kundenwünschen? Oder der Zeitlichen Planung wie lange du für ein Programm schreiben musst? Hierfür musst du als nächstes etwas über den Softwareentwicklungszyklus lernen. Mit Programmieren hat dies dann auch nicht mehr viel zutun, gehört aber dazu.

Objektorientierung: Was ist das?

Ooh Ooh – Objektorientierung

In diesem Artikel gehe ich nun weiter im Lernpfad zum Thema der Objektorientierung. Wenn du deine erste eigene Anwendung geschrieben hast, fängst du an und lernst die Objektorientierte Programmierung kennen. Dieses Thema hört sich so schwierig an und ist doch so einfach, wenn man erst einmal durchgeblickt hat. Steigst du in die Objektorientierung ein, wirst du alle Strukturen und Ideen in deinem Kopf in ein Programm überführen können.

Ab dieser Stelle geht es nicht mehr alleine um das Eintippen von Quelltext in deine Entwicklungsumgebung. Hier geht es um richtiges Gehirnschmalz. Ich erkläre dir kurz die wesentlichen Bereiche die du dir aneignen solltest.

Objektorientierte Analyse (OOA)

Was passiert bei der objektorientierten Analyse und wofür ist diese gut? Du willst ja deine Idee in ein Programm überführen. Das bedeutet, dass du dein Konzept im Kopf irgendwie in deinen Programmcode überführen musst. Damit du genau weißt wie deine Idee später im Programmcode aussehen soll, gibt es die objektorientierte Analyse. Du gehst los und schreibst alle wesentlichen Merkmale deiner Idee auf und zwar ins kleinste Detail. Auch hier gibt es wieder verschiedene Techniken um eine ordentliche Analyse zu erhalten. Als nächstes prüfst du, ob die Merkmale deiner Idee in Klassen passen (Du weißt nicht was eine Klasse ist? Dann aber schnell zurück zu den Grundlagen). Sobald du anfängst mit Klassen zu arbeiten bist du eigentlich bereit im nächsten Schritt, dem Design deiner Klassenstruktur. Damit du auch später alle Funktionen programmieren kannst, solltest du auch hier bereits wissen, welche Funktionen deine Bibliothek bereits zur Verfügung stellt oder zumindest zu diesem Zeitpunkt danach suchen.

Objektorientiertes Design (OOD)

Du weißt anhand deiner Analyse nun ganz genau welche Klassen und Methoden du benötigst und welche davon du schreiben musst. Nun gilt es das Ganze zu einem Gesamtbild zu gestalten. Dafür wirst du weiter Klassen benötigen. Hier kommen bereits erste Objektorientierte Prinzipien zum Vorschein, denn irgendwann werden Strukturen unhandlich und nicht wartbar. Wichtig ist hier erstmal ein Gesamtkonzept über dein Programm zu erhalten. Dieses teilt man auch noch meistens auf in Grob- und Feinkonzept. Im Grobkonzept sind nur ganz allgemeine Strukturen beschrieben, aber im Feinkonzept geht es richtig ins Detail. Somit weißt du nun was du genau programmieren musst. Das Gute hier dran ist: Du kannst während des Designs bereits kleine Prototypen erstellen, um zu sehen ob die Struktur so umsetzbar ist.

Objektorientierte Programmierung (OOP)

Da du nun ein fertiges Design hast, geht es darum dieses mittels einer Programmiersprache einzuprogrammieren. Wenn du dir die richtigen Gedanken gemacht hast ist dieser Schritt fast der einfachste. Allerdings musst du auch immer wieder überprüfen ob dein Programm dann auch wirklich das tut was es soll. Hier greifst du auf die Grundlagen zurück die du im Vorfeld gelernt hast. Nicht nur die Grundelemente der Hochsprachen sind hier wichtig. Hier benötigt bereits das Wissen über Klassen und Objekte und genauso das Wissen über die Bibliothek, die du verwendest. Außerdem können Klassen miteinander arbeiten oder können Eigenschaften voneinander erben. Diese Dinge musst du an diesem Punkt bereits anwenden oder dir aneignen können. Bist du hier angekommen, ist deine eigenes richtiges Programm nicht mehr weit oder du hast es bereits geschafft dein Programm zu schreiben, welches du dir vorstellst.

Unit-Testing

Du wirst von Anfang an gemerkt haben. Programme haben Fehler. Egal was du programmierst, irgendwann musst du einen Fehler suchen. In der Objektorientierung versucht man dieses Problem mittels Unit-Tests in den Griff zu bekommen. Dafür wird neben dem eigentlichen Programm ein zusätzliches Testprogramm geschrieben. Für jede Klasse in deinem Programm, gibt es eine passende Testklasse. Das hört sich zwar nach viel Arbeit an, aber ist im Vergleich zu der Zeit wie lange du einen Fehler suchen würdest ein kleiner Bruchteil. Man bekommt so nicht alle Fehler herausgefunden, aber selbst eine Testabdeckung von nur 1% ist besser als gar keine Tests.

Unified Modeling Language (UML)

Diese sogenannte Sprache ist eine Beschreibungssprache, mit der du grafisch Strukturen notieren kannst. Die UML besteht aus einer Sammlung von verschiedenen Diagrammarten. Mit jeder Diagrammart kannst du andere Strukturen dokumentieren. Wofür? Nehmen wir mal das Klassendiagramm. Hiermit kannst du dein objektorientiertes Design grafisch darstellen. Wenn du dann mal mit einem anderen Programmierer über dein Design sprechen willst, versteht er dich sofort, weil er die UML ebenfalls kennt. Es gibt natürlich noch mehr Diagrammarten in der UML.

Das nützliche an der UML ist, dass es Codegeneratoren gibt, mit denen man direkt aus den Diagrammen Programmcode generieren lassen kann. Bevor du nun losrennst um die so ein Werkzeug zu suchen, diese Werkzeuge programmieren nicht für dich, du programmierst dann zum Teil in der UML und in deiner Programmiersprache. Also das ganze ist wirklich nur nützlich für dich, wenn du bereits perfekt programmieren kannst und du UML Diagramme erstellen kannst. Die Arbeit selbst wird dadurch nicht weniger, aber kann dadurch erheblich beschleunigt werden.

Fazit

Bist du an diesem Punkt angekommen und kennst dich in der Objektorientierung aus und genauso so in der UML, kannst du bereits normale Programme schreiben. Wenn du eine konkrete Vorstellung deines Programmes hast, hast du kein Problem dieses umzusetzen. Du kannst dein Programm mittels der UML designen und komplexe Strukturen programmieren. Deine Programme stürzen nicht so oft ab, da du mit Unit-Tests jede deiner Klassen auf die Funktionalität testest. Ab hier gilt es nur noch besser und effizienter zu werden. Wie du siehst, gibt es hier langsam keine neue Grundwerkzeuge mehr.  Wie weit bist du? Kommentiere unten den Artikel und lass uns über deinen Lernweg diskutieren!