Programmieren
«Qualifikationsverfahren allgemeinbildender Unterricht / Vertiefungsarbeit»
2013
Bösch Stefan
ZRL 7a
Abgabedatum: 25.11.2013
Vertiefungsarbeit Programmieren Stefan Bösch
1
Inhaltsverzeichnis
1 Einleitung............................................................................................................................................ 3
2 Was ist Programmieren? .................................................................................................................... 4
3 Programmiersprachen........................................................................................................................ 5
3.1 Was ist eine Programmiersprache? ............................................................................................ 5
3.2 Welche Programmiersprachtypen existieren? ........................................................................... 6
4 Schritt für Schritt ................................................................................................................................ 7
4.1 Warum Pascal? ........................................................................................................................... 7
4.2 Was ist Pascal? ........................................................................................................................... 8
4.3 Mein Vorgehen ......................................................................................................................... 10
5 Eigene Programme ........................................................................................................................... 11
Schlusswort ........................................................................................................................................... 15
Begriffserklärung ................................................................................................................................... 16
Eigenständigkeitserklärung ................................................................................................................... 17
Quellenverzeichnis ................................................................................................................................ 18
Abbildungsverzeichnis ........................................................................................................................... 19
Anhang .................................................................................................................................................. 20
Vertiefungsarbeit Programmieren Stefan Bösch
2
Warum beglückt uns die herrliche, das Leben
erleichternde, Arbeit ersparende Technik so
wenig? Die einfache Antwort lautet: weil wir
noch nicht gelernt haben, einen vernünftigen
Gebrauch von ihr zu machen. Im Kriege dient sie
dazu, daß wir uns gegenseitig verstümmeln. Im
Frieden hat sie unser Leben hastig und unsicher
gestaltet. Statt uns weitgehend von geisttötender
Arbeit zu befreien, hat sie die Menschen zu
Sklaven der Maschine gemacht, die meist mit
Unlust ihr eintöniges, langes Tagewerk
vollbringen und stets um ihr armseliges Brot
zittern müssen.1
Albert Einstein (1879 – 1955), dt. – amerik. Physiker
1 Vgl. http://www.zitate.de/autor/Einstein,+Albert?page=2
Vertiefungsarbeit Programmieren Stefan Bösch
3
1 Einleitung
Jeder hat es, ein technisches Hilfsmittel wie zum Beispiel ein Computer, Laptop, Handy oder
Smartphone. Wir sind in den letzten Jahren Sklaven der technischen Geräte geworden. Ein Leben
ohne Technik ist kaum noch vorstellbar. Trotzdem sind wir alle nur Anwender und wissen nicht, wie
man beispielsweise selber ein Programm programmiert. Urs Thomann, Berater für Raumplanung und
Städtebau, antwortete in einem Interview mit der HSR (Hochschule Rapperswil) auf die Frage: „Wenn
ich heute 20 Jahre alt wäre, würde ich …“ mit: „… mich nicht damit zufrieden geben,
Computertechnologien nur als Anwender zu beherrschen“. Mit diesem Wunsch ist er nicht alleine.
Schon seit vielen Jahren interessiere auch ich mich sehr für die Technik und möchte hinter die
Kulissen der Programmierung sehen und es verstehen können. Zudem möchte ich in Zukunft ein
Beruf in der IT-Branche ausüben. Deshalb habe ich mir vorgenommen, die Kunst des Programmierens
zu erlernen.
Im Allgemeinbildungsunterricht der Berufsschule BBZ ist es Pflicht, im siebten Semester während
zwei Monaten eine Vertiefungsarbeit zu schreiben. Das sah ich als Chance, um mich mit dem Thema
Programmieren auseinanderzusetzten. Die Leitfragen lauten wie folgt:
Wie viel Aufwand ist nötig, um eine Programmierhochsprache als Laie zu erlernen und wo
liegen die Schwierigkeiten?
Was ist eine Programmiersprache und wo liegt der Unterschied zwischen den vielen
Programmiersprachen?
Warum Pascal (Programmiersprache)?
Zu Anfang dieser Arbeit erkläre ich, was Programmieren und was eine Programmiersprache ist.
Im Anhang sind einige Begriffserklärungen, die für das Verständnis des Textes nützlich sein können,
aufgeführt. Die jeweiligen Wörter sind mit einem Stern* gekennzeichnet.
Alle Dateien, Programme und Skripte, die ich während dieser Arbeit benötigte/erstellte, sind auf
einer CD gespeichert, welche sich auf der letzten Seite befindet.
Vertiefungsarbeit Programmieren Stefan Bösch
4
2 Was ist Programmieren?2
Die Geschichte der heutigen Computer begann circa im Jahre 1100 v. Chr. im indochinesischen
Kulturraum mit der Erfindung des Abakus. Der Abakus, auch Rechenschieber genannt, ist ein
Rechenhilfsmittel mit dem man einfache Rechnungen lösen kann. Das heutige Pendant für den
Abakus ist der Taschenrechner. Ab diesem Zeitpunkt entwickelte sich diese Technologie weiter bis
zur Erfindung des heute bekannten PCs im 20. Jahrhundert.
Programmieren bedeutet, Computerprogramme zu erstellen. Dies umfasst das Schreiben (Codieren)
des Quellcodes* und das Erstellen der Benutzeroberfläche*. Danach wird das Programm in
Maschinensprache* übersetzt, meist unter Verwendung eines Compilers*. Jedoch gibt es auch
Sprachen die nicht übersetzt werden.
Für die Programmierung benötigt man einen Texteditor* und ein Compiler*. Jedoch ist das
Programmieren mit dazu passenden Programmen einfacher. Denn diese verfügen über zusätzliche
Funktionen wie Syntax-Highlighting* oder Debugger*, die einem die Arbeit sehr erleichtern.
Das Programmieren setzt kreatives, mathematisches und logisches Denken voraus.
Die Softwarequalität ist sehr wichtig. Die Hauptkriterien lauten:
Korrektheit
Robustheit
Wartbarkeit
Performance
Korrektheit Korrektheit bedeutet, dass der Quellcode* fehlerfrei ist und das Programm läuft wie gewünscht.
Robustheit Robustheit heisst, dass das entwickelte Programm auch auf anderen Computer mit unterschiedlicher Hardware funktioniert.
Wartbarkeit Bei der Korrektur von Fehler im Programm oder bei der Implementierung* neuer Befehle sollte es so einfach wie möglich sein dies zu bewerkstelligen. Zudem ist es wichtig, dass andere Personen, die den Quellcode* lesen, ihn ohne grosse Einarbeitungszeit verstehen. Dies wird durch einen klaren Programmierstil ermöglicht.
Performance Das entwickelte Programm soll leistungsschonend sein, damit es auch auf älteren, nicht so leistungsstarken, Geräten funktioniert.
2 Vgl. http://de.wikipedia.org/wiki/Programmierung
Vertiefungsarbeit Programmieren Stefan Bösch
5
3 Programmiersprachen
3.1 Was ist eine Programmiersprache?
Wie in der nicht digitalen Welt gibt es beim Programmieren viele verschiedene Sprachen um den
Quellcode* zu codieren. Alleine auf Wikipedia sind 283 verschiedene Programmiersprachen
aufgelistet.3 Die Sprachen unterscheiden sich durch ihre Syntax, Befehle, Programmaufbau,
Ausführungsgeschwindigkeit, Verbreitung und Anwendungsgebiet.
Syntax
Wie jede andere Sprache auf der Welt haben auch Programmiersprachen eine Art von Satzaufbau.
Ein Beispiel dazu im Kapitel 4.2: Was ist Pascal.
Befehle
Die Sprachen unterscheiden sich durch die Anzahl der verschiedenen Befehle und ihre Schreibweise.
Ein Beispiel dazu im Kapitel 4.2: Was ist Pascal.
Programmaufbau
Wie bei vielen Sprachen ist es möglich, den Satz unterschiedlich aufzubauen. So ist es auch bei den
Programmiersprachen. Es gibt diverse Arten, ein Programm/Befehlssatz aufzubauen.
Ein Beispiel dazu im Kapitel 4.2: Was ist Pascal.
Ausführungsgeschwindigkeit
Es gibt grosse Unterschiede in der Ausführungsgeschwindigkeit eines Programmes verglichen mit
demselben Programm, das in einer anderen Sprache geschrieben worden ist.
Programme, die zum Beispiel in der Assembly* Sprache geschrieben sind, haben beispielsweise eine
schnellere Laufgeschwindigkeit als jene in Java.
Verbreitung
Manche Sprachen werden öfters verwendet als andere. Während Programme die mit Objective-C
geschrieben sind, nur auf Applegeräten ausgeführt werden können, funktionieren hingegen
Programme, die mit Java geschrieben werden, auf den meisten Geräten.
Anwendungsgebiet
Obwohl die meisten Sprachen heutzutage für so ziemlich alles verwendet werden können
(Allrounder), gibt es doch noch Programmiersprachen mit spezialisiertem Anwendungsgebiet wie
zum Beispiel Grafik, Datenbanken, Mathematik oder Protokolle.
3 Vgl. http://de.wikipedia.org/wiki/Liste_von_Programmiersprachen
Vertiefungsarbeit Programmieren Stefan Bösch
6
3.2 Welche Programmiersprachtypen existieren?4
Es gibt verschiedene Arten von Programmiersprachen. Sie unterscheiden sich durch ihr
Anwendungsgebiet und ihren Aufbau.
Die bekanntesten sind:
Assembler* und Maschinensprache* Assembler* ist die schnellste Sprache, da man mit ihr direkt in der Maschinensprache* schreibt.
Prozedurale und Objektorientierte* Programmiersprachen (Hochsprachen)
In diesen Sprachen werden die meisten Programme geschrieben. Sie überzeugen durch das Erlauben
von maschinennaher Programmierung. Zudem können mit ihnen einfach grössere Projekte realisiert
werden.
Skriptsprachen
Die Skriptsprachen überzeugen durch ihre klar verständliche Syntax und einfacher Lernbarkeit.
Jedoch kommen diese Sprachen bei rechenintensiven Aufgaben schnell an ihre Grenzen.
Auszeichnungs- und Beschreibungssprachen, Style Sheets
Ihr Anwendungsbereich ist die Web-Programmierung*. Sie werden hauptsächlich in diesem Bereich
genutzt.
4 Vgl. http://www.hs-augsburg.de/mebib/fai/informatik/kerninformatik/programmiersprachen.html
Vertiefungsarbeit Programmieren Stefan Bösch
7
4 Schritt für Schritt
4.1 Warum Pascal?
Wenn man Programmieren lernen möchte, muss man zuerst herausfinden, welcher Sprachtyp für
einen geeignet ist. Hierzu konsultierte ich das Internet, um mir folgende Fragen zu beantworten:
Was für Programmiersprachen gibt es?
In welchen Sprachbereich möchte ich gehen?
Wie sinnvoll ist es für mich, eine Sprache aus diesem Bereich zu erlernen?
Schlussendlich entschied ich mich für den Bereich Prozedurale und Objektorientierte
Programmiersprachen. Der Grund dafür war, dass ich gerne Programme schreiben und mich auf eine
zukünftige Laufbahn in der IT-Branche vorbereiten möchte. Die anderen Bereiche sprachen mich
nicht an, da ich nicht sonderlich an Webseitenentwicklung interessiert bin und Assembler nicht
einsteigerfreundlich ist.
Der zweite Schritt ist es, sich für eine bestimmte Sprache zu entscheiden. Dafür begann ich im
Internet zu recherchieren, um herauszufinden, welche Sprache einsteigerfreundlich ist und für mich
auch in Zukunft noch einen Nutzen hervorbringen kann. Ich erstellte eine Tabelle, in der ich einige
Sprachen nach folgenden Kriterien bewertete.
Sprachen:
Java
Python
C
C++
Objective – C
Assembly
Visual Basic
Pascal (Object Pascal / Delphi)
Kriterien:
Einsteigerfreundlichkeit (zählt doppelt)
Ausführungsgeschwindigkeit (zählt doppelt)
Verbreitung
Businessprogrammierung
Spieleprogrammierung (zählt halb)
Kompatibilität
Vertiefungsarbeit Programmieren Stefan Bösch
8
Die Kritikpunkte Einsteigerfreundlichkeit und Ausführungsgeschwindigkeit zählen für mich doppelt da
es meine erste Programmiersprache ist, die ich lerne, und mir die Geschwindigkeit von Programmen
sehr wichtig ist. Der Punkt Spielprogrammierung gewichtete ich deutlich tiefer, da meine Interessen
bei der ersten Sprache nicht in diesem Bereich liegen.
Bewertet wurde mit einer Skala von 1 bis 10. Der Gewinner in einer Kategorie ist grün
hervorgehoben.
Tabelle 1 Vergleichtabelle verschiedener Sprachen (Diese Tabelle wurde vor der Vertiefungsarbeit erstellt)
Java Python C C++ Objective-C
Assembly Visual Basic
Pascal
Einsteiger-freundlich
4 (8) 10 (20) 5 (10)
3 (6) 4 (8) 1 (2) 6 (12) 9(18)
Ausführungs-geschwindigkeit
4 (8) 2 (4) 6 (12)
8 (16)
7 (14) 10 (20) 4 (8) 7 (14)
Verbreitung 10 6 4 10 7 3 8 3 Business-programmierung
6 4 7 8 8 5 8 8
Spiele-programmierung
8 (4) 9 (5) 5 (3) 10 (5)
6 (3) 4 (2) 5 (3) 7 (4)
Kompatibilität 9 6 8 9 4 10 5 8
Gesamt 45 45 44 54 44 42 44 55
Aufgrund dieser Tabelle entschied ich mich, als erstes Pascal zu lernen und dann später auf C++
umzusteigen.
4.2 Was ist Pascal?5
Die Sprache Pascal, benannt nach dem Mathematiker Blaise Pascal, ist eine prozedurale
Programmiersprache, die im Jahre 1972 an der ETH Zürich von Niklaus Wirth erfunden wurde. Die
Sprache wurde entwickelt, um die strukturierte Programmierung zu lehren. Sie ist eine
Weiterentwicklung von Algol 60 und lehnt sich in ihrer Syntax stark an die englische Grammatik.
Dadurch wird die Lesbarkeit des Quellcodes* verbessert und der Einstieg für Programmierlaien
erleichtert. Die Sprache fand ihren Weg in die professionelle Programmierung dank der
Weiterentwicklung durch die Firma Bordland zu Object Pascal. Mit Hilfe von Object Pascal ist es
möglich, objektorientiert* zu programmieren. Die Sprache zeichnet sich vor allem durch ihre
Typstrenge*, hohe Fehlersicherheit und kostenlosen Compiler* (Free Pascal, GNU Pascal, Lazarus)
aus und erlangte dadurch grosse Beliebtheit im Informatikunterricht und bei Hobbyprogrammierer.
5 Vgl. http://de.wikipedia.org/wiki/Pascal_(Programmiersprache)
Vertiefungsarbeit Programmieren Stefan Bösch
9
Pascal Assembly*
Abb. 1 Programmquelltext in Pascal Abb. 2 Programmquelltext in Assembly
Dies ist ein Vergleich zwischen den beiden Programmiersprachen Pascal (links) und Assembly
(rechts). Das hier geschriebene Programm öffnet ein Konsolenfenster* und gibt den Text „Hallo
Welt“ aus. Bei beiden Programmen ist das Resultat das selbe, jedoch sieht man in diesem Beispiel,
dass es viel schwieriger ist, eine Anwendung in Assembly zu schreiben.
Vertiefungsarbeit Programmieren Stefan Bösch
10
4.3 Mein Vorgehen
Als ich mich entschieden habe, welche Sprache ich erlernen möchte, begann ich mich genauer über
die Sprache zu informieren und Lernskripte zum Lernen zu suchen. Auf Wikibooks.org (eine Lern-
Community für Themen wie Naturwissenschaften und Technik, Sozialwissenschaft, Kultur,
Mathematik, Informatik) fand ich zwei Skripte zum Thema Pascal erlernen („Programmierkurs
Delphi“ und „GNU Pascal“)
Nachdem ich mir beide angesehen habe, beschloss ich das Skript „Programmierkurs Delphi“ als
Lernanleitung zu nehmen und nebenbei das „GNU Pascal“ Skript zu lesen. Um mir eine Übersicht zu
verschaffen, erstellte ich anhand des Inhaltsverzeichnis eine Themenleiste und unterteilte sie in die
folgenden Bereiche:
Grundlagen
Fortgeschritten
Für diese Vertiefungsarbeit schenkte mir ein Mitarbeiter seinen fünf-jährigen Lapto, den er sowieso
entsorgen wollte. Ich setzte ihn neu auf, schrieb und programmierte im Verlaufe der gesamten VA
auf diesem Laptop.
Mein Plan beinhaltete zuerst das Kapitel Grundlagen zu erlernen, danach die Dokumentation zu
schreiben und mich dann dem Thema Fortgeschritten zu widmen.
Ich begann vorzu jedes Kapitel aus dem Themenbereich Grundlagen zu studieren und praktisch
anzuwenden. Manche Kapitel strich ich aus der Liste aufgrund der Tatsache, dass sie entweder nicht
für Anfänger geeignet sind oder weil von ihnen im Internet abgeraten wird.
Befehle, welche ich in den Skripts nicht fand, recherchierte ich im Internet.
Nach ungefähr 20 Stunden Lernen innerhalb von zwei Wochen schloss ich das Thema Grundlagen ab
und begann, die Dokumentation zu schreiben. Während diesem Lernprozess investierte ich täglich
circa eine Stunde zum Lesen und Austesten von Funktionen. Manche Kapitel waren allerdings sehr
schwierig zu verstehen.
Vertiefungsarbeit Programmieren Stefan Bösch
11
5 Eigene Programme
Im Verlaufe des Lernprozesses schrieb ich ein Programm, um ein paar Befehle in Kombination zu
benutzen. Das Programm dient zur Berechnung des Anhaltewegs eines PKWs. Die erste Version vom
04.10.2013 sah wie folgt aus. Erklärungen des Quellcodes stehen in geschweiften Klammern und sind
grün hervorgehoben.
Abb. 3 Quelltext des Programms: Anhalteweg1.exe
In der ersten Version war es nur möglich, den Anhalteweg bei nasser Fahrbahn und bei fixer
Reaktionszeit zu berechnen.
program Anhalteweg1; {notwendiger Programmkopf mit Programmname}
var {Definition der Variablen}
v, b, r, a, q: Single; {Definieren der Variablen v, b, r, a und q als Gleitkommazahl}
begin {Beginn des Kommandoblocks}
Writeln ('Bitte geben Sie die Geschwindigkeit des Fahrzeuges ein:'); {Ausgabe von Text}
Readln(v); {Aufnahme der Eingabe in Variable v, Bestätigen mit Enter}
r := v / 3.6; {r gleich v durch 3.6}
q := v / 10; {q gleich v durch 10}
b := q * q; {b gleich q2}
a := r + b; {a gleich r + b}
Writeln ('Der Anhalteweg beträgt: ', a:0:2,'m'); {Ausgabe von Text mit Resultat auf Stellen nach dem Komma angezeigt}
Readln; {Eingabebefehl als Trick um das Fenster offen zu behalten}
end. {Beenden des Programms}
Vertiefungsarbeit Programmieren Stefan Bösch
12
Bei der zweiten Version vom 17.10.2013 habe ich die Funktionen hinzugefügt, um den
Strassenzustand zu wählen und die Reaktionszeit bei Bedarf manuell anzupassen. Zusätzlich wird nun
der Anhalteweg differenziert in Reaktionsweg und Bremsweg angezeigt. Die Änderungen sind rot
hervorgehoben:
Abb. 4 Quelltext des Programms: Anhalteweg2.exe
program Anhalteweg2;
Label {Definieren von einem Label als Sprungpunkt im Quellcode}
10;
var
v, b, r, a, z, q, c, d: Single;
s: String; {Definieren der Variable von s als Zeichenkette}
begin
d := 1; {d gleich 10}
10: {Sprungpunkt 10}
Writeln ('Welche Bedingung (Fahrbahn)? (Nasse, Trockene, Optimale, Reaktionszeit):'); {Ausgabe von Text}
Readln(s); {Aufnahme der Eingabe in Variable s, Bestätigen mit Enter}
if s = 'n' then {Wenn Variable s n ist beginne folgenden Kommandoblock}
begin {Begin des Kommandoblocks}
z := 1; {z gleich 1}
end; {Ende des Kommandoblocks}
if s = 't' then {Wenn Variable s t ist beginne folgenden Kommandoblock}
begin {Begin des Kommandoblocks}
z := 0.75; {z gleich 0.75}
end; {Ende des Kommandoblocks}
if s = 'o' then {Wenn Variable s o ist beginne folgenden Kommandoblock}
begin {Begin des Kommandoblocks}
z := 0.5; {z gleich 0.5} end; {Ende des Kommandoblocks} if s = 'r' then {Wenn Variable s r ist beginne folgenden Kommandoblock}
begin {Begin des Kommandoblocks}
Writeln ('Bitte geben Sie die Reaktionszeit ein (In Sekunden)<',d:0:2,'>:'); {Ausgabe von Text}
Readln(d); {Aufnahme der Eingabe in Variable d, Bestätigen mit Enter}
goto 10; {Gehe zu Sprungpunkt 10}
end; {Ende des Kommandoblocks}
Writeln ('Bitte geben Sie die Geschwindigkeit des Fahrzeuges ein:');
Readln(v);
c := 3.6; {c gleich 3.6}
r := v / c * d; {r gleich v durch c mal d}
q := v / 10;
b := q * q * z; {b gleich q2 mal z}
a := r + b;
Writeln ();
Writeln ('Der Reaktionsweg beträgt: ', r:0:2,'m.'); {Ausgabe von Text und Variable r}
Writeln ('Der Bremswegweg beträgt: ', b:0:2,'m.'); {Ausgabe von Text und Variable b}
Writeln ('Der Anhalteweg beträgt: ', a:0:2,'m.');
Readln;
end.
Vertiefungsarbeit Programmieren Stefan Bösch
13
In der dritten Version vom 22.10.2013 habe ich einen Befehl hinzugefügt, um das Drücken der
Entertaste nach der Eingabe des Strassenzustandes zu ersparen. Jedoch beinhaltete diese Version
noch einen Fehler bei der Eingabe der manuellen Reaktionszeit. Aus diesem Grund erstellte ich ein
Update auf die Version 3.1. Die Änderungen von Version 2 zu 3.1 sind rot hervorgehoben.
Abb. 5 Quelltext des Programms: Anhalteweg3.exe
program Anhalteweg3_1;
uses {Hinzufügen neuer Befehlssätze}
crt; {Befehlssatz für Tasteneingabe
Label
10;
var
v, b, r, a, z, q, c, d: Single;
s: char; {Definieren der Variablen von s als einzelnes Zeichen}
begin
d := 1;
10:
Writeln ('Welche Bedingung (Fahrbahn)? (Nasse, Trockene, Optimale, Reaktionszeit):');
s := Readkey; {Variable s gleich warten auf Tasteneingabe}
if s = 'n' then
begin
z := 1;
end;
if s = 't' then
begin
z := 0.75;
end;
if s = 'o' then
begin
z := 0.5;
end;
if s = 'r' then
begin
Writeln ('Bitte geben Sie die Reaktionszeit ein (In Sekunden)<',d:0:2,'>:');
Readln(d);
goto 10;
end;
Writeln ('Bitte geben Sie die Geschwindigkeit des Fahrzeuges ein:');
Readln(v);
c := 3.6;
r := v / c * d;
q := v / 10;
b := q * q * z;
a := r + b;
Writeln ();
Writeln ('Der Reaktionsweg beträgt: ', r:0:2,'m.');
Writeln ('Der Bremswegweg beträgt: ', b:0:2,'m.');
Writeln ('Der Anhalteweg beträgt: ', a:0:2,'m.');
Readln;
end.
Vertiefungsarbeit Programmieren Stefan Bösch
14
Wenn man diesen Quelltext nun durch einen Compiler* in Maschinensprache* übersetzten lässt und
es ausführt, sieht das wie folgt aus.
Abb. 6 Bildschirmfoto von ausgeführten Anhaltewegprogramm
Um den Strassenzustand zu wählen, betätigt man die entsprechende Taste (Anfangsbuchstabe) auf
der Tastatur, also N für nass, T für trocken und O für optimal.
Abb. 7 Bildschirmfoto von ausgeführten Anhaltewegprogramm mit manueller Reaktionszeiteingabe
Drückt man R für Reaktionszeit, kann man diese manuell bestimmen.
Auf diesem Bild sieht man, wie die Reaktionszeit manuell von 1 auf 1.5 Sekunden eingestellt und
danach der Anhalteweg bei trockener Strasse bei 50 km/h berechnet wird.
Vertiefungsarbeit Programmieren Stefan Bösch
15
Schlusswort
Ich blicke mit Freude auf den Anfang der Arbeit zurück. Es war die richtige Entscheidung das
Programmieren zu lernen und dies zum Thema meiner VA zu bestimmen. Ich hatte viel Spass und
werde es wohl auch hoffentlich in der Zukunft haben, denn ich werde diese Tätigkeit weiterführen.
Das grösste Problem war bedauerlicherweise das Schreiben der Dokumentation, dadurch verlor ich
sehr viel Zeit. Obwohl ich während des geplanten Zeitraums nicht so weit gekommen bin wie erhofft,
so möchte ich die Leitfrage "Wie viel Aufwand ist nötig um eine Programmierhochsprache als „Laie“
zu erlernen und wo liegen die Schwierigkeiten?" trotzdem beantworten. Die Problematik liegt jedoch
beim Wort "erlernen", da es nicht klar definiert ist. Manche sagen, dass man Programmieren kann,
wenn man die objektorientierte Programmierung und den "richtigen" Programmierstil beherrscht.
Jedoch gibt es auch andere, die behaupten, dass man erst nach mehreren Jahren eine Sprache
beherrscht. Nach meinem Ermessen benötigt man circa 50 Stunden, um die Grundlagen und die
objektorientierte Programmierung zu erlernen. Die Sicherheit beim Schreiben kommt dann mit der
Routine.
Die Schwierigkeiten lagen beim Verständnis mancher Themen, da es ein ziemlich kompliziertes
Thema ist. Jedoch findet man im Internet sehr schnell Hilfe.
Ich bin überzeugt, dass ich mir durch das Lernen einer Programmiersprache denn Weg in einen IT-
Beruf erleichtern konnte.
Ich bedanke mich bei all jenen, die mich während dieser Arbeit unterstützt haben.
Vertiefungsarbeit Programmieren Stefan Bösch
16
Begriffserklärung
Quellcode = Der für den Menschen in einer Programmiersprache
geschriebene lesbare Text, der danach vom
Computer ausgeführt wird
Benutzeroberfläche = Das für den Benutzer sichtbare Programm
Compiler = Wird zur Übersetzung des Quellcodes in
Maschinensprache benutzt.
Texteditor = Ein Programm zum Schreiben von Text wie zum
Beispiel unter Windows der Editor oder Notepad++
oder unter Mac das Programm Textedit
Syntax-Highlighting = Zur Hervorhebung von Schlüsselwörtern im
Quellcode
Debugger = Zur Fehlerüberprüfung des Quellcodes
Implementierung = Hinzufügen von Befehlen und Algorithmen
Assembler = Eine leicht abgewandelte Version der
Maschinensprache
Maschinensprache = Die Sprache, die vom Computer direkt ausgeführt
werden kann
Web-Programmierung = Programmieren von Webseiten und
Internetprogrammen
objektorientiert = Wird zur Strukturierung des Quellcodes benutzt.
Dadurch verliert man auch bei grossen Projekten
nicht den Überblick.
Typstrenge = Jede Variable muss klar deklariert sein.
Konsolenfenster = Ein Textfenster des Betriebssystem
Abb. 8 Das Konsolenfenster von Windows
Vertiefungsarbeit Programmieren Stefan Bösch
17
Eigenständigkeitserklärung
Der Verfasser bestätigt mit seiner Unterschrift, dass die Arbeit selbstständig verfasst und in
schriftlicher Form gebracht worden ist, dass die Mitwirkung anderer Personen auf Beratung und
Korrekturlesen beschränkt hat und dass alle verwendeten Unterlagen und Gewährspersonen
aufgeführt sind.
November 2013, Stefan Bösch
Vertiefungsarbeit Programmieren Stefan Bösch
18
Quellenverzeichnis
http://www.zitate.de/autor/Einstein,+Albert?page=2
http://de.wikipedia.org/wiki/Programmierung
http://de.wikipedia.org/wiki/Liste_von_Programmiersprachen
http://www.hs-augsburg.de/mebib/fai/informatik/kerninformatik/programmiersprachen.html
http://de.wikipedia.org/wiki/Pascal_(Programmiersprache)
Vertiefungsarbeit Programmieren Stefan Bösch
19
Abbildungsverzeichnis
Titelbild http://www.carlosnuel.com/wp-content/uploads/2013/09/codigo-fuente-portada.jpeg
Abb. 1, 2 http://de.wikipedia.org/wiki/Liste_von_Hallo-Welt-
Programmen/Höhere_Programmiersprachen
Abb. 3 - 5 Selbstgeschriebener Quelltext
Abb. 6 - 8 Bildschirmfoto
Vertiefungsarbeit Programmieren Stefan Bösch
20
Anhang
Vertiefungsarbeit Programmieren Stefan Bösch
21
Arbeitsprotokoll
Arbeitstyp Datum Uhrzeit Zeit in h
Motivation Arbeiten Nächster Schritt Offene Fragen Sonst. Bemerkungen
1 28.09.2013 8:00 - 8:30
0.5 9 Programmkopf erstellen Befehle: Readln Writeln Typen: Char String Integer Single, Double, … Boolean Algemeine Befehle: addition subrtraktion multiplikation division Wurzel ziehen (sqrt)
Umwandlung von Single zu Integer Pointer und Zeiger Was ist Typumwandlung
Anzeige der Zahlen (Single), Umwandlung von Single zu Integer
Grosse Motivation damit zu beginnen Grosser Motivationsanstieg bei schnellem Vorankommen
2 30.09.2013 8:00 - 11:45
3.75 5 Fragen definieren Abgabedatum bestimmen Erstes Ziel setzten Arbeitsprotokoll erstellen
Weiter Ziele deinieren Rahemnthemen definieren
Erster Termin: 21.10.13 Zweiter Termin: 11.11.13 Abgabetermin: 25. 11. 13 Präsentation: 13./20./27. Januar
1 30.09.2013 17:00 - 17:30
0.5 7 Umwandlung von Single zu Integer (Trunc) Typumwandlung Liste gesucht und gefunden Anzeige der Zahlen (Single) (ohne Erfolg)
Pointer und Zeiger Anzeige der Zahlen
Anzeige der Zahlen (Single)
Grosse Motivation bei Problemfindung jedoch einen kleinen Dämpfer bei Misserfolg.
Vertiefungsarbeit Programmieren Stefan Bösch
22
1 04.10.2013 01:00 - 02:30
1.5 9 Anzeige der Zahlen Auswerten von Eingaben(erfolgreich)erstes Programm schreiben: Anhalteweg1.exe (Zur Berechnung des Anhalteweges von einem Fahrzeug auf nasser Fahrbahn)
Grosse Motivation das Problem anzugehen und das erste Programm zu schreiben. Extremer Motivationsschub bei erfolgreicher fertigstellung und Ausführung des ersten Programm.
5 04.102013 - 13.10.2013
Ferien "Arbeitsunterbruch"
1 15.10.2013 20:00 - 21:00
1 6 Skriptabschnitt lesen: Verzweigung, Schleifen
Anwenden bei Anhaltewegprogramm
Grosse Motivation nach den Ferien weiter daran zu arbeiten.
1 16.10.2013 21:00 - 21.45
0.75 8 Lernprogramm schreiben: Zähler.exe (für "repeat until" Schleife)
Grosse Motivation um etwas auszuprobieren.
1 17.10.2013 23:30 - 01:00
1.5 7 Neuer Befehl: Goto Anwendung von Verzweigungen Programm schreiben: Anhalteweg2.exe (Erweiterung des ersten Programms: Unterschiedliche Strassenzustände: nass, trocken, optimal Veränderung der Reaktionszeit)
Problem beheben bei manueller Reaktionszeit Eingabe
Starker Motivationsansteig bei erster "erfolgreicher" Ausführung des Programms Kleiner Motivationsdämpfer bei entdeckung des Problems mit der manuellen Eingabe der Reaktionszeit
1 19.10.2013 0:00 - 0:45
0.75 8 Problem beheben bei manueller Reaktionszeit EingabeNeue Funktion: Anzeige der momentanen Reaktionszeit bei manueller Reaktionszeiteingabe.
Starke Motivation um das Problem zu lösenStarker Motivationsanstieg bei erfolgreicher Problemlösung und bei implementierung der neuen Funktion.
Vertiefungsarbeit Programmieren Stefan Bösch
23
1 21.10.2013 8:30 - 11:45
3.25 7 Rechechieren: Was ist ein Zeiger / Pointer (Es wird Anfängern abgeraten damit zu programmieren, d. h. der nächste Schritt vom 30.9.13 wird bis auf weiteres vertagt) Kapitel Konstanten lesen und anhand von Testprogramm ausprobieren. Kapitel Boolean, Verzweigung mit Boolean. Kapitel Schleifen lesen und anhand von Testprogrammen ausprobieren (Vorzeitiger Abbruch einer Schleife verschoben).
Zu Anfang mittelmässige Motivation (Montagmorgen) Starker Motivationsanstieg bei "Arbeitsbeginn". Kleiner Dämpfer bei Problem mit Konstanten. Jedoch war der nur von kurzer Dauer da das Problem schnell gelöst werden konnte.
1 21.10.2013 22:00 - 22:30
0.5 8 Fehlendes Skriptkapitel Varianten im Internet nachlesen. (Vom Thema wird abgeraten da es ein unschöner Programmierstil ist, deshalb streiche ich dieses Thema aus dem "Lernprogramm")
Zu Anfang gab es einen Motivationsdämpfer da ich das Thema / denn Sinn Varianten nicht verstanden habe. Kleiner Motivationsanstig bei Entdeckung im letzten Abschnitt das es ein unschöner Programmierstil ist.
5 22.10.2013 20:00 - 21:00
1 1 / 9 Free Pascal neu installieren aufgrund der Programmabstürzen bei den Befehlen: program und Writeln -> Ohne Erfolg Systemwiederherstellung auf den 18.10.13 -> Erfolgreich
Extremer Motivationsdämpfer bei Entdeckung des Problems und bei erfolglosem Versuch das Programm neu zu installieren. Extremer Motivationsschub bei Lösung des Problems mit der Systemwiederherstellung.
Vertiefungsarbeit Programmieren Stefan Bösch
24
1 22.10.2013 21:00 - 22:15
1.25 8 Neuer Befehl: Readkey Programm schreiben: Anhalteweg3.exe (Erweiterung: Entertaste für die Auswahl des Strassenzustand nicht mehr nötig.)
Wie zur gleichen Zeit Readkey und Readln?
Grosse Motivation nach Lösung des Problems. Motivationsschub nach Befehlimplementierung.
1 23.10.2013 20:45 - 22:15
1.5 7 Skripktkapitel Prozeduren und Funktionen lesen.
Anwenden im Beispiel Ausgabe call by reference
Sehr kompliziertes Kapitel
1 24.10.2013 22:15 - 23:30
1.25 8 Prozedur mit globalen Werten testen in Anwendungsbeispiel.Programm schreiben:Taschenrechner.exe (Taschenrechner mit Prozeduren, Verzweigungen und Readkey)
weitere Prozeduren testen
Ausgabe call by reference
Grosse Motivation die neuen Befehle auszuprobieren.
1 28.10.2013 08:00 - 11:30
3.5 7 Weitere Prozeduren testen, Die offene Frage "Ausgabe call by reference" wurde durch das testen der weiteren Prozeduren beantwortet. Kapitel "Records" lesen und ausprobieren. Kapitel "Der "richtige" Programmierstil Rechechieren
Kapitel "Aufzählung", "Arrays" lesen und anwendem um damit das Überkapitel Grundlagen abzuschliessen.
Grosse Motivation nach Pause (Aufgrund zu wenig Zeit) um damit weiter zu machen. Trotz kompliziertem Kapitel starke Motivation.
1 28.10.2013 17:30 - 18:15
0.75 8 Kapitel "Aufzählungen" lesen und anwenden. Kapitel "Arrays" beginnen.
Kapitel "Arrays" abschliessen.
Grosse Motivaion das Überkapitel "Grundlagen" zu beenden
1 28.10.2013 20:00 - 21:00
1 8 Kapitel "Arrays" abschliessen. Dokumentation beginnen
Grosse Motivaion das Überkapitel "Grundlagen" zu beenden
Vertiefungsarbeit Programmieren Stefan Bösch
25
2 30.10.2013 16:00 - 20:00
4 6 Einleitung schreiben, Kapitel Was ist Programmieren) schreiben, Kapitel Programmiersprache beginnen
Kapitel Programmiersprache fertig schreiben
Vorwort und Einleitung getrennt?
Geringe Motivation da ich das Programmieren einstellen muss um mich Komplett auf die Dokumentation konzentrieren zu können.
2 31.10.2013 17:00 - 20:00
3 5 An Kapitel Programmiersprache weiter schreiben
Kapitel Programmiersprache fertig schreiben
Vorwort und Einleitung getrennt?
Immer noch geringe Motivation die Dokumentation zu schreiben. Motivationsdämpfer bei schlependem vorankommen.
2 01.11.2013 16:00 - 18:15
2.25 2 Kapitel Programmiersprache fertig schreiben
Kapitel Vorgehen / Erkentnisse schreiben
Vorwort und Einleitung getrennt?
Geringe Motivation aufgrund Todesfall.
2 02.11.2013 8:00 - 8:30
0.5 6 Bei Kapitel Programmiersprache Vergleich zwischen Pascal und Assembly anfügen, Kapitel Vorgehen beginnen
Kapitel Vorgehen schreiben
Gute Motivation aufgrund des schnellen Vorankommens
2 02.11.2013 10:00 - 11:00
1 6 Kapitel Vorghen schreiben Kapitel eigene Programme schreiben
Gute Motivation aufgrund des schnellen Vorankommens
2 02.11.2013 13:00 - 13:30
0.5 6 Kapitel eigene Programme beginnen
Gute Motivation aufgrund des schnellen Vorankommens
2 02.11.2013 15:30 - 17:00
1.5 6 Kapitel eigene Programme schreiben
Gute Motivation aufgrund des schnellen Vorankommens
2 04.11.2013 8:00 - 11:45
3.75 3 Dokumentation lesen, Fehler suchen und unklare Begriffe suchen um sie dann noch zu erklären.
Sehr unkonzentriert
Vertiefungsarbeit Programmieren Stefan Bösch
26
2 07.11.2013 10:00 - 01:30
3.5 6 Fehler aus eigener Korrektur korrigieren und unklare Begriffe erklären.
Kapitel: Vorgehen korrigierenDanach an externe Person zur Korrektur geben (Michelle / Angela)
Geringe Motivation noch zu später Stunde an der Dokumentation zu schreiben. Zudem geringe Motivation aufgrund von Stress bei der Arbeit und sonstigen schulischen Projekten. Jedoch "muss" ich wieder weiter arbeiten da nicht mehr viel Zeit übrig bleibt und ich die Dokumentation am 8.11.2013 an externe Person zur Korrektur geben möchte und ich nun mehrere Tage nicht mehr daran gearbeitet habe.
2 08.11.2013 19:00 - 20:30
1.5 6 Kapitel Vorgehen korrigieren Dokumentation zur Korrektur geben.
Geringe Motivation nach sehr stressigem Tag.
2 09.11.2013 16:00 - 22:00
6 5 Korrektur, Formatierung, Verzeichnisse erstellen
Korrektur von Michelle ausführen
Angela korriegert es in 7 Tagen
2 10.11.2013 23:00 - 1:45
2.75 6 Korrektur Arbeit A. Derungs zeigen, Schlusswort schreiben
Bin froh die erste Korrektur hinter mir zu haben
2 11.11.2013 8:15 - 11:30
3.25 6 Titelblatt erstellen, Checkliste, mit A. Derungs Besprechen
Schlusswort schreiben, Quellenverzeichnis, Kapitel Eigene Programme überdenken, Fazit erstellen
Sehr müde
2 12.11.2013 22:45 - 00:00
1.25 5 Quellenverzeichnis erstellen, Schlusswort beginnen
Schlusswort zu Ende schreiben, Kapitel Eigene Programme überdenken, Anhalteweg3.1.exe in Dokumentation implementieren
geringe Motivation aufgrund Krankheit und geringer verbleibender Zeit
Vertiefungsarbeit Programmieren Stefan Bösch
27
2 14.11.2013 21:30 - 23:30
2 7 Kapitel eigene Programme überdenken, Kommentare/Erklärungen zu Quellcode einfügen, Anhalteweg3.exe durch Anhalteweg3.1.exe
Schlusswort zu Ende schreiben, Dokumentation an Angela zur Korrektur geben
Ausgeruht nach einem Tag Pause von der Arbeit
2 15.11.2013 22:00 - 22:45
0.75 8 Schlusswort zu Ende schreiben Dokumentation an Angela zur Korrektur geben
Grosse Motivation denn der 1. Stand der Dokumentation ist abgeschlossen
2 18.11.2013 8:00 - 11:45
3.75 6 Dokumentation lesen und Fehler suchen Sicherung und bearbeiten der Daten für erstellung von CD Fragen stellen und besprechen mit A. Derungs
Fehler zuhause korrigieren Korrektur durch Angela Dokumentation korrigieren CD brennen Arbeit drucken und binden
Gute Motivation da ich mit der Arbeit schon zimlich weit bin. Jedoch bin ich unzufrieden mit meiner Arbeit, jedoch bin ich das immer bei Arbeiten von mir.
2 18.11.2013 20:00 - 21:30
1.5 6 Fehler zuhause korrigieren Korrektur durch Angela Dokumentation korrigieren Dokumentation in CD Ordner CD brennen Arbeit drucken und binden
Motiviert die Arbeit zu beenden
2 19.11.2013 20:30 - 00:45
4.25 6 Dokumentation korrigieren mit Angela
Dokumentation in CD Ordner CD brennen Arbeit drucken und binden
Motiviert die Arbeit zu beenden
2 20.11.2013 18:15 - 02:15
8 6 Dokumentation korrigieren mit Angela
Dokumentation in CD Ordner CD brennen Arbeit drucken und binden
Motiviert die Arbeit zu beenden
Vertiefungsarbeit Programmieren Stefan Bösch
28
CD
Inhalt:
1. Arbeitsmethodikdokumente
2. Dokumentation
3. Eigene Programme
4. Entwicklungsprogramme
5. Lernskripte