Imit03b N01

Das Studienheft und seine Teile sind urheberrechtlich geschützt.
Jede
Nutzung in anderen als den gesetzlich zugelassenen Fällen ist nicht
erlaubt und bedarf der vorherigen schriftlichen Zustimmung des
Rechteinhabers. Dies gilt insbesondere für das öffentliche Zugänglich-
machen via Internet, Vervielfältigungen und Weitergabe. Zulässig ist
das Speichern (und Ausdrucken) des Studienheftes für persönliche
Zwecke.
$
IMIT03B
Informatik
Einführung in die Programmierung
0320N01
Christoph Siebeck
©
Werden Personenbezeichnungen aus Gründen der besseren Lesbarkeit nur in der männlichen oder
weiblichen Form verwendet, so schließt dies ausdrücklich alle anderen Geschlechtsidentitäten ein.
Falls wir in unseren Studienheften auf Seiten im Internet verweisen, haben wir diese nach sorgfältigen
Erwägungen ausgewählt. Auf die zukünftige Gestaltung und den Inhalt der Seiten haben wir jedoch
keinen Einfluss. Wir distanzieren uns daher ausdrücklich von diesen Seiten, soweit darin rechtswid-
rige, insbesondere jugendgefährdende oder verfassungsfeindliche Inhalte zutage treten sollten.
© SGD, 20.04.23, Rothe, Christof (1092381)
Informatik
IMIT03B
Einführung in die Programmierung

0320N01
Inhaltsverzeichnis
Einleitung ....................................................................................................................... 1
1 Warum Computer programmiert werden müssen .............................................. 3

1.1 Eine kleine Geschichte der Automaten ..................................................... 4
Zusammenfassung .................................................................................................... 6
2 Wie Computer programmiert werden ................................................................... 8

2.1 Vom Assembler zur Hochsprache ............................................................. 8
2.2 Compiler und Interpreter ........................................................................... 14
2.3 Die Objektorientierung ............................................................................... 19
2.4 Einzelne Programmiersprachen ................................................................. 21
2.5 Spezielle Entwicklungswerkzeuge ............................................................. 25
3 Programmstrukturen ............................................................................................... 29
3.1 Datentypen und Variablen ......................................................................... 29
3.2 Folge ............................................................................................................. 30
3.3 Auswahlen ................................................................................................... 31
3.4 Wiederholungen .......................................................................................... 32
3.5 Ereignisverarbeitung ................................................................................... 35
4 Entwicklung von Software ...................................................................................... 38

4.1 Die Phasen der Software-Entwicklung ..................................................... 38
4.2 Das Lösen von Problemen .......................................................................... 42
4.3 Das Entwickeln von Algorithmen ............................................................. 43
Schlussbetrachtung ........................................................................................................ 51
0320N01
IMIT03B
Inhaltsverzeichnis
Anhang
A. Lösungen zu den Aufgaben zur Selbstüberprüfung ................................. 52
B. Glossar .......................................................................................................... 54
C. Literaturverzeichnis ..................................................................................... 62
D. Abbildungsverzeichnis ................................................................................ 63
E. Tabellenverzeichnis ..................................................................................... 64
F. Codeverzeichnis ........................................................................................... 65
G. Medienverzeichnis ....................................................................................... 66
H. Sachwortverzeichnis .................................................................................... 67
I. Einsendeaufgabe .......................................................................................... 69
IMIT03B
Einleitung
IMIT03BInformatik1219N01
In diesem Studienheft werden Sie sich mit dem Programmieren von Computern beschäf-
tigen. Sie erfahren unter anderem, warum Computer programmiert werden müssen und
lernen verschiedene Programmiersprachen im Überblick kennen. Außerdem stellen wir
Ihnen das grundsätzliche Vorgehen bei der Programmierung vor.
Im Einzelnen lernen Sie in diesem Studienheft:
• warum Computer programmiert werden müssen,
• was ein Programm ist,
• wie die ersten Automaten und Computer programmiert wurden,
• was die Maschinensprache ist,
• was ein Assembler ist,
• was einen Assembler und Hochsprachen unterscheidet,
• welche Unterschiede zwischen einem Compiler und einem Interpreter bestehen,
• was Skriptsprachen sind,
• was sich hinter der Objektorientierung verbirgt,
• welche speziellen Programmierwerkzeuge neben Programmiersprachen eingesetzt
werden,
• aus welchen Strukturen ein Programm grundsätzlich besteht,
• was die Ereignisverarbeitung ist,
• in welchen Phasen Software grundsätzlich entwickelt wird,
• welche Techniken für die Lösung von Problemen eingesetzt werden können und
• wie Algorithmen entwickelt werden.
Hinweis:
Im weiteren Verlauf werden Sie sich detailliert mit einer Programmiersprache
beschäftigen – nämlich mit Python.
Christoph Siebeck
IMIT03B 1
2 IMIT03B
1 Warum Computer programmiert werden müssen

In diesem Kapitel lernen Sie, warum Computer programmiert werden müssen.
Computer sind heute aus dem Alltag nicht mehr wegzudenken. Sie werden zum Schrei-
ben von Briefen und zum Erstellen von Rechnungen eingesetzt, steuern aber auch Fab-
riken und Atomkraftwerke. Viele Dinge, die heute einen wesentlichen Teil des mensch-
lichen Miteinanders bestimmen, sind allein durch den Computer möglich geworden –
zum Beispiel das Internet. Kaum eine andere Maschine hat so entscheidenden Einfluss
auf unser Leben.
Überlegen Sie einmal …

Wo liegen die Gründe für den Erfolg des Computers?
Entscheidend für die weite Verbreitung sind vor allem vier Punkte:
1. Computer arbeiten sehr schnell.
2. Computer arbeiten sehr genau.
3. Computer können gigantische Datenmengen verarbeiten.
4. Computer sind sehr flexibel.
Schauen wir uns dazu ein Beispiel im direkten Vergleich zwischen Mensch und Compu-
ter an.
Für einen Computer ist es kein Problem, mehrere Tausend Adressen nach Nachnamen
zu sortieren. Je nach Leistungsfähigkeit des Rechners ist die Sortierung innerhalb kür-
zester Zeit erledigt. Fehler macht der Computer dabei nicht – vorausgesetzt, die Arbeits-
anweisungen stimmen.
Ein Mensch dagegen würde für das Sortieren Stunden oder sogar Tage brauchen. Mit
ziemlicher Sicherheit unterliefen ihm dabei auch Fehler – allein schon, weil die Konzen-
tration nachlässt.
Für den Computer spielt es auch keine Rolle, ob er mehrere Tausend, mehrere Millionen
oder mehrere Milliarden Adressen sortieren soll. Es dauert lediglich länger, bis das
Ergebnis vorliegt. Ein einzelner Mensch würde sich dagegen wahrscheinlich weigern,
wenn er einen Riesenberg mit mehreren Milliarden Karteikarten sortieren sollte.
Dem Computer ist es auch egal, ob er die Adressen erst nach dem Nachnamen sortieren
soll und direkt danach in einem zweiten Durchlauf nach der Postleitzahl. Ein Mensch
dagegen würde wohl streiken, wenn er nach getaner Arbeit sofort wieder von vorne an-
fangen soll.
Und: Die Maschine, die gerade noch Daten sortiert hat, kann im nächsten Moment zum
Schreiben eines Briefes benutzt werden. Mit einem entsprechenden Betriebssystem las-
sen sich sogar mehrere Aufgaben gleichzeitig erledigen. Der Computer sortiert im Hin-
tergrund Adressen, während der Anwender einen Brief eintippt.
Anders als zum Beispiel bei vielen Maschinen in der Produktion müssen an einem Com-
puter kaum Änderungen vorgenommen werden, damit er andere Aufgaben erledigen
kann. Sie müssen den Computer weder umbauen noch irgendwie umrüsten. Sie können
IMIT03B 3
mit ein und demselben Gerät ohne sichtbare Änderungen Briefe schreiben, Daten sor-
tieren, komplexe Berechnungen durchführen und sogar spielen. Sie müssen lediglich
andere Arbeitsanweisungen bereitstellen.
Die Frage ist nun: Woher bekommt der Computer diese Arbeitsanweisungen? Oder all-
gemeiner: Woher weiß er, was er wann zu tun hat?
Um diese Frage zu beantworten, unternehmen wir noch einmal einen kleinen Ausflug
in die Vergangenheit.
1.1 Eine kleine Geschichte der Automaten

Die Entwicklung und der Einsatz von Computern ist die Konsequenz eines Wunsches,
der schon seit langer Zeit die Menschen beschäftigt: Menschliche Arbeit soll von Ma-
schinen erledigt werden. Der Mensch selber kontrolliert nur die Ausführung und das
Ergebnis. Den Rest übernimmt die Maschine.
Auch wenn zwischen den ersten Automaten aus der Antike und modernen Computern
Welten liegen, ist diesen Maschinen doch eins gemeinsam: Sie erledigen Arbeitsaufträge,
die ihnen vorher von einem Menschen gegeben wurden – sie bearbeiten ein Programm.
Ein Programm im weitesten Sinne fasst Arbeitsaufträge zusammen, die der Reihe
nach abgearbeitet werden.
Mit der technischen Entwicklung änderten sich auch diese Programme. Die ersten
mechanischen Automaten arbeiteten mehr oder weniger mit fest installierten Vorgaben.
Die Mechanik löste in einem festen Muster einen bestimmten Arbeitsschritt aus. Weder
die Arbeitsschritte noch die Reihenfolge der Schritte konnten geändert werden. Die
Arbeit eines „Programmierers“ bestand im Wesentlichen in der Konstruktion und der
Montage der mechanischen Einzelteile. Zum Teil hatten diese mechanischen Automaten
erstaunliche Fähigkeiten. So konnten ja einige Rechenmaschinen, die Sie bereits kennen-
gelernt haben, durchaus verschiedene Operationen durchführen und auch in kleinem
Umfang Daten speichern.
Mit der weiteren Entwicklung machte sich dann auch ein Problem bemerkbar, dass letzt-
lich zur „Erfindung“ des Programmierens führte: Die Maschinen waren so aufwendig,
dass der Wunsch aufkam, sie für mehrere unterschiedliche Aufgaben nutzen zu können.
Die ersten Ideen in diese Richtung kennen Sie ja ebenfalls schon – die programmier-
baren Webstühle des französischen Erfinders Joseph-Marie Jacquard.
Bei den ersten Computern spielten vor allem die Kosten eine Rolle. Die elektrischen und
elektronischen Bauelemente waren so teuer, dass nach Möglichkeiten gesucht wurde,
die Geräte möglichst universell einzusetzen. Die Rechner sollten unterschiedlichste Pro-
gramme bearbeiten können.
Die Programmierung war damals im wahrsten Sinne des Wortes Handarbeit. Ein Pro-
gramm wurde zum Beispiel mithilfe einer Stecktafel und einer Menge verschiedener
Drähte erstellt. Jedes Loch in der Tafel hatte eine bestimmte Funktion, jede Verbindung
der einzelnen Löcher untereinander bewirkte eine bestimmte Aktion. Die Ergebnisse
4 IMIT03B
Warum Computer programmiert werden müssen 1
dieser Art von Programmierung ließen aber oft zu wünschen übrig. Schon recht ein-
fache Programme bestanden aus mehreren Hundert Drähten – und jeder dieser Drähte
konnte einen Fehler verursachen.
Außerdem ließen sich die Programme nicht beliebig oft abrufen. Um ein neues Pro-
gramm zu starten, musste erst das alte entfernt und anschließend das neue gesteckt wer-
den. Die einzige Möglichkeit, Programme zu „speichern“, bestand in Notizen, aus denen
das Programm später rekonstruiert wurde.
Daher wurden bereits recht schnell Lochstreifen und Lochkarten benutzt, die ja auch
schon bei den Webstühlen von Jacquard zum Einsatz kamen. Die Verbindungen auf dem
Steckbrett wurden durch die Kombination von Löchern dargestellt. Ein Programm be-
stand dann nicht mehr aus vielen Drähten, sondern aus vielen Karten beziehungsweise
einem Streifen mit unzähligen Löchern.
Einfacher wurde die Arbeit der Programmierer durch die Lochkarten aber nicht unbe-
dingt. Statt in Drahtbrücken zu „denken“, mussten sie nun im Kopf haben, welches Loch
an welcher Stelle welche Aktion bewirkte. Auch die ersten Locher, die die Löcher in die
Karten machten, waren keine große Hilfe. Die Tasten waren direkt den Positionen auf
der Karte zugeordnet beziehungsweise die Löcher wurden direkt in die Karte gestanzt.
Die Weiterentwicklung der Lochkartenlocher war dann der nächste Schritt bei der Pro-
grammierung. Durch eine Taste wurde nicht mehr nur ein Loch an einer bestimmten Po-
sition auf der Karte ausgestanzt, sondern gleich ein kompletter Befehl. Der Programmie-
rer musste zum Beispiel nur eine Taste drücken, um die Löcher für den Befehl „Addiere“
in eine Karte zu stanzen. Die Befehle wurden auf die Tasten aufgedruckt und machten
so die Arbeit erheblich einfacher. Der Programmierer musste nicht mehr in Löchern
„denken“, sondern konnte sich an den Tasten auf dem Locher orientieren.
Im nächsten Schritt erhielten die Lochkartenlocher eine Tastatur, über die dann die
Befehle eingegeben werden konnten.
Abb. 1.1: Ein Lochkartenlocher (Bild von Stahlkocher)
IMIT03B 5
Der Schwerpunkt bei der Programmierung lag nun nicht mehr auf den konkreten An-
forderungen der Maschinen, sondern verschob sich hin zum menschlichen Denken. Der
Programmierer erstellte ein Programm mithilfe des Lochers. Der Locher setzte die Be-
fehle des Programmierers dann in ein Format um, das der Computer „verstehen“ und
verarbeiten konnte.
An diesem wesentlichen Prinzip hat sich bis heute nichts geändert. Lediglich die Werk-
zeuge wurden immer weiterentwickelt. Locher und Lesegeräte für Lochkarten finden Sie
nur noch im Museum. Heute werden Programme mit leistungsfähigen Entwicklungs-
umgebungen und Programmiersprachen erstellt, die selbst wieder Computerprogramme
sind. Wie das genau geht, werden wir uns in diesem Studienheft noch ausführlich an-
sehen.
Egal, was ein Computer macht, er führt immer die Anweisungen aus, die ihm vom Pro-
gramm – und damit von Menschen – vorgegeben werden. Dabei kann er im beschränk-
ten Rahmen aus den Ergebnissen eines Arbeitsschritts neue Ergebnisse ermitteln.
Ein Computer ist das ideale Werkzeug für Aufgaben, die durch Regeln eindeutig
beschrieben werden können. Die Regeln werden über das Programm abgebildet.
Das Programm steuert dann den Computer.
Ein Computer ist aber eine Maschine ohne eigene Intelligenz. „Denken“ kann also kein
Computer. Er ist nichts weiter als ein Werkzeug, das exakt und präzise die Aufgaben
durchführt, die ihm vorgegeben wurden. Ob ein Ergebnis sinnvoll ist oder nicht, kann
ein Computer nicht selbstständig entscheiden. So entstehen gelegentlich auch skurrile
Fehler wie Zahlungsaufforderungen über 0 Euro und Einberufungsbefehle für 100-Jäh-
rige.
Zusammenfassung
Für die weite Verbreitung von Computern haben unter anderem die hohe Geschwindig-
keit und die hohe Präzision bei der Verarbeitung gesorgt.
Ein Programm im weitesten Sinne fasst Arbeitsaufträge zusammen, die der Reihe nach
abgearbeitet werden.
Die Programmierung der ersten Computer erfolgte durch Drahtbrücken oder Loch-
karten.
Ein Computer ist das ideale Werkzeug für Aufgaben, die durch Regeln eindeutig
beschrieben werden können. Die Regeln werden über das Programm abgebildet.
6 IMIT03B
Warum Computer programmiert werden müssen 1
Aufgaben zur Selbstüberprüfung
Überprüfen Sie nun bitte Ihr neu erworbenes Wissen. Lösen Sie die Aufgaben zu-
nächst selbstständig und vergleichen Sie anschließend Ihre Lösungen mit den Anga-
ben im Anhang.
1.1 Für welche Automaten wurden die ersten Lochkarten beziehungsweise Loch-
streifen verwendet?
1.2 Warum entstand bei den ersten Computern der Wunsch, sie zu programmie-
ren?
1.3 Kann ein Computer selbstständig entscheiden, ob ein Ergebnis seiner Arbeit
sinnvoll ist? Begründen Sie bitte kurz Ihre Antwort.
IMIT03B 7
2 Wie Computer programmiert werden

In diesem Kapitel lernen Sie, mit welchen Techniken Anweisungen in ein Format
gebracht werden können, das der Computer ausführen kann.
Wie Sie ja bereits wissen, müssen alle Anweisungen, die ein Computer ausführen soll,
in binär codierter Form vorliegen. Mit einer Anweisung wie
ADDIERE 3 und 4
kann ein Computer überhaupt nichts anfangen.

Eine Möglichkeit wäre es, die entsprechenden Anweisungen direkt in binär codierter
Form in den Speicher zu schreiben und das Programm dann ausführen zu lassen. Diese
Maschinensprache haben Sie ja bereits im letzten Studienheft bei der Codierung von
Befehlen kurz kennengelernt.
Die Anweisung zum Addieren der beiden Werte könnte in Maschinensprache so aus-
sehen:
0001 1010 0011 0100
Die acht Bits ganz links stehen für die Anweisung Addiere, dann folgen die beiden Zah-
len – jeweils mit vier Bits dargestellt.
Hinweis:
Die Bitfolge 0001 1010 für die Anweisung Addiere ist willkürlich gewählt.
Maschinensprache ist immer auf einen ganz bestimmten Prozessortyp zugeschnit-

ten. Ein Programm muss daher für jeden Prozessortyp neu geschrieben werden.
Da diese direkte Programmierung über Maschinensprache sehr umständlich, aufwendig

und auch äußerst fehlerträchtig ist, wurden für die Programmierung von Computern
eigene Programme entwickelt – die Programmiersprachen.
2.1 Vom Assembler zur Hochsprache

Eine der ersten Programmiersprachen waren die Assembler1. Hier erfolgte die Pro-
grammierung über Mnemonics2, kurze mehr oder weniger sprechende Befehle, die
leichter zu merken sind als eine Kombination aus Einsen und Nullen. Typische Mne-
monics sind zum Beispiel add zum Addieren oder mov zum Laden von Werten.
Das Mnemonic mov steht dabei als Abkürzung für move (engl. „verschieben“).
Die Anweisungen zum Addieren von zwei Zahlen würden in Assembler so aussehen:
mov ax, 3
add ax, 4
1. Assembler bedeutet übersetzt so viel wie „Monteur“.

2. Mnemonic bedeutet übersetzt so viel wie „Gedächtnisstütze“.
8 IMIT03B
Wie Computer programmiert werden 2
Mit der ersten Anweisung wird der Wert 3 in ein Register – eine spezielle Speicherstelle
im Prozessor – geschrieben. Mit der zweiten Anweisung wird auf den aktuellen Wert des
Registers der Wert 4 addiert.
Ein vollständiges Assembler-Programm, das den Text „Hello World“ auf dem Bildschirm
ausgibt, könnte so aussehen:
.MODEL tiny
.CODE
ORG 100h
HELLO PROC
MOV AH,09h
LEA DX,msg
INT 21h; Display Hello World
MOV AX,4C00h; Exit to DOS

INT 21h
HELLO ENDP
msg DB 'Hello World$'
END HELLO
Code 2.1: Ein einfaches Assembler-Programm (Quelle: http://www.ntecs.de/)
Das „Hello World“-Beispiel ist ein Programm, das für die ersten Versuche in einer
Programmiersprache benutzt wird. Im weiteren Verlauf werden Sie das „Hello
World“-Programm auch selbst mit der Programmiersprache Python erstellen.
Hinweis:
Assembler-Programme arbeiten mit hexadezimalen Zahlen. Das erkennen Sie unter
anderem an dem kleinen h hinter einem Wert.
Durch den Einsatz der Mnemonics wurde zwar die Programmierung etwas einfacher,
allerdings konnte der Computer das Programm nun nicht mehr direkt ausführen.
Es musste erst in einem Zwischenschritt wieder in eine Folge von Einsen und Nullen
umgesetzt werden. Diese Aufgabe erledigte ebenfalls der Assembler.
Die Bezeichnung Assembler wird sowohl für die Programmiersprache als auch für
das Programm benutzt, das die Anweisungen in ein für den Computer verständliches
Format übersetzt.
Allerdings war die Programmierung mit einem Assembler immer noch sehr aufwendig,
da die Befehle nicht unbedingt leicht zu behalten waren und der Programmierer sich um
viele Sachen selber kümmern musste. Das folgende Assembler-Programm berechnet
zum Beispiel die Quadrate der Zahlen 1 bis 10.
;; Squares of integers 1..10 in MIDAS
title squares
IMIT03B 9
p==17
.vector pdl(lpdl==200)
ttyo==:5
start: move p, [-lpdl,,pdl-1]

open ttyo, [.uao,,'tty ? 0 ? 0]
.lose %lsfil
move 1, [-12,,1]
loop: hrrz 2, 1
imul 2, 2
pushj p, print
movei 2, 15
.iot ttyo, 2
movei 2, 12
.iot ttyo, 2
aobjn 1, loop
.logou1,
print: idivi 2, 12
push p, 3
skipe 2
pushj p, print
pop p, 2
addi 2, "0
.iot ttyo, 2
popj p,
end start
Code 2.2: Ein Assembler-Programm für die Berechnung von Quadrat-Zahlen

(Quelle: http://www.ntecs.de/)
Auch wenn wir uns das vorige Listing nicht weiter im Detail ansehen wollen, wird selbst
beim schnellen Überfliegen der Anweisungen klar, dass die Programmierung mit einem
Assembler nicht nur schwierig, sondern auch sehr fehlerträchtig war. Bereits ein kleiner
Fehler führte dazu, dass das Programm nicht wie gewünscht arbeitete. Deshalb wurden
Hochsprachen entwickelt.
Die erste Hochsprache – FORTRAN (Formula Translator)3 – entstand bereits 1957.
Die Befehle orientierten sich an der englischen Sprache. Das „Hello World“-Programm
in FORTRAN sieht zum Beispiel so aus:
*
C Hello World in Fortran 77
C (lines must be 6 characters indented)
*
PROGRAM HELLOW
WRITE(UNIT=*, FMT=*) 'Hello World'
END
Code 2.3: Das „Hello World“-Programm in FORTRAN (Quelle: http://www.ntecs.de/)
3. Formula Translator bedeutet übersetzt „Formelübersetzer“.
10 IMIT03B
Die Symbole für Berechnungen entsprachen bei FORTRAN den üblichen mathemati-
schen Symbolen – zum Beispiel + für eine Addition, – für eine Subtraktion oder * für
eine Multiplikation. Das Programm zum Berechnen der Quadratzahlen von 1 bis 10
sieht in FORTRAN so aus:
PROGRAM SQUARE
DO 15,I = 1,10
WRITE(*, *) I*I
15 CONTINUE
END
Code 2.4: Das Programm zum Berechnen von Quadratzahlen in FORTRAN

(Quelle: http://www.ntecs.de/)
Statt Drahtbrücken zu stecken, Löcher in eine Karte zu stanzen oder komplizierte Mne-
monics wie bei einem Assembler zu verwenden, konnte ein Programmierer dem Com-
puter seine Wünsche nun in einer halbwegs verständlichen Form mitteilen. Dadurch
konnte er sich viel stärker dem eigentlichen Problem widmen. Im Mittelpunkt stand
weniger die Frage: „Wie teile ich dem Computer die Lösung für das Problem mit?“, son-
dern die Frage „Wie soll der Computer die Aufgabe lösen?“.
FORTRAN nahm dem Programmierer auch sehr viel Arbeit ab. Er musste zum Beispiel
nicht mehr selber die Organisation des Speichers übernehmen und konnte Funktionen
zum Speichern und Lesen von Daten mit einem einzigen Befehl aufrufen. Dieser eine
Befehl wurde bei der Ausführung beziehungsweise Übersetzung des Programms in viele
einzelne Befehle für den Computer umgeformt.
Programmiersprachen, bei denen ein Befehl in mehrere einzelne Befehle für den
Computer umgeformt wird, heißen auch 1:n-Programmiersprachen. Programmier-
sprachen, bei denen ein Befehl auch einem Befehl für den Computer entspricht, hei-
ßen 1:1-Programmiersprachen.
Nahezu alle Hochsprachen sind 1:n-Programmiersprachen. Ein Assembler dagegen
ist eine 1:1-Programmiersprache.
Die Programmiersprache FORTRAN hatte ihre Stärken vor allem bei Programmen mit
mathematischem Schwerpunkt. Für kaufmännische Anwendungen war sie weniger gut
geeignet. Daher entstanden recht schnell weitere Programmiersprachen. LISP (List
Processing Language)4 hatte zum Beispiel Stärken bei der Arbeit mit Zeichenketten,
COBOL (Common Business Orientated Language)5 dagegen wurde vor allem für kauf-
männische Anwendungen eingesetzt.
(print "Hello World")
Code 2.5: Das „Hello World“-Programm in LISP (Quelle: http://www.ntecs.de/)
4. Übersetzt bedeutet List Processing Language so viel wie „Listenverarbeitungssprache“.

5. Common Business Orientated Language lässt sich etwas holprig mit „Allgemeine, am Geschäft orientierte
Sprache“ übersetzen.
IMIT03B 11
IDENTIFICATION DIVISION.
PROGRAM-ID. HelloWorld.
AUTHOR. Fabritius.
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
INPUT-OUTPUT SECTION.
DATA DIVISION.
FILE SECTION.
WORKING-STORAGE SECTION.
LINKAGE SECTION.
PROCEDURE DIVISION.
DISPLAY "Hello World".
STOP RUN.
Code 2.6: Das „Hello World“-Programm in COBOL (Quelle: http://www.ntecs.de/)
Wie Sie an diesen Beispielen sehen, orientieren sich einige Hochsprachen sehr eng an
der menschlichen Sprache. Ein COBOL-Programm lässt sich zum Beispiel auch ohne
spezielle Kenntnisse der Programmiersprache einigermaßen gut lesen. Sie benötigen
lediglich einige englische Vokabeln.
Versuchen Sie zum Beispiel einmal selbst herauszufinden, was das folgende COBOL-
Programm macht. Konzentrieren Sie sich dabei auf die Anweisungen im Bereich
PROCEDURE DIVISION.
PROCEDURE DIVISION.
IDENTIFICATION DIVISION.
PROGRAM-ID. TEST3.
AUTHOR. SIEBECK.
DATA DIVISION.
WORKING-STORAGE SECTION.
77 TEXTA PIC X(4) VALUE "A : ".
77 TEXTB PIC X(4) VALUE "B : ".
77 TEXTF PIC X(9) VALUE "FLAECHE : ".
01 A PIC 9(3).
01 B PIC 9(3).
01 FLAECHE PIC 9(6).
01 EIN-A PIC ZZ9.
01 EIN-B PIC ZZ9.
01 AUS-FLAECHE PIC ZZZZZ9.
PROCEDURE DIVISION.
DISPLAY SPACE AT 0101.
DISPLAY TEXTA AT 0101.
ACCEPT EIN-A AT 0110.
MOVE EIN-A TO A.
DISPLAY TEXTB AT 0201.
ACCEPT EIN-B AT 0210.
MOVE EIN-B TO B.
COMPUTE FLAECHE = A * B.
MOVE FLAECHE TO AUS-FLAECHE.
12 IMIT03B
DISPLAY TEXTF AT 0301.

DISPLAY AUS-FLAECHE AT 0310.
STOP RUN.
Code 2.7: Ein COBOL-Programm
Das Programm liest zwei Zahlen ein und berechnet daraus den Flächeninhalt eines
Rechtecks.
In einer anderen Programmiersprache wie zum Beispiel C ist dieses Programm sehr viel
kompakter, sieht aber auch komplizierter aus.
#include <stdio.h>
main()
{
int a, b;
long flaeche;
printf("\nA : ");
scanf("%i",&a);
printf("B : ");
scanf("%i",&b);
flaeche = a * b;
printf("Flaeche = %li",flaeche);
}
Code 2.8: Ein C-Programm
Neben den mehr oder weniger leicht verständlichen Anweisungen unterstützen nahezu
alle Hochsprachen auch spezielle Strukturen, die beim Programmieren oft benötigt wer-
den. Dazu gehören zum Beispiel Verzweigungen und Wiederholungen. Mit diesen
Strukturen werden wir uns in diesem Studienheft noch ausführlicher beschäftigen.
Da die meisten Hochsprachen typische Vor- und Nachteile haben und häufig auf be-
stimmte Teilbereiche spezialisiert sind, wurden im Laufe der Zeit immer weitere Hoch-
sprachen entwickelt und bereits vorhandene Hochsprachen an neue Entwicklungen an-
gepasst. Andere Programmiersprachen sind dafür im Laufe der Jahre wieder vom Markt
verschwunden.
IMIT03B 13
Eine Darstellung der wichtigsten Entwicklungen finden Sie in dem folgenden Stamm-
baum:
Abb. 2.1: Der Stammbaum wichtiger Programmiersprachen
Hinweis:
Von einzelnen Programmiersprachen gibt es mehrere Sprachvarianten – sogenannte
Dialekte –, die sich zum Teil erheblich unterscheiden. So lässt sich ein Assembler-
programm nicht mit jedem Assembler ausführen beziehungsweise übersetzen.
2.2 Compiler und Interpreter

Genau wie bei einem Assembler müssen auch die Anweisungen einer Hochsprache vor
der Ausführung in ein Format gebracht werden, das der Computer verarbeiten kann.
Dazu verwenden nahezu alle modernen Hochsprachen einen Compiler.6 Er setzt die
Anweisungen der Programmiersprache – den Quelltext – in eine ausführbare Datei um.
Diese Datei kann dann vom Betriebssystem ausgeführt werden. Der Quelltext selbst
wird also für die eigentliche Ausführung nicht benötigt.
6. to compile bedeutet übersetzt so viel wie „zusammentragen“.
14 IMIT03B
Abb. 2.2: Das Funktionsprinzip eines Compilers
Neben den Hochsprachen, die mit einem Compiler arbeiten, gibt es auch einige Hoch-
sprachen, die das Programm durch einen Interpreter7 verarbeiten. Hier wird der aus-
führbare Code nicht vor der Ausführung des Programms erzeugt, sondern zur Laufzeit
des Programms. Das heißt, die einzelnen Anweisungen werden erst unmittelbar vor der
Ausführung einzeln übersetzt.
Solche Programme können normalerweise nicht direkt vom Betriebssystem ausgeführt
werden, sondern müssen immer in der Programmiersprache beziehungsweise der dazu-
gehörigen Anwendung ausgeführt werden. Durch den ständigen Wechsel zwischen
Ausführung und Übersetzung sind die Programme außerdem recht langsam.
Abb. 2.3: Das Funktionsprinzip eines Interpreters
Interpreter werden vor allem bei Skriptsprachen eingesetzt. Hier wird ein Programm –
etwas vereinfacht ausgedrückt – durch die Aneinanderreihung von einzelnen Befehlen
beschrieben. So lassen sich zum Beispiel häufig ausgeführte Arbeiten automatisieren.
Ein Programm, das mit einer Skriptsprache erstellt wurde, wird auch Skript genannt.
7. to interpret bedeutet übersetzt so viel wie „auslegen“ oder „dolmetschen“.
IMIT03B 15
In diesem Video stellen wir Ihnen die

unterschiedlichen Arbeitsweisen eines
Compilers und eines Interpreters vor
www.sgd.media/tz5uaj
Video 2.1: Compiler und Interpreter
Skriptsprachen finden Sie unter anderem bei Batchprogrammen auf Betriebssystem-

ebene. Hier werden Anweisungen an das Betriebssystem der Reihe nach abgearbeitet.
Ein Batchprogramm ist eine Reihe von Befehlen, die von oben nach unten abgear-
beitet werden. Batch bedeutet übersetzt so viel wie „Stapel“. Statt Batchprogramm
findet sich auch die Bezeichnung Stapelprogramm oder Stapelverarbeitung.
Das folgende Programm kopiert zum Beispiel in der Eingabeaufforderung von Windows
alle Dateien aus dem aktuellen Ordner mit der Erweiterung .doc in einen Ordner \test
auf dem Laufwerk C: und vergleicht danach die kopierten Dateien mit dem Original.
@echo off
cls
echo ******************************************
echo * Batchprogramm zum Kopieren von Dateien *
echo ******************************************
echo.
rem Bitte in einer Zeile eingeben
echo Druecken Sie CTRL + C zum Abbruch oder eine beliebige Taste
zum Start
pause >NUL
rem *** Dateien kopieren
echo Die Dateien mit der Erweiterung .doc werden nach C:\test
kopiert
copy *.doc c:\test
rem *** Vergleich der Dateien
echo Die kopierten Datei(en) werden ueberprueft
echo n | comp *.doc c:\test\*.doc
echo n
echo Druecken Sie eine beliebige Taste, um das Konsolenfenster
zu schliessen
pause >NUL
@echo on
Code 2.9: Ein Batchprogramm
16 IMIT03B
Die Wirkung des Batchprogramms können Sie selbst ausprobieren. Erstellen Sie dazu
zum Beispiel mit dem Editor von Windows8 eine Datei und geben Sie die Befehle aus
dem vorigen Code ein. Achten Sie dabei sorgfältig darauf, dass Ihnen kein Tippfehler
unterläuft. Speichern Sie dann die Datei unter einem beliebigen Namen mit der Erwei-
terung .bat oder .cmd9.
Hinweis:
Einige Anweisungen in dem vorigen Code sind in mehreren Zeilen abgedruckt. Sie
müssen diese Anweisungen aber in einer Zeile eingeben. Andernfalls erhalten Sie
beim Ausführen eine Fehlermeldung beziehungsweise merkwürdige Ergebnisse. Die
entsprechenden Zeilen erkennen Sie auch an dem Hinweis, der in dem Code steht.
Der Ordner \test wird durch das Batchprogramm nicht automatisch angelegt. Wenn
er auf Ihrer Festplatte nicht vorhanden ist, müssen Sie ihn selbst per Hand angelegen.
Sie finden die Datei auch im heftbezogenen Download-Bereich Ihrer Online-Lern-
plattform unter dem Namen demo.cmd.
Im Explorer von Windows wird die Datei als Befehlsskript mit dem Symbol darge-
stellt. Nach einem Doppelklick auf das Symbol wird automatisch die Eingabeaufforde-
rung geöffnet und die Befehle in der Datei werden ausgeführt.
Abb. 2.4: Das ausgeführte Befehlsskript
8. Den Editor von Windows finden Sie im Startmenü unter Windows-Zubehör.

9. Die Erweiterung cmd steht für command (engl. „Befehl“). Die Erweiterung .bat steht für batch 
(engl. „Stapel“).
IMIT03B 17
Hinweis:
Bitte benutzen Sie zum Test zur Sicherheit nur Dateien, die Sie nicht benötigen oder
erstellen Sie Kopien.
Sie müssen das Befehlsskript unter Umständen mit administrativen Rechten ausfüh-
ren. Klicken Sie dazu mit der rechten Maustaste auf das Symbol des Skripts und wäh-
len Sie im Kontext-Menü die Funktion Als Administrator ausführen. Bestätigen Sie
anschließend die Sicherheitsabfrage der Benutzerkontensteuerung durch einen Klick
auf Fortsetzen.
Die Ausführung des Befehlsskripts können Sie mit der Tastenkombination +

abbrechen. Bestätigen Sie anschließend die Abfrage.
Unter macOS können Sie Befehlsskripte über Shell Skripte ausführen lassen. Ein typi-
sches Shell Skript könnte zum Beispiel so aussehen:
#!/bin/sh
clear
echo "******************************************"
echo "* Shell Skript zum Kopieren einer Datei *"
echo "******************************************"
echo
# Bitte in einer Zeile eingeben
read -p "Drücken Sie CTRL + C zum Abbruch oder eine beliebige
Taste zum Start"
# Datei kopieren
echo "Die Datei test.docx wird nach save.docx kopiert"
cp test.docx save.docx
# Vergleich der Datei
echo "Die kopierte Datei wird überprüft"
diff test.docx save.docx
Code 2.10: Ein Shell Skript zum Kopieren und Vergleichen einer Datei unter macOS
Abb. 2.5: Das ausgeführte Skript im Terminal von macOS
Ein weiteres Einsatzgebiet von Skriptsprachen ist die Automatisierung in Anwendungs-

programmen über Makros. Das folgende Beispiel für die Textverarbeitung Word von
Microsoft führt in einem Rutsch einige Zeichen- und Absatzformatierungen durch.
18 IMIT03B
Sub formatierung()
'
' formatierung Makro
'
'
Selection.Font.Name = "Arial"
Selection.Font.Size = 14
Selection.Font.Bold = wdToggle
Selection.ParagraphFormat.Alignment = wdAlignParagraphRight
End Sub
Code 2.11: Ein Makro
Zum Teil verfügen Skriptsprachen aber auch über Möglichkeiten, die einer echten Pro-
grammiersprache nicht nachstehen. So werden zum Beispiel viele anspruchsvolle Inter-
net-Anwendungen mit Skriptsprachen wie PHP entwickelt.
2.3 Die Objektorientierung

Nahezu alle modernen Programmiersprachen arbeiten objektorientiert. Dabei werden
– etwas vereinfacht ausgedrückt – Daten mit dem Verhalten, das die Daten verändert,
in einem Objekt zusammengefasst. Die Daten bilden dabei die Eigenschaften des
Objekts und das Verhalten die Methoden.
Abb. 2.6: Ein Objekt
Sehen wir uns dazu zwei konkrete Beispiele an:

Bei einem Objekt Kaffeemaschine sind zum Beispiel die Farbe, die Größe oder die Art
des Kaffeefilters Eigenschaften. Methoden wären dann das Erhitzen des Wassers oder
auch das Ein- beziehungsweise Ausschalten.
Bei einem Objekt Auto wären die Farbe, die Anzahl der Türen und der Motor Eigen-
schaften. Methoden wären dann zum Beispiel Starten, Gas geben und Bremsen.
Objekte mit gleichen oder sehr ähnlichen Eigenschaften und Methoden werden in Klas-
sen zusammengefasst und in eine hierarchische Beziehung gebracht. Die untergeordne-
ten Klassen können dabei von den übergeordneten Objekten sowohl die Eigenschaften
als auch die Methoden erben. Bei Bedarf können in einer Klasse außerdem neue Eigen-
schaften und Methoden ergänzt werden. Auf diese Weise müssen bereits vorhandene
Eigenschaften und Methoden nicht immer wieder neu programmiert werden, sondern
können übernommen und erweitert werden.
IMIT03B 19
Auf den Computer übertragen könnten Sie zum Beispiel eine übergeordnete Klasse
Fenster erstellen und aus dieser Klasse dann die Klassen Ausgabefenster, Eingabe-
fenster und Dialogfenster ableiten. In der Klasse Fenster werden die allgemeinen
Eigenschaften beschrieben – zum Beispiel die Größe, die Farbe oder die Position auf dem
Desktop. In den untergeordneten Klassen finden sich dann die Besonderheiten – zum
Beispiel die Anzahl der Schaltflächen im Fenster.
Abb. 2.7: Eine einfache Klassenhierarchie
Durch die Objektorientierung ist es außerdem recht einfach möglich, einem Program-
mierer vorgefertigte Elemente wie Dialoge oder Komponenten für bestimmte Aufgaben
zur Verfügung zu stellen. Die vorgefertigten Elemente lassen sich in einer grafisch ori-
entierten integrierten Entwicklungsumgebung mit ein paar Mausklicks in ein eigenes
Programm einfügen und anpassen. Durch dieses Rapid Application Development
(RAD)10 kann die Entwicklungszeit für ein Programm deutlich verkürzt werden.
Abb. 2.8: Eine Entwicklungsumgebung für Rapid Application Development (hier Visual
Studio von Microsoft)
10. Rapid Application Development bedeutet wörtlich übersetzt „schnelle Anwendungsentwicklung“.
20 IMIT03B
In diesem Video zeigen wir Ihnen eine

Entwicklungsumgebung für das Rapid
Application Development im prakti-
schen Einsatz.
www.sgd.media/g1cc73
Video 2.2: Eine Entwicklungsumgebung für das Rapid Application Development im Einsatz
2.4 Einzelne Programmiersprachen

Schauen wir uns jetzt einige Programmiersprachen etwas genauer an. Beginnen wir mit
Python.
Python ist eine universell einsetzbare Programmiersprache. Sie wurde in den 1990er
Jahren vom Niederländer Guido van Rossum entwickelt. Wesentliche Ziele waren dabei
Einfachheit und Übersichtlichkeit.
Bei der Übersetzung wird zunächst durch den Python-Compiler ein Bytecode erzeugt.
Dieser Bytecode wird dann auf dem Rechner, auf dem das Programm ausgeführt werden
soll, durch einen Interpreter – die Python Virtual Machine11 – in ausführbare Befehle
umgesetzt.
Python Virtual
Quelltext Python-Compiler Bytecode ausgeführtes Programm
Machine
Abb. 2.9: Die Python Virtual Machine
Damit lassen sich Python-Programme grundsätzlich auf jedem Computer ausführen,

der über eine Python Virtual Machine verfügt. So werden unter anderem Windows,
macOS und auch Linux unterstützt.
Python-Anwendungen sind weitgehend plattformunabhängig. Sie können unter

nahezu allen gängigen Betriebssystemen eingesetzt werden.
Allerdings ist die Plattformunabhängigkeit von Python auch ein Nachteil. Da die Befeh-
le in der Regel zunächst erst interpretiert werden müssen, sind Python-Anwendungen
vergleichsweise langsam.
11. Virtual Machine bedeutet übersetzt so viel wie „virtuelle Maschine“. Eine virtuelle Maschine ist in der
Informationstechnik so etwas wie ein Computer, der simuliert wird – also nur virtuell vorhanden ist.
IMIT03B 21
Ein einfaches Programm, das zwei Werte über die Tastatur einliest und daraus den
Flächeninhalt eines Rechtecks berechnet, sieht in Python zum Beispiel so aus:
a = float(input("A: "))
b = float(input("B: "))
flaeche = a * b
print("Flaeche", flaeche)
Code 2.12: Ein einfaches Python-Programm
So viel zu Python. Mehr zu der Programmiersprache erfahren Sie im weiteren Verlauf.

Die Programmiersprache C++ wurde 1980 von Bjarne Stroustrup entwickelt. Sie erwei-
tert die Programmiersprache C um einen objektorientierten Ansatz. C++ verfügt über
einen grundlegenden Sprachstandard – ISO C++12. Durch diesen Sprachstandard kön-
nen Programme einmal erstellt und dann von unterschiedlichsten Compilern für ver-
schiedene Betriebssysteme übersetzt werden. Allerdings haben im Laufe der Zeit die
verschiedenen Anbieter ihre Entwicklungsumgebungen so stark mit eigenen Anweisun-
gen und vorgefertigten Bausteinen erweitert, dass die Programme sich nicht mehr mit
Entwicklungsumgebungen anderer Hersteller übersetzen lassen.
C++ gilt als sehr mächtige Programmiersprache, ist aber zum Teil recht komplex.
Das Programm zur Flächenberechnung sieht in C++ so aus:
#include <iostream>
using namespace std;
int main()
{
int a, b;
long flaeche;
cout << "A: ";
cin >> a;
cout << "B: ";
cin >> b;
flaeche = a * b;
cout << "Flaeche = " << flaeche << endl;
return 0;
}
Code 2.13: Ein einfaches C++-Programm
So viel an dieser Stelle zu C++.

Bei der Programmiersprache Java wird bei der Übersetzung von Quelltexten durch den
Compiler nicht direkt ein ausführbares Programm erzeugt, sondern zunächst wie bei
Python ebenfalls ein Bytecode. Er wird durch einen Interpreter – die Java Virtual
12. ISO (International Standardization Organization) ist eine internationale Organisation, die international
gültige Standards aufstellt. Zu den Mitgliedern der ISO gehört zum Beispiel das Deutsche Institut für
Normung DIN.
22 IMIT03B
Machine – in ausführbare Befehle umgesetzt. Damit lassen sich auch Java-Anwendun-

gen grundsätzlich auf jedem Computer ausführen, der über eine Java Virtual Machine
verfügt.
Abb. 2.10: Die Java Virtual Machine
Auch Java-Anwendungen können unter nahezu allen gängigen Betriebssystemen

eingesetzt werden.
Durch den Interpreter sind Java-Programme allerdings ebenfalls vergleichsweise lang-

sam.
Das Java-Programm zum Berechnen des Flächeninhalts eines Rechtecks könnte zum
Beispiel so aussehen:
import javax.swing.JOptionPane;
public class Flaeche {

public static void main(String[] args) {
int a, b;
long flaeche;
a = Integer.parseInt(JOptionPane.showInputDialog("A: "));
b = Integer.parseInt(JOptionPane.showInputDialog("B: "));
flaeche = a * b;
System.out.println("Flaeche = " + flaeche);
}
}
Code 2.14: Ein einfaches Java-Programm
Die Programmiersprache C#13 fasst die besonderen Stärken der Programmiersprachen

C++ und Java zusammen. C# ist in das .NET-Konzept14 der Firma Microsoft integriert.
Dieses Konzept arbeitet nach einem Prinzip wie Python und Java. Die Programme
werden nicht direkt in ausführbare Anwendungen übersetzt, sondern zunächst in eine
Zwischensprache – die Common Intermediate Language15 (CIL) – umgesetzt. Diese
Zwischensprache wird dann auf jedem einzelnen Computer durch einen Just in Time-
Compiler16 (JIT) in ein ausführbares Programm umgewandelt.
13. Das Zeichen # wird wie das englische Wort sharp ausgesprochen.
14. .NET wird „dot net“ ausgesprochen. Dot bedeutet übersetzt so viel wie „Punkt“. NET bedeutet übersetzt
„Netz“.
15. Intermediate Language bedeutet übersetzt so viel wie „Zwischensprache“.
16. Just in Time bedeutet übersetzt so viel wie „genau rechtzeitig“.
IMIT03B 23
Damit sind auch .NET-Anwendungen grundsätzlich plattformunabhängig – allerdings

nicht in dem Umfang wie zum Beispiel Java-Programme. Außerdem können verschie-
dene Teile eines Programms auch in unterschiedlichen Programmiersprachen erstellt
und anschließend beim Ausführen des Programms zusammengefasst werden.
Da die Umsetzung in ein ausführbares Programm durch einen Compiler erfolgt, ist die
Ausführung der Programme schneller als bei einem Interpreter. Allerdings muss nach
dem Aufruf des Programms eine kurze Wartezeit in Kauf genommen werden, bis das
Programm tatsächlich startet. Das liegt daran, dass der Compiler erst seine Arbeit erle-
digen muss.
Ein Beispiel für ein C#-Programm finden Sie im folgenden Code. Es liest ebenfalls zwei
Werte ein und errechnet daraus den Flächeninhalt eines Rechtecks.
using System;
namespace Flaeche
{
class Program
{
static void Main(string[] args)
{
int a, b;
long flaeche;
Console.Write("A: ");
a = Convert.ToInt32(Console.ReadLine());
Console.Write("B: ");
b = Convert.ToInt32(Console.ReadLine());
flaeche = a * b;
Console.WriteLine("Flaeche = {0}", flaeche);
}
}
}
Code 2.15: Ein einfaches C#-Programm
Werfen wir abschließend noch einen kurzen Blick auf die Programmiersprache Visual
Basic von Microsoft. Sie ist eine Weiterentwicklung der klassischen Einsteigersprache
BASIC. Visual Basic gilt als relativ schnell zu erlernen und ist wie C# in das .NET-Kon-
zept integriert. Ein Visual Basic-Programm sieht daher einem C#-Programm auf den ers-
ten Blick auch recht ähnlich.
Module Module1
Sub Main()
Dim a As Integer
Dim b As Integer
Dim flaeche As Long
Console.Write("A: ")
a = Convert.ToInt32(Console.ReadLine())
Console.Write("B: ")
b = Convert.ToInt32(Console.ReadLine())
flaeche = a * b
Console.WriteLine("Flaeche = {0}", flaeche)
24 IMIT03B
End Sub
End Module
Code 2.16: Ein einfaches Visual Basic-Programm
So viel zu den Programmiersprachen. Sehen wir uns jetzt noch einige spezielle Entwick-
lungswerkzeuge an.
2.5 Spezielle Entwicklungswerkzeuge

Da viele Anwender keine Programmiersprache erlernen wollen, aber trotzdem gerne
eigene kleine Programme erstellen möchten, haben einige Anbieter besondere Entwick-
lungswerkzeuge auf den Markt gebracht. Diese Werkzeuge arbeiten vielfach auf gra-
fischem Weg und nehmen Ihnen die oft mühselige Programmierung in einzelnen An-
weisungen nahezu vollständig ab. Sie müssen lediglich Bilder und Texte einfügen und
können dann zum Beispiel über Symbole Verzweigungen und auch Wiederholungen
einfügen. Aus der symbolischen Darstellung erzeugt dann eine Art Generator ein Pro-
gramm.
Über Multimedia-Werkzeuge können Sie zum Beispiel vergleichsweise einfach und
komfortabel anspruchsvolle Präsentationen mit Bildern, Videos, Animationen und
Audios erstellen. Die Präsentationen sind dabei in der Regel interaktiv – das heißt, ein
Anwender kann den Ablauf der Präsentation selbst steuern.
Ein Programm zur Erstellung solcher Präsentationen ist zum Beispiel Presenter17 der
Firma Adobe. Hier können Sie unterschiedlichste Elemente in eine Präsentation ein-
fügen und steuern, wann und wie lange die Elemente angezeigt werden sollen. Außer-
dem lassen sich für die verschiedenen Elemente Eigenschaften und Aktionen einstellen.
So können Sie zum Beispiel sehr komfortabel festlegen, wie ein Element dargestellt wird
und was beim Klick auf eine Schaltfläche geschehen soll.
17. Presenter bedeutet übersetzt „Moderator“.
IMIT03B 25
Abb. 2.11: Ein Multimedia-Werkzeug (hier: Presenter von Adobe)
Die fertigen Präsentationen lassen sich in einem stark komprimierten Format speichern
und können zum Beispiel in Internet-Seiten eingebunden werden. Die Wiedergabe
erfolgt mit einem speziellen Programm, das zusätzlich zum Browser installiert wird –
einem Player18.
Noch einen Schritt weiter als Multimedia-Werkzeuge gehen die Autorensysteme. Hier
können Sie nicht nur Inhalte zusammenstellen und verbinden, sondern zum Teil auch
komplette Programme mit Verzweigungen und Wiederholungen erstellen – oft ohne
eine einzige Zeile Quelltext selbst zu erstellen. Die gesamte „Programmierung“ erfolgt
auf visuellem Weg, indem Sie zum Beispiel ein Symbol für eine Verzweigung anklicken
und dann in einem eigenen Fenster festlegen, was in den verschiedenen Fällen gesche-
hen soll. Die Anweisungen können Sie dabei ebenfalls komfortabel mit der Maus aus-
wählen.
18. Player bedeutet wörtlich übersetzt „Spieler“. Gemeint ist damit ein Programm, das die Filme wiedergeben –
also abspielen – kann.
26 IMIT03B
Abb. 2.12: Ein Autorensystem (hier: EasyProf® von Innovative Training Academy SAS19)
So lassen sich mit wenig Aufwand auch komplexe Anwendungen wie zum Beispiel
Computerlernprogramme erstellen. Allerdings ist diese Art der Programmierung nicht
besonders flexibel, da Sie sich mit den Strukturen zufrieden geben müssen, die der Her-
steller des Autorenprogramms anbietet. Viele Autorenprogramme verfügen deshalb
auch über eine Programmiersprache, mit der Sie eigene Anweisungen selbst erfassen
können. Dabei müssen Sie aber wieder jede Anweisung per Hand codieren.
Grundsätzlich lassen sich die Ergebnisse von Multimedia-Werkzeugen oder Autorensys-
temen auch mit herkömmlichen Programmiersprachen wie C# oder Java erzielen. Aller-
dings ist der Aufwand hier erheblich höher, da Sie viele Elemente komplett selbst neu
programmieren müssten. Deshalb werden für solche Fälle in der Regel auch entspre-
chend spezialisierte Programme eingesetzt.
So viel zu den Programmiersprachen und Programmierwerkzeugen. Im nächsten Kapitel
werden wir uns einige grundlegende Programmstrukturen ansehen.
19. EasyProf® ist eine registrierte Marke von Innovative Training Academy SAS.
IMIT03B 27
Zusammenfassung
Die Programmierung von Computern erfolgt über spezielle Programme – die Program-
miersprachen.
Die Anweisungen der Programmiersprachen müssen in einem Zwischenschritt in ein
Format umgesetzt werden, das der Computer direkt ausführen kann. Das kann entweder
über einen Compiler oder einen Interpreter erfolgen.
Häufig eingesetzte Programmiersprachen sind zum Beispiel Python, C++, C#, Java und
Visual Basic.
Bei der Objektorientierung werden Daten mit dem Verhalten, das die Daten verändert,
in einem Objekt zusammengefasst.
Über spezielle Entwicklungswerkzeuge können Sie Programme erstellen, ohne eine
Zeile Quelltext selbst zu programmieren.
2.1 Was unterscheidet einen Assembler von einer Hochsprache?

2.2 Kann ein Programm, das in Maschinensprache erstellt wurde, auf einem belie-
bigen Prozessor ablaufen? Begründen Sie bitte Ihre Antwort.
2.3 Was ist ein Mnemonic?
2.4 Was verstehen Sie unter dem Begriff „Quelltext“?
2.5 Ein Bekannter von Ihnen will eine Multimedia-Präsentation erstellen, die auf
einer Internet-Seite dargestellt werden soll. Dazu möchte er die Programmier-
sprache C# verwenden. Halten Sie die Auswahl für richtig? Begründen Sie bitte
kurz Ihre Antwort.
2.6 Was ist das Besondere am Rapid Application Development?
2.7 Sie wollen ein Programm erstellen, das ohne Änderungen unter verschiedenen
Betriebssystemen eingesetzt werden können soll. Welche Programmierspra-
chen eignen sich besonders für diese Aufgabe?
28 IMIT03B
3 Programmstrukturen
In diesem Kapitel lernen Sie einige klassische Programmstrukturen kennen, die
beim Erstellen von Anwendungen eingesetzt werden. Sie erfahren unter anderem,
wie Verzweigungen und Wiederholungen programmiert werden.
Beginnen wir mit den Datentypen und Variablen.
3.1 Datentypen und Variablen

Wie Sie ja bereits aus dem letzten Studienheft wissen, besteht für einen Computer intern
zunächst einmal überhaupt kein Unterschied zwischen einer Zahl und einem Buchsta-
ben. Sowohl die Zahl als auch der Buchstabe werden durch ein Bitmuster repräsentiert,
das korrekt interpretiert werden muss.
Diese Interpretation wird durch die Datentypen einer Programmiersprache vorgege-
ben. Die Datentypen legen nicht nur fest, ob es sich um numerische oder alphanumeri-
sche Daten handelt, sondern beschreiben zum Beispiel bei Zahlen auch den möglichen
Wertebereich und die Nachkommastellen.
Die Programmiersprache C++ kennt unter anderem folgende Datentypen:
Tab. 3.1: Datentypen am Beispiel C++
Name Daten Wertebereicha)

int ganze Zahlen –2147483 648 bis 2147483647
float Gleitkommazahlen mit mindestens –3,40 · 1038 bis 3,40 · 1038
acht Stellen Genauigkeit
char alphanumerisch ein ASCII-Zeichen von 0 bis 255
bool Wahrheitswerte entweder „wahr“ oder „falsch“ bezie-
hungsweise „ungleich 0“ oder „0“
a) Der genaue Wertebereich hängt immer auch vom verwendeten Compiler und Betriebssystem ab.
Bitte beachten Sie:

Jede Programmiersprache arbeitet mit eigenen Datentypen. Neben den sehr allge-
meinen Datentypen gibt es auch noch Datentypen für kleine ganze Zahlen oder auch
für Zeichenketten – zum Beispiel ganze Wörter.
Die Datentypen werden unter anderem benutzt, um Variablen für das Speichern von
Daten im Programm zu vereinbaren. Im ersten Schritt werden dazu der Programmier-
sprache der Datentyp und der Name der Variable bekannt gemacht. In der Programmier-
sprache C++ kann das zum Beispiel so aussehen:
int wert;
Für die Variable mit dem Namen wert wird hier ein Speicherbereich reserviert, der
ganze Zahlen im Wertebereich von –2147483648 bis 2147483647 aufnehmen kann.
IMIT03B 29
Im Programm können der Variable anschließend Werte zugewiesen werden – zum Bei-
spiel das Ergebnis einer Addition. Diese Anweisung könnte so aussehen:
wert = 100 + 20;
Erst werden die Werte 100 und 20 addiert. Danach wird das Ergebnis in der Variablen
mit dem Namen wert abgelegt. An der Speicherstelle, die für die Variable wert reser-
viert ist, befindet sich danach also der Wert 120.
Variablen haben Sie auch schon ganz kurz in den Beispielprogrammen für die Flächen-
berechnung eines Rechtecks kennengelernt – zum Beispiel in den Zeilen
int a, b;
long flaeche;
Hier werden zwei Variablen mit den Namen a und b vom Typ int und eine Variable
mit dem Namen flaeche vom Typ long vereinbart. Da beide Typen keine Nachkom-
mastellen verarbeiten können, lassen sich mit dem Programm nur ganze Zahlen ver-
arbeiten.
Überlegen Sie einmal …

Welcher C++-Datentyp wäre für die Verarbeitung von Zahlen mit Nachkomma-
stellen geeignet? Sehen Sie dazu noch einmal in der Tabelle oben nach.
So viel zu den Datentypen und Variablen.

Kommen wir nun zu den eigentlichen Programmstrukturen. Hier werden im Wesent-
lichen nur drei Grundstrukturen unterschieden:
• die Folge,
• die Auswahl und
• die Wiederholung.
3.2 Folge
Die einfachste Struktur ist eine Folge –

auch Sequenz genannt. Hier werden die
einzelnen Anweisungen der Reihe nach
ausgeführt. Wenn Anweisung 1 abgear-
beitet ist, wird Anweisung 2 ausgeführt
und so weiter. Grafisch lässt sich eine
Folge so darstellen:
Abb. 3.1: Eine Folge
30 IMIT03B
Programmstrukturen 3
Programme mit einer Folge haben Sie in diesem Studienheft bereits bei der Berechnung
des Flächeninhalts eines Rechtecks kennengelernt. Etwas verkürzt lassen sich die einzel-
nen Schritte umgangssprachlich so beschreiben:
Vereinbare a, b und flaeche als Variablen
Lies den Wert für a ein
Lies den Wert für b ein
Multipliziere a mit b und lege das Ergebnis in flaeche ab
Gib den Wert von flaeche aus
Zuerst werden drei Variablen vereinbart. Anschließend werden die Werte für die beiden
Variablen a und b über die Tastatur eingelesen und das Ergebnis berechnet. Im letzten
Schritt wird das Ergebnis von flaeche ausgegeben. Danach wird das Programm auto-
matisch beendet.
Die Verarbeitung beginnt also mit der ersten Zeile und endet mit der letzten Zeile.
Die Anweisungen dazwischen werden von oben nach unten ausgeführt.
So viel zur Folge.
3.3 Auswahlen
Über Auswahlstrukturen können Anweisungen in Abhängigkeit von Bedingungen aus-
geführt werden. Dazu wird zunächst überprüft, ob eine Bedingung „wahr“ oder „falsch“
ist. Im einfachsten Fall wird nur dann eine bestimmte Anweisung ausgeführt, wenn die
Bedingung zutrifft. Diese Auswahlstruktur wird auch einfache Verzweigung genannt.
Ein Beispiel:
Ein Programm soll überprüfen, ob eine Zahl größer ist als 10. Wenn das der Fall ist, soll
der Text „Die Zahl ist größer als 10“ auf dem Bildschirm ausgegeben werden.
Grafisch lässt sich eine einfache Verzweigung so darstellen:
Abb. 3.2: Eine einfache Verzweigung
IMIT03B 31
Umgangssprachlich lässt sich diese Überprüfung so beschreiben:

Wenn zahl größer ist als 10 dann
Gib "Die Zahl ist größer als 10" aus
Neben der einfachen Verzweigung gibt es auch alternative Verzweigungen, in denen

auch für den Fall, dass die Bedingung nicht zutrifft, eigene Anweisungen angegeben
werden können. In unserem Beispiel könnte durch eine alternative Verzweigung zum
Beispiel der Text „Die Zahl ist nicht größer als 10“ auf dem Bildschirm erscheinen, wenn
die Zahl kleiner ist als 10.
Grafisch lässt sich eine alternative Verzweigung so darstellen:
Abb. 3.3: Eine alternative Verzweigung
Die umgangssprachliche Beschreibung sieht dann so aus:

Wenn zahl größer ist als 10 dann
Gib "Die Zahl ist größer als 10" aus
sonst
Gib "Die Zahl ist nicht größer als 10" aus
Außerdem unterstützen die meisten Programmiersprachen auch Mehrfachverzwei-

gungen. Hier können für unterschiedliche Fälle jeweils eigene Anweisungen festgelegt
werden. Mehrfachverzweigungen werden zum Beispiel oft in Menüs eingesetzt. Abhän-
gig von der Auswahl des Anwenders wird dann eine bestimmte Aktion gestartet.
Kommen wir nun zu den Wiederholungen.
3.4 Wiederholungen
Über Wiederholungen – im Fachjargon auch Schleifen genannt – lassen sich Anweisun-
gen in Abhängigkeit von einer Bedingung mehrfach ausführen. So könnte ein Programm
zum Beispiel so lange Daten über die Tastatur einlesen, bis der eingegebene Wert un-
gleich 0 ist.
32 IMIT03B
Grafisch lässt sich eine solche Wiederholung so darstellen:
Abb. 3.4: Eine Wiederholung
Die umgangssprachliche Beschreibung der Wiederholung sieht so aus:

Wiederhole so lange zahl gleich 0 ist
Lies zahl ein
Auch bei den Schleifen gibt es verschiedene Varianten – zum Beispiel eine Schleife, bei
der die Bedingung erst nach dem Ausführen der Anweisungen in der Schleife überprüft
wird und eine Variante, bei der die Bedingung vor dem Ausführen der Anweisungen in
der Schleife überprüft wird. Außerdem verfügen die meisten Programmiersprachen
auch über eine Schleifenvariante, bei der die Anzahl der Wiederholungen fest vorge-
geben wird.
Durch eine Kombination und Aneinanderreihung der verschiedenen Strukturen lassen
sich dann nahezu sämtliche Aufgaben lösen. Schauen wir uns das an einem einfachen
Beispiel an:
Ein Programm soll zwei Werte ungleich 0 über die Tastatur einlesen. Wenn der Anwen-
der den Wert 0 eingibt, soll eine Meldung auf dem Bildschirm erscheinen und das Ein-
lesen wiederholt werden. Nach der Eingabe der Werte sollen die beiden Zahlen addiert
werden. Wenn das Ergebnis der Addition größer ist als 10, soll die Meldung „Das Ergeb-
nis ist größer als 10“ auf dem Bildschirm erscheinen, andernfalls die Meldung „Das
Ergebnis ist nicht größer als 10“.
IMIT03B 33
Grafisch lässt sich dieser Ablauf so darstellen:
Abb. 3.5: Ein Programm
Zuerst wird der Wert für die erste Zahl eingelesen. Wenn dieser Wert gleich 0 ist, wird
in einer Schleife eine Meldung ausgegeben und das Einlesen wiederholt. Diese Schritte
werden so lange wiederholt, wie der eingelesene Wert gleich 0 ist. In der Schleife selbst
werden zwei Anweisungen als Folge ausgeführt – also hintereinander.
Dann wird das gleiche Verfahren für das Einlesen der zweiten Zahl eingesetzt.
Abschließend wird das Ergebnis berechnet und abhängig vom Wert des Ergebnisses
Ausgaben durchgeführt.
34 IMIT03B
Das komplette „Programm“ ließe sich umgangssprachlich so beschreiben:

Vereinbare zahl1, zahl2 und ergebnis als Variablen
Lies den Wert für zahl1 ein
Wiederhole so lange zahl1 gleich 0 ist
Gib eine Meldung aus
Wiederhole so lange zahl2 gleich 0 ist
Gib eine Meldung aus
Addiere zahl1 und zahl2
Lege das Ergebnis in ergebnis ab
Wenn ergebnis größer ist als 10 dann
Gib "Das Ergebnis ist größer als 10" aus
sonst
Gib "Das Ergebnis ist nicht größer als 10" aus

wichtigsten Programmstrukturen vor.
www.sgd.media/ml3p46
Video 3.1: Die wichtigsten Programmstrukturen
3.5 Ereignisverarbeitung
Bei vielen modernen Programmiersprachen muss ein Programm seine Anweisungen
nicht nur „stur“ der Reihe nach von oben nach unten abarbeiten. Es kann auch auf Er-
eignisse reagieren, die beim Ausführen des Programms eintreten. Solche Ereignisse kön-
nen zum Beispiel ein Mausklick auf eine Schaltfläche, ein Doppelklick an eine bestimm-
te Stelle oder auch das Drücken einer Taste sein.
Ereignisse sind eine Art Signal, das von bestimmten Aktionen ausgelöst wird.
Zu den Aktionen, die ein Ereignis auslösen, gehören zum Beispiel das Bewegen
der Maus, das Klicken, das Doppelklicken oder auch eine Tastatureingabe.
Ereignisse können an bestimmte Befehle gekoppelt werden. Ein typisches Beispiel ist ein
Doppelklick auf eine Datei, der das Öffnen der Datei veranlasst. Hier führt das Ereignis
Doppelklicken dazu, dass der Befehl Datei öffnen ausgeführt wird. Ein anderes Bei-
spiel wäre ein Mausklick auf eine Schaltfläche. Hier führt das Ereignis Klicken dazu,
dass die Anweisungen ausgeführt werden, die für die Schaltfläche programmiert wor-
den sind.
Die Ereignisverarbeitung – im Fachjargon auch event handling genannt – ist vor allem
für Programme unter grafischen Benutzeroberflächen wichtig. Hier kann ein Anwender
in der Regel zahlreiche Aktionen von unterschiedlichsten Stellen im Programm aufru-
IMIT03B 35
fen. Wenn diese Aktionen „klassisch“ programmiert werden sollten, müsste an allen ent-
sprechenden Stellen auch eine Abfrage erfolgen, ob der Anwender die Aktion tatsäch-
lich gestartet hat.
Bei der Ereignisverarbeitung dagegen wird einmal zentral festgelegt: „Wenn dieses
Ereignis eintritt, führe folgende Anweisungen aus“. Dadurch sind flexible Reaktionen
des Programms möglich – ohne enormen Aufwand betreiben zu müssen.
Außerdem kann die Ereignisverarbeitung auch zu einer höheren Betriebssicherheit von
Programmen führen, da Aktionen erst dann ausgeführt werden, wenn ein Ereignis tat-
sächlich eingetreten ist. Diese Fähigkeit ist zum Beispiel bei der Programmierung von
Internet-Anwendungen enorm wichtig, da hier nicht davon ausgegangen werden kann,
dass ein begonnenes Programm auch komplett bis zum Ende durchläuft. Möglicherweise
geht mitten im Ablauf des Programms die Verbindung zum Internet verloren, oder der
Anwender schließt den Browser, ohne das Ende des Programms abzuwarten.
Welche Ereignisse in einem Programm verarbeitet werden können, hängt von der ein-
gesetzten Programmiersprache ab. So können die meisten modernen Programmierspra-
chen wie C# oder Visual Basic Standardereignisse wie Mausaktionen oder Tastaturein-
gaben verarbeiten. Andere hochspezialisierte Programmiersprachen – wie zum Beispiel
ABAP des SAP©-Systems20 – sind auch in der Lage, auf sehr spezielle Ereignisse wie das
Verarbeiten von Datenbanktabellen zu reagieren.
So viel zu den Programmstrukturen. Im nächsten Kapitel werden Sie erfahren, in wel-
chen grundsätzlichen Schritten Software entwickelt wird.
Zusammenfassung
Über Datentypen wird festgelegt, welche Art von Daten verarbeitet werden sollen.
Bei den Programmstrukturen werden im Wesentlichen drei Grundstrukturen eingesetzt:
die Folge, die Auswahl und die Wiederholung.
Bei der Ereignisverarbeitung reagiert ein Programm mit bestimmten Aktionen auf ein
Signal.
20. Das SAP©-System der SAP SE ist ein hochintegriertes System zur Verarbeitung von Geschäftsvorfällen in
Unternehmen. Es verfügt über eine eigene Programmiersprache ABAP, über die das System angepasst und
erweitert werden kann. ABAP steht Advanced Business Application Programming (frei übersetzt etwa:
„fortgeschrittene Programmierung von Geschäftsanwendungen“).
36 IMIT03B
3.1 Nennen Sie zwei typische Ereignisse, die bei der Verarbeitung von Ereignissen
zum Einsatz kommen.
3.2 In einer Bedienungsanleitung für eine Kaffeemaschine finden Sie folgende
Anleitungen:
a) Drücken Sie erst den Einschaltknopf. Danach drehen Sie den Aromaschal-
ter nach links.
b) Stellen Sie das Mahlwerk so lange über den Drehregler ein, bis das Kaffee-
pulver mittelfein ist.
c) Wenn Sie den Timer aktivieren, können Sie Kaffee erst später aufbrühen.
Mit welchen Programmstrukturen können Sie diese Anleitungen abbilden?
IMIT03B 37
4 Entwicklung von Software

Nachdem Sie in den letzten Kapiteln Programmiersprachen und Programmstruk-
turen kennengelernt haben, wollen wir uns in diesem Kapitel ansehen, wie Soft-
ware entwickelt wird.
Moderne Software – gleichgültig, ob Betriebssystem oder Anwendungsprogramm – ist

ein hoch komplexes Gebilde. Zum Teil müssen mehrere Millionen einzelner Befehle kor-
rekt verarbeitet werden. Bereits ein kleiner Fehler in einem einzigen Befehl kann große
Folgen haben – die Ergebnisse von Berechnungen werden falsch, Maschinen stehen still,
betriebliche Abläufe geraten durcheinander, oder die Arbeit der letzten Stunden geht
verloren, weil das Programm die Daten nicht mehr speichern kann.
In den Anfängen der Computer wurden Programme häufig nach dem Versuch-und-Irr-
tum-Prinzip erstellt – im Fachjargon auch Trial and Error oder Code and Fix21 genannt.
Der Programmierer gab dem Computer einen Befehl und überprüfte dann anhand des
Ergebnisses, ob der Befehl korrekt war. Wenn das Ergebnis nicht den Erwartungen ent-
sprach, wurde der Befehl geändert. Dieses Verfahren wurde so lange wiederholt, bis das
gewünschte Ergebnis vorlag.
4.1 Die Phasen der Software-Entwicklung

Moderne Software lässt sich durch ihre enorme Komplexität nicht mehr mit solch ein-
fachen Verfahren erstellen. Die Entwicklung erfolgt mit ausgefeilten Methoden, Kon-
zepten und Verfahren des Software-Engineerings. Einen ersten kurzen Kontakt mit
diesem Teilgebiet der Informatik hatten Sie ja bereits.
Bei der Entwicklung von Software werden – stark vereinfacht – mehrere unterschied-
liche Phasen durchlaufen:
• die Analyse („Was soll die Software machen?“),
• der Entwurf („Wie soll die Software die Aufgaben lösen?“),
• die Umsetzung oder Implementierung22 – die eigentliche Programmierung,
• der Test des Systems sowie
• Betrieb und Wartung.
Die ersten vier Phasen umfassen dabei die Entstehung der Software und die letzte Phase
den Einsatz. Hier ist das Produkt also bereits komplett fertiggestellt.
Abb. 4.1: Die Phasen bei der Software-Entwicklung
21. Trial and Error ist die englische Übersetzung von Versuch und Irrtum. Code and Fix bedeutet übersetzt so
viel wie „Codieren und Reparieren“.
22. Implementierung leitet sich vom englischen Begriff to implement („realisieren, ausführen“) ab.
38 IMIT03B
Entwicklung von Software 4
Alle Phasen zusammen in ihrer zeitlichen Abfolge werden auch als Software-
Lebenszyklus oder Software Life Cyclea) bezeichnet. Der Software-Lebenszyklus
ist also die Zeitspanne, in der ein Softwareprodukt entwickelt und eingesetzt wird –
bis zum Ende seiner Benutzung.
a) Software Life Cycle ist die englische Übersetzung von Softwarelebenszyklus.
Schauen wir uns die einzelnen Phasen der Reihe nach an einem praktischen Beispiel an.
Es soll ein Programm entwickelt werden, das Zahlen aus dem Dezimalsystem in das
Dualsystem umrechnen kann.
Phase 1: Die Analyse

In der ersten Phase wird das zu lösende Problem möglichst exakt analysiert. Diese Auf-
gabe übernehmen häufig Spezialisten.
In unserem Beispiel ist die Analyse nicht sonderlich aufwendig und kompliziert, da das
Problem ja recht einfach und nicht sonderlich umfangreich ist. Die Antwort auf die Fra-
ge „Was soll das Programm machen?“ ist daher schnell gefunden: „Das Programm soll
Zahlen vom Dezimalsystem in das Dualsystem umrechnen.“
Phase 2: Der Entwurf

In der zweiten Phase wird das Gesamtsystem zunächst einmal – falls erforderlich – in
mehrere übersichtliche Teilprobleme aufgegliedert. Für jedes einzelne Teilproblem wer-
den dann konkrete Lösungsmöglichkeiten erarbeitet – die Algorithmen. Diese Algorith-
men werden zunächst in allgemeiner Form beschrieben – zum Beispiel durch umgangs-
sprachliche Darstellungen und Grafiken.
Zur Auffrischung:
Ein Algorithmus ist – vereinfacht ausgedrückt – eine Vorschrift zur Lösung eines
Problems.
In unserem einfachen Beispiel ist der Algorithmus ebenfalls nicht sonderlich kompli-
ziert. Wenn Sie noch einmal an das letzte Studienheft zurückdenken, erfolgt die Umrech-
nung durch fortlaufende Divisionen durch die Basiszahl des gewünschten Zahlensys-
tems – und zwar so lange, bis Sie den Wert 0 als Ergebnis erhalten. Der Rest jeder
Division steht dabei für die Ziffer – allerdings in umgekehrter Reihenfolge.
Zur Auffrischung noch einmal ein Beispiel:
Der dezimale Wert 11 soll in das Dualsystem umgerechnet werden. Die Rechnung sieht
so aus:
11 : 2  5 Rest 1
5:22 Rest 1
2:21 Rest 0
1:20 Rest 1
Von unten nach oben gelesen ergeben die Reste dann den dualen Wert 1011.
IMIT03B 39
Ein entsprechender Algorithmus zur Umrechnung könnte umgangssprachlich formu-

liert so aussehen:
Lies den Wert ein, der umgerechnet werden soll
Wiederhole
Teile den Wert durch 2
Merke den Rest
Benutze das Ergebnis der Division als neuen Wert
solange das Ergebnis der Division ungleich 0
Gib die gemerkten Reste in umgekehrter Reihenfolge aus
Die grafische Darstellung für unseren Algorithmus sieht so aus:
Abb. 4.2: Der Algorithmus zum Umrechnen vom Dezimal- ins Dualsystem
40 IMIT03B
Hinweis:
Mit dem Lösen von Problemen und dem Entwickeln von Algorithmen werden wir
uns gleich noch ein wenig intensiver beschäftigen.
Phase 3: Die Implementierung

Bei der Implementierung werden die Algorithmen aus der Entwurfsphase in konkrete
Anweisungen einer Programmiersprache umgesetzt. Da dafür umfangreiche Vorkennt-
nisse erforderlich sind, wollen wir uns damit hier nicht weiter beschäftigen. Sie werden
das Programm aber später mit Python erstellen.
Phase 4: Der Test

In der vierten Phase wird das Programm umfangreichen Tests unterzogen. Dabei wer-
den möglichst viele Fehler aufgespürt und beseitigt. Als Endergebnis steht das fertige
Programm, das ausgeliefert werden kann.
Trotz sorgfältiger Programmierung und umfangreicher Tests lassen sich Fehler in

Software-Systemen allein schon durch die enorme Komplexität nicht immer vermei-
den. Solche Fehler können unter ungünstigen Umständen dazu führen, dass ein Pro-
gramm plötzlich beendet wird oder nicht mehr korrekt arbeitet. Im Fachjargon wird
der Programmabbruch durch einen Fehler als Absturz bezeichnet.
In unserem Fall ließe sich ein erster, sehr einfacher Test durch einige beispielhafte Um-
rechnungen durchführen. Die Ergebnisse werden dabei jeweils durch Gegenrechnungen
geprüft und auch mit anderen Werkzeugen – wie zum Beispiel dem Taschenrechner von
Windows – kontrolliert.
Die Gegenrechnung für den Wert 1011 in unserem Beispiel sieht so aus:
1 · 23  0 · 22  1 · 21 + 1 · 20
 1·80·41·21·1
 8021
 11
Das Ergebnis ist 11 – also korrekt. Besonders brauchbar ist dieser Test allerdings nicht,
da wir ja – streng genommen – nicht unseren Algorithmus testen, sondern nur das
grundsätzliche Vorgehen. Für einen aussagekräftigeren Test müssten Sie die einzelnen
Schritte des Algorithmus auf dem „Trockenen“ durchgehen oder das fertige Programm
verwenden. Einen Test mit dem fertigen Programm holen wir ebenfalls später nach.
Bitte beachten Sie:

Unser Programm ist bewusst sehr einfach gehalten und nicht sonderlich betriebs-
sicher. So prüfen wir ja zum Beispiel gar nicht, ob überhaupt ein gültiger dezimaler
Wert eingegeben wurde. Die Eingabe des Buchstaben A oder der hexadezimalen
Zahl 16FF würde unser Programm in große Schwierigkeiten bringen.
IMIT03B 41
Phase 5: Der Betrieb und die Wartung

In der letzten Phase schließlich wird das Programm in Betrieb genommen. Dabei treten
in der Regel noch weitere Fehler und Unstimmigkeit auf, die eine Wartung erforderlich
machen. Außerdem muss das Programm an Änderungen in der Umgebung angepasst
werden – zum Beispiel an neue Versionen eines Betriebssystems oder Änderungen bei
gesetzlichen Vorgaben.
Hinweis:
Aus dem grundlegenden Phasenmodell wurden verschiedene konkrete Vorgehens-
modelle entwickelt – zum Beispiel das Software Life Cycle-Modell, das V-Modell
und der Rational Unified Process. Mit diesen Modellen wollen wir uns hier aber
nicht weiter beschäftigen.
Da die Entwicklung von Software bei einer strikten Trennung von Analyse, Entwurf
und Implementierung sehr lange dauern kann und auch nicht immer die gewünsch-
ten Ergebnisse liefert, kommen auch agile Methoden zum Einsatz. Sie versuchen,
möglichst schnell zu einer einsatzfähigen Software zu kommen, die dann Schritt für
Schritt erweitert wird. Zu den agilen Methoden gehören zum Beispiel Extreme Pro-
gramming und Scrum. Auch mit diesen Modellen wollen wir uns aber nicht weiter
beschäftigen.
4.2 Das Lösen von Problemen

Eine sehr wichtige Phase beim Entwickeln von Software ist das Erarbeiten von konkre-
ten Lösungsmöglichkeiten für eine Aufgabe – der Entwurf. Es gibt zwar für viele Anfor-
derungen im IT-Bereich mittlerweile fertige Lösungen, die universell eingesetzt werden
können, trotzdem stehen die Entwickler häufig vor der Frage: „Wie lässt sich ein konkre-
tes Problem genau lösen?“
Auch wenn für die Antwort auf diese Frage Kreativität und Erfahrung wichtig sind, gibt
es einige Techniken, die beim Lösen von Problemen helfen können. Dazu gehören zum
Beispiel
• Versuch-und-Irrtum,
• Analogiebildung,
• Variation oder
• Rückwärtssuche.
Bei Versuch-und-Irrtum wird eine Vermutung angestellt, die durch Ausprobieren über-
prüft wird. So kann direkt herausgefunden werden, ob die Vermutung stimmt oder
nicht. Stimmt sie nicht, wird mit der nächsten Vermutung weitergemacht, bis entweder
das Problem gelöst ist oder auch nicht.
Die Versuch-und-Irrtum-Methode ist zwar nicht unbedingt „streng wissenschaftlich“,
kann anderen Methoden aber trotzdem überlegen sein. Das ist vor allem dann der Fall,
wenn es um eng begrenzte Bereiche mit einer fest definierten Auswahl geht. So lassen
sich zum Beispiel Kennwörter oder auch Zahlenkombinationen durch einfaches Raten
herausfinden. Es werden einfach so lange alle Kombinationen ausprobiert, bis die
42 IMIT03B
Lösung gefunden wurde. Mit Unterstützung des Computers geht das sogar sehr schnell.
Ein Kennwort mit einigen wenigen Buchstaben wird zum Beispiel innerhalb weniger
Minuten „geknackt“.
Dieses Ausprobieren aller möglichen Kombinationen wird auch brute force

genannt. Brute force bedeutet übersetzt so viel wie „brutale Gewalt“.
So viel zu Versuch-und-Irrtum.
Bei der Analogiebildung wird nach ähnlichen Problemen gesucht, die bereits gelöst
wurden. Aus diesen Lösungen wird dann versucht, eine neue Lösung abzuleiten.
Die Variation arbeitet ähnlich wie die Analogiebildung. Allerdings wird hier das aktu-
elle Problem leicht abgewandelt. Über das abgewandelte Problem wird dann versucht,
schneller zur Lösung zu kommen.
Bei der Rückwärtssuche schließlich versucht man, vom Ergebnis zum Ausgangspunkt
zu kommen – und nicht wie üblich vom Ausgangspunkt zum Ergebnis.
Die Methoden zur Lösung von neuen, unbekannten Problemen werden Heuristiken
genannt. Die Heuristik allgemein beschäftigt sich damit, mit wenig Aufwand und
wenig Zeit zu guten Lösungen eines Problems zu kommen. Die Heuristik will dabei
vor allem gute Lösungen liefern – keine optimalen.
4.3 Das Entwickeln von Algorithmen

Neben den Heuristiken, die allgemein für die Lösung von neuen Problemen eingesetzt
werden, gibt es aber auch ganz konkrete Beschreibungen für die Lösung von bekannten
Problemen – die Algorithmen. Ein Beispiel für solch einen Algorithmus haben Sie ja be-
reits weiter oben bei der Umrechnung von Dezimalzahlen in Dualzahlen kennengelernt.
Algorithmen finden Sie nicht nur in der Informationstechnik. Auch ein Backrezept oder
eine Bauanleitung für ein Modell sind Algorithmen. Sie beschreiben ja ebenfalls konkret
die Lösung eines bekannten Problems – eben „Wie bereite ich einen Käsekuchen für
sechs Personen zu?“ oder „Wie baue ich ein U-Boot-Modell aus den vorhandenen Ein-
zelteilen?“.
Neben Algorithmen, die ganz konkret für ein bestimmtes Problem eingesetzt werden,
gibt es auch Algorithmen, die Lösungen für einen Problembereich anbieten. Zwei klas-
sische Gebiete in der Informationstechnik sind zum Beispiel das Suchen nach Daten und
das Sortieren von Daten. Hier gibt es unterschiedlichste Algorithmen, die mit mehr oder
weniger Aufwand zum Ziel führen.
Schauen wir uns zuerst zwei Beispiele für die Suche an – die lineare Suche und die
binäre Suche.
Die lineare Suche – auch sequenzielle Suche genannt – ist das einfachste Suchverfah-
ren. Hier wird der gesuchte Wert der Reihe nach mit allen vorhandenen Werten ver-
glichen, bis der Wert gefunden wurde oder keine weiteren Werte zum Vergleich mehr
vorhanden sind.
IMIT03B 43
Nehmen wir einmal an, in einer Liste mit den vier Zahlen 10, 20, 30 und 40 soll nach
dem Wert 20 gesucht werden. Zuerst wird der gesuchte Wert – also 20 – mit dem ersten
Wert in der Liste – also 10 – verglichen. Die beiden Werte stimmen nicht überein. Also
wird die Suche mit dem zweiten Wert in der Liste fortgeführt. Er stimmt mit dem ge-
suchten Wert überein. Die Suche kann also beendet werden.
Die lineare Suche ist zwar sehr einfach, aber eigentlich nur bei sehr kurzen Listen zu
gebrauchen. Denn im ungünstigsten Fall muss ja immer die komplette Liste durchsucht
werden – und das kann bei langen Listen sehr aufwendig werden.
Die binäre Suche versucht daher, die Liste schrittweise zu verkleinern und so die zu
durchsuchende Menge zu reduzieren. Dazu wird die Liste immer wieder in zwei Teile
zerlegt, bis entweder der gesuchte Wert gefunden wird oder eine weitere Halbierung
nicht möglich ist. Gesucht wird dann immer nur noch in der Hälfte der Liste.
Die binäre Suche funktioniert nur dann, wenn die Liste, die durchsucht werden soll,
geordnet ist – zum Beispiel vom kleinsten zum größten Wert aufsteigend sortiert.
Schauen wir uns jetzt auch die binäre Suche an einem Beispiel an:
Nehmen wir einmal an, in einer Liste stehen 10 Zahlen, die aufsteigend sortiert sind.
Abb. 4.3: Die aufsteigend sortierte Liste
Gesucht wird nach der Zahl 123.

Im ersten Schritt wird die Mitte der Liste ermittelt. Diese Mitte wird benutzt, um die
Liste in zwei annähernd gleich große Teile zu zerlegen.
Im zweiten Schritt wird das Element in der Mitte mit dem gesuchten Wert verglichen.
Stimmen das mittlere Element und der gesuchte Wert nicht überein, gibt es durch die
aufsteigende Sortierung der Liste nur zwei Möglichkeiten:
Wenn die gesuchte Zahl größer ist als das mittlere Element, kann sie sich nur im rechten
Teil der Liste befinden.
Ist die gesuchte Zahl dagegen kleiner als das mittlere Element, kann sie sich nur im lin-
ken Teil der Liste befinden.
1 4 6 9 11 18 22 98 123 129
kleiner Vergleich? größer
Abb. 4.4: Die geteilte Liste
44 IMIT03B
In den nächsten Schritten wird die Liste nach diesem Verfahren immer weiter halbiert.
Für unser Beispiel ergibt sich damit der folgende Suchweg:
1. Schritt: Die erste Halbierung ergibt als Mitte die Position 5. Dieses Element hat den
Wert 11. Die gesuchte Zahl – 123 – ist größer als dieser Wert. Sie kann sich
damit nur im rechten Teil der Liste befinden.
Abb. 4.5: Die erste Halbierung der Liste
Hinweis:
Ob Sie die Liste vor oder hinter der Mitte teilen, spielt keine Rolle.
2. Schritt: Die zweite Halbierung der Liste ergibt als Mitte die Position 8. Der Wert
dieses Elements ist 98. Die gesuchte Zahl ist wieder größer als dieser Wert.
Sie kann sich also wieder nur im rechten Teil der Liste befinden.
Abb. 4.6: Die zweite Halbierung der Liste
3. Schritt: Die dritte Halbierung der Liste ergibt als Mitte die Position 9. Der Wert die-
ses Elements ist 123. Damit wurde die Zahl gefunden.
1 2 3 4 5 6 7 8 9 10
1 4 6 9 11 18 22 98 123 129
Abb. 4.7: Die dritte Halbierung der Liste

binäre Suche vor.
www.sgd.media/3g3zoo
Video 4.1: Die binäre Suche
Statt neun Vergleichen wie bei der linearen Suche waren bei der binären Suche also nur
drei Vergleiche erforderlich. Damit ist die Suche deutlich schneller – auch wenn der
Aufwand für die Verwaltung der Liste durch die Halbierungen höher ist.
So viel zum Suchen. Kommen wir nun zu den Sortierverfahren. Beginnen wir auch hier
mit einer sehr einfachen Variante – der einfachen Maximumauswahl.
IMIT03B 45
Hier wird die Folge, die sortiert werden soll, in einen sortierten und einen unsortierten
Bereich geteilt. Der sortierte Bereich ist zunächst leer, enthält also kein Element. Solange
der unsortierte Bereich mehr als ein Element enthält, geschieht folgendes:
1. Das letzte Element des unsortierten Bereichs wird als vorläufiges Maximum defi-
niert.
2. Es wird überprüft, ob es im unsortierten Bereich größere Elemente als das vorläufige
Maximum gibt. Wenn ja, werden das größte Element und das Element mit dem vor-
läufigen Maximum getauscht.
3. Der unsortierte Bereich wird am Ende um ein Element verkleinert. Damit wird das
jeweils letzte Element beim nächsten Durchlauf nicht mehr berücksichtigt.
Schauen wir uns dieses Verfahren wieder an einem praktischen Beispiel an:
Nehmen wir einmal an, in einer Liste stehen vier Werte.
Abb. 4.8: Die unsortierte Liste
Das Sortieren erfolgt dann in den folgenden Schritten:

1. Schritt: Der Wert des letzten Elements – also 2 – wird zum vorläufigen Maximum.
2. Schritt: Der unsortierte Bereich – hier noch die gesamte Liste – wird nach dem
größten Wert durchsucht. Das Ergebnis ist 9.
3. Schritt: Das vorläufige Maximum – die 2 – und der größte Wert – die 9 – werden
getauscht.
4. Schritt: Der unsortierte Bereich wird am Ende um 1 verkleinert. Damit besteht die
Liste jetzt aus drei unsortierten Elementen und einem sortierten Element.
Abb. 4.9: Die Liste mit drei unsortierten Elementen und einem sortierten
Element
5. Schritt: Das letzte Element im unsortierten Bereich – also der Wert 6 – wird zum
vorläufigen Maximum.
6. Schritt: Der unsortierte Bereich wird nach dem größten Wert durchsucht. Das
Ergebnis ist ebenfalls 6. Es ist also kein Tausch erforderlich.
Liste jetzt aus zwei unsortierten Elementen und zwei sortierten Elementen.
Abb. 4.10: Die Liste mit zwei unsortierten und zwei sortierten Elementen
46 IMIT03B
8. Schritt: Das letzte Element im unsortierten Bereich – also der Wert 1 – wird zum
vorläufigen Maximum.
9. Schritt: Der unsortierte Bereich wird nach dem größten Wert durchsucht. Das
Ergebnis ist 2.
10. Schritt: Das vorläufige Maximum – die 1 – und der größte Wert – die 2 – werden
getauscht.
Liste jetzt aus einem unsortierten Element und drei sortierten Elementen.
Die Sortierung ist also abgeschlossen.
Abb. 4.11: Die sortierte Liste

einfache Maximumauswahl vor.
www.sgd.media/ohjn0u
Video 4.2: Die einfache Maximumauswahl
Ein anderes Sortierverfahren ist Bubblesort – frei übersetzt „Blasensortierung“. Auch

hier wird die Liste zunächst wieder in einen sortierten und unsortierten Bereich geteilt.
Der sortierte Bereich ist zu Beginn ebenfalls leer.
Solange der unsortierte Bereich mehr als ein Element enthält, geschieht Folgendes:
1. Der unsortierte Bereich wird vom Anfang bis zum Ende durchlaufen. Dabei wird das
aktuelle Element der Liste mit seinem Nachfolger verglichen.
2. Wenn der Nachfolger kleiner ist als das aktuelle Element, werden die beiden Ele-
mente getauscht.
3. Wenn das Ende der Liste erreicht wurde, steht das größte Element hinten. Der un-
sortierte Bereich wird am Ende um ein Element verkleinert. Damit wird das jeweils
letzte Element beim nächsten Durchlauf nicht mehr berücksichtigt.
Schauen wir uns auch Bubblesort an einem konkreten Beispiel an. Nehmen wir diesmal
an, in einer Liste stehen die folgenden vier Werte.
Abb. 4.12: Die unsortierte Liste
IMIT03B 47
Das Sortieren erfolgt dann in den folgenden Schritten:

1. Schritt: Das erste Element wird mit seinem Nachfolger verglichen.
2. Schritt: 32 ist größer als 11 – also werden die Elemente getauscht.
3. Schritt: 32 – jetzt an der Position 2 – wird mit seinem Nachfolger verglichen.
4. Schritt: 32 ist kleiner als 43 – also werden die Elemente nicht getauscht.
5. Schritt: Jetzt wird das dritte Element mit dem vierten verglichen. Da im vorigen
Schritt kein Tausch erfolgt ist, wird hier also 43 mit 8 verglichen.
6. Schritt: 43 ist größer als 8 – also werden die Elemente wieder getauscht.
7. Schritt: Alle Elemente im unsortierten Bereich wurden getauscht. Der unsortierte
Bereich wird am Ende um 1 verkleinert.
9. Schritt: 11 ist kleiner als 32 – also erfolgt kein Tausch.
10. Schritt: Jetzt wird das zweite Element mit dem dritten verglichen. Da im vorigen
Schritt kein Tausch erfolgt ist, wird hier also 32 mit 8 verglichen.
11. Schritt: 32 ist größer als 8 – also werden die Elemente getauscht.
14. Schritt: 11 ist größer als 8 – also erfolgt ein Tausch.
Damit enthält der unsortierte Bereich nur noch ein Element und das Sortieren wird
beendet.
Die einzelnen Schritte sehen Sie auch noch einmal zusammengefasst in der folgenden
Grafik:
Abb. 4.13: Bubblesort
48 IMIT03B
Wie Sie sehen, rutschen die kleinen Zahlen im unsortierten Bereich schrittweise nach
vorne. Sie steigen also – wenn Sie so wollen – wie eine Blase in einem Glas Wasser nach
oben. Daher auch der Name Bubblesort.
In diesem Video stellen wir Ihnen das

Sortierverfahren Bubblesort vor.
www.sgd.media/hqqmfc
Video 4.3: Bubblesort
Besonders effektiv sind weder die einfache Maximumauswahl noch Bubblesort. Vor
allem Bubblesort benötigt unter Umständen sehr viele Sortiervorgänge, da im Extrem-
fall jedes Element mit jedem anderen Element verglichen werden muss. Es gibt daher
noch sehr viel mehr Sortierverfahren, die deutlich schneller arbeiten, aber auch sehr viel
komplizierter sind – zum Beispiel Quicksort. Eine sehr gute Übersicht finden Sie zum
Beispiel im Internet auf der Seite https://de.wikipedia.org/wiki/Liste_von_Algorithmen
im Bereich Sortieralgorithmen. Dort werden auch noch zahlreiche weitere Suchalgorith-
men vorgestellt.
Bitte beachten Sie:

Ein Algorithmus ist häufig eine mehr oder weniger abstrakte Beschreibung zur
Lösung eines Problems. Diese Beschreibung muss in vielen Fällen erst in die Befehle
einer Programmiersprache umgesetzt werden. Ein Algorithmus beschreibt damit
also in allgemeiner Form, was ein Programm beziehungsweise ein Teil eines Pro-
gramms machen soll.
So viel an dieser Stelle zur Entwicklung von Software. Im weiteren Verlauf werden Sie
selbst als Programmierer aktiv. Sie erstellen kleine Programme mit der Programmier-
sprache Python.
Zusammenfassung
Die Entwicklung moderner Software-Systeme erfolgt mit den Methoden, Konzepten

und Verfahren des Software-Engineerings. Dabei werden mehrere Phasen durchlaufen.
Beim Lösen von Problemen können verschiedene Techniken eingesetzt werden – zum
Beispiel Versuch-und-Irrtum oder die Rückwärtssuche.
Methoden zur Lösung von neuen, unbekannten Problemen werden Heuristiken genannt.
Für verschiedene Bereiche der Informationstechnik gibt es unterschiedliche Algorith-
men – zum Beispiel für das Suchen von Daten oder das Sortieren von Daten.
IMIT03B 49
4.1 Nennen Sie die fünf wesentlichen Phasen bei der Entwicklung von Software-
Systemen.
4.2 Was ist der Software-Lebenszyklus?
4.3 Was verstehen Sie unter einem Algorithmus?
4.4 Was unterscheidet die binäre Suche von der linearen Suche? Denken Sie dabei
auch an die Voraussetzungen.
50 IMIT03B
Schlussbetrachtung
In diesem Studienheft haben Sie sich vor allem theoretisch mit dem Programmieren von
Computern beschäftigt. Sie haben gelernt, warum Computer überhaupt programmiert
werden müssen und wie dabei grundsätzlich vorgegangen wird. Außerdem haben Sie
mit einigen Programmiersprachen Bekanntschaft gemacht und kennen wichtige Grund-
strukturen für die Programmierung.
Christoph Siebeck
IMIT03B 51
A. Lösungen zu den Aufgaben zur Selbstüberprüfung

Hier finden Sie die Lösungen zu den Aufgaben zur Selbstüberprüfung in den einzelnen
Kapiteln. Bei offenen Aufgaben mit freien Formulierungen kommt es nicht auf eine
wörtliche Übereinstimmung an, sondern auf den Inhalt. Entsprechen Ihre Ergebnisse
nicht den Lösungen, wiederholen Sie bitte das entsprechende Kapitel und bearbeiten Sie
die zugehörigen Aufgaben zur Selbstüberprüfung nach einer Pause erneut.
Kapitel 1
1.1 Die ersten Lochkarten beziehungsweise Lochstreifen kamen bei Webstühlen
zum Einsatz.
1.2 Die elektrischen und elektronischen Bauelemente waren bei den ersten Compu-
tern so teuer, dass nach Möglichkeiten gesucht wurde, die Geräte möglichst uni-
versell einzusetzen. Die Rechner sollten unterschiedlichste Programme bearbei-
ten können.
1.3 Nein, ein Computer kann nicht selbstständig entscheiden, ob das Ergebnis seiner
Arbeit sinnvoll ist. Ein Computer kann nicht „denken“, sondern führt nur die
Aufgaben aus, die ihm vorgegeben wurden.
Kapitel 2
2.1 Ein Assembler verwendet sehr kurze, schwer zu merkende Anweisungen – die
Mnemonics. Eine Hochsprache dagegen orientiert sich stärker an der menschli-
chen Sprache und arbeitet mit vergleichsweise einfach zu behaltenden Befehlen.
Ein Assembler ist außerdem eine 1:1-Programmiersprache. Das heißt, jede An-
weisung im Assembler wird in eine Anweisung für den Computer umgesetzt.
Hochsprachen sind dagegen 1:n-Programmiersprachen. Hier wird eine Anwei-
sung in der Hochsprache in mehrere Anweisungen für den Computer umgesetzt.
2.2 Nein, ein Programm, das in Maschinensprache erstellt wurde, kann nicht auf
einem beliebigen Prozessor ablaufen. Programme in Maschinensprache sind
immer auf einen bestimmten Prozessortyp zugeschnitten.
2.3 Ein Mnemonic ist ein kurzer Befehl, der bei einem Assembler eingesetzt wird.
2.4 Ein Quelltext enthält Anweisungen für ein Programm in dem Format der jewei-
ligen Programmiersprache. Der Quelltext kann nicht direkt ausgeführt werden.
2.5 Die Auswahl der Programmiersprache C# für diese Aufgabe ist nicht besonders
glücklich. Es müssten viele erforderliche Elemente selbst programmiert werden.
Besser geeignet für diese Aufgabe wäre ein spezielles Multimedia-Werkzeug
oder ein Autorensystem.
2.6 Beim Rapid Application Development werden vorgefertigte Komponenten in ein
eigenes Programm eingefügt und angepasst. Auf diese Weise kann die Entwick-
lung erheblich beschleunigt werden.
2.7 Für die Aufgabe benötigen Sie eine plattformunabhängige Programmiersprache.
Dazu gehören zum Beispiel Java, Python und – mit Einschränkungen – auch C#.
52 IMIT03B
Lösungen zu den Aufgaben zur Selbstüberprüfung A
Kapitel 3
3.1 Zu den typischen Ereignissen, die bei der Ereignisverarbeitung zum Einsatz
kommen, gehören
• das Drücken einer Taste,
• ein Mausklick oder
• ein Doppelklick.
Für die richtige Antwort reicht es aus, wenn Sie zwei Ereignisse genannt haben.
3.2 a) Es handelt sich um eine Folge oder Sequenz. Die Schritte werden hinterein-
ander ausgeführt.
b) Es handelt sich um eine Wiederholung. Die Einstellung wird so lange durch-
geführt, bis ein bestimmter Zustand erreicht ist.
c) Es handelt sich um eine Auswahl. Die Anweisung ist an eine Bedingung
geknüpft.
Kapitel 4
4.1 Die fünf wesentlichen Phasen bei der Entwicklung von Software-Systemen sind:
• die Analyse,
• der Entwurf,
• die Umsetzung,
• der Test sowie
• Betrieb und Wartung.
4.2 Der Software-Lebenszyklus fasst die Phasen bei der Entwicklung von Software
zusammen. Er beschreibt die Zeitspanne, in der ein Softwareprodukt entwickelt
und eingesetzt wird.
4.3 Ein Algorithmus ist – vereinfacht ausgedrückt – eine Vorschrift zur Lösung eines
Problems.
4.4 Die binäre Suche halbiert die zu durchsuchende Liste bei jedem Durchgang und
setzt die Suche in der verbleibenden Hälfte fort. Sie kann nur in einer sortierten
Liste durchgeführt werden.
Die lineare Suche durchsucht die Liste von vorne bis hinten, bis das Element
gefunden wurde oder die Liste durchsucht wurde. Die Liste kann daher auch
unsortiert vorliegen.
IMIT03B 53
B. Glossar
.NET-Konzept Beim .NET-Konzept (ausgesprochen: „dot net“) werden
die Programme nicht direkt in ausführbare Anwendun-
gen übersetzt, sondern zunächst in eine Zwischenspra-
che – die CIL – umgesetzt. Diese Zwischensprache wird
dann auf jedem einzelnen Computer durch einen Just in
Time-Compiler in ein ausführbares Programm umge-
wandelt.
1:1-Programmiersprache Eine 1:1-Programmiersprache ist eine Programmierspra-
che, bei der ein Befehl auch einem Befehl für den Com-
puter entspricht.
1:n-Programmiersprache Eine 1:n-Programmiersprache ist eine Programmierspra-
che, bei der ein Befehl in mehrere Befehle für den Com-
puter umgesetzt wird.
ABAP ABAP ist eine spezielle Programmiersprache des SAP©-
Systems. ABAP steht für Advanced Business Applica-
tion Programming.
Absturz Ein Absturz ist im Fachjargon ein Programm-abbruch
durch einen Fehler.
Agile Methode Agile Methoden versuchen möglichst schnell zu einem
einsatzfähigen Produkt zu kommen. Das Produkt wird
dann in mehreren Schritten erweitert.
Algorithmus Ein Algorithmus ist eine präzise formulierte und eindeu-
tige Vorschrift zur Lösung eines Problems. Typische Bei-
spiele für Algorithmen sind Formeln zur Berechnung
oder Kochrezepte.
Alphanumerisch Eine alphanumerische Zeichenfolge besteht neben Zif-
fern auch aus Buchstaben beziehungsweise Sonder-
zeichen.
Alternative Verzweigung Die alternative Verzweigung ist eine Programmstruktur.
Wenn eine Bedingung zutrifft, werden bestimmte An-
weisungen ausgeführt. Trifft die Bedingung nicht zu,
werden andere Anweisungen ausgeführt.
Analogie Eine Analogie ist eine Ähnlichkeit oder Entsprechung.
Assembler Assembler war eine der ersten Programmiersprachen.
Die Programmierung erfolgt über Mnemonics.
Die Bezeichnung Assembler wird aber auch für das Pro-
gramm benutzt, das die Umwandlung der Anweisungen
in ein für den Computer verständliches Format durch-
führt.
54 IMIT03B
Glossar B
Auswahlstruktur Über Auswahlstrukturen können beim Programmieren

Anweisungen in Abhängigkeit von Bedingungen aus-
geführt werden. Dazu wird zunächst überprüft, ob eine
Bedingung „wahr“ oder „falsch“ ist. Im einfachsten Fall
wird nur dann eine bestimmte Anweisung ausgeführt,
wenn die Bedingung zutrifft.
Neben den einfachen Verzweigungen unterstützen viele
Programmiersprachen auch alternative Verzweigungen
und Mehrfachverzweigungen.
Autorensystem Ein Autorensystem ist ein spezielles Programm, das die
schnelle Entwicklung von Anwendungen ermöglicht.
Dazu werden zum Beispiel Inhalte mit der Maus an den
gewünschten Stellen platziert. Viele Autorensysteme
ermöglichen auch eine visuelle Programmierung. Hier
können Anweisungen über entsprechende Symbole
umgesetzt werden.
Autorensysteme werden sehr häufig für die Erstellung
von Computerlernprogrammen eingesetzt.
Basiszahl Die Basiszahl ist die Zahl in einem Zahlensystem, die für
die Bildung der Stellenwerte benutzt wird.
Batchprogramm Ein Batchprogramm ist ein Programm, bei dem die Be-
fehle der Reihe nach von oben nach unten abgearbeitet
werden.
Binäre Suche Bei der binären Suche wird die zu durchsuchende Liste
bei jedem Durchlauf halbiert. Weitergesucht wird nur in
einer Hälfte der Liste.
Die binäre Suche erwartet eine sortierte Liste.
Binäres System Ein binäres System ist ein System mit genau zwei ein-
deutigen Zuständen – zum Beispiel 0 und 1.
brute force Als brute force wird das Ausprobieren aller möglichen
Kombinationen zum Beispiel für ein Kennwort genannt.
Brute force ist damit – wenn Sie so wollen – ein Versuch-
und-Irrtum-Verfahren.
Bubblesort Bubblesort ist ein Sortierverfahren.
Bytecode Der Bytecode wird bei der Übersetzung von Program-
men als eine Art Zwischenprodukt erzeugt. Er stellt kein
direkt ausführbares Programm dar.
Bei der Ausführung wird der Bytecode durch eine virtu-
elle Maschine – die Virtual Machine – interpretiert.
Bytecode kommt unter anderem bei den Programmier-
sprachen Java und Python zum Einsatz.
IMIT03B 55
B Glossar
C# Die Programmiersprache C# fasst die Stärken der Pro-

grammiersprachen Java und C++ zusammen. C# ist in
das .NET-Konzept der Firma Microsoft integriert.
Das Zeichen # wird „sharp“ ausgesprochen.
C++ C++ ist eine sehr weitverbreitete Programmiersprache.
Sie ist durch ISO standardisiert.
CIL CIL ist die Abkürzung für Common Intermediate Lan-
guage.
COBOL COBOL ist eine Programmiersprache für kaufmännische
Anwendungen.
Code and Fix Code and Fix ist eine Bezeichnung für das Programmie-
ren nach Versuch-und-Irrtum.
Common Intermediate Die Common Intermediate Language bildet beim .NET-
Language (CIL) Konzept eine Art Zwischensprache. In diese Zwischen-
sprache werden die Anwendungen zunächst übersetzt.
Die endgültige Übersetzung erfolgt durch einen Just in
Time-Compiler auf jedem einzelnen Computer.
Compiler Ein Compiler setzt die Anweisungen einer Program-
miersprache in ein ausführbares Programm um. Nach
der Übersetzung kann das Programm direkt vom Be-
triebssystem ausgeführt werden.
Datentyp Der Datentyp beschreibt bei der Programmierung, wel-
che Informationen mit einem Datenobjekt verarbeitet
werden.
Dezimalsystem Das Dezimalsystem ist ein Zahlensystem mit der Basis-
zahl 10.
Dialekt Ein Dialekt ist eine Version einer Programmiersprache.
Die verschiedenen Dialekte weichen zum Teil erheblich
voneinander ab.
Dualsystem Das Dualsystem ist ein Stellenwertsystem mit der Basis-
zahl 2.
Editor Ein Editor ist ein Programm zum Erfassen und Bearbei-
ten von Informationen.
Eigenschaft Die Eigenschaften beschreiben bei der Objektorientie-
rung die Daten eines Objekts.
Einfache Maximumauswahl Die einfache Maximumauswahl ist ein Sortierverfahren.
Einfache Verzweigung Die einfache Verzweigung ist eine Programmstruktur.
Hier werden Anweisungen nur dann ausgeführt, wenn
eine Bedingung zutrifft.
56 IMIT03B
Glossar B
Entwicklungsumgebung Entwicklungsumgebungen werden für die Erstellung

von Programmen eingesetzt. Sie stellen dem Program-
mierer fertige Objekte wie zum Beispiel Bedienelemente
und Dialoge zur Verfügung, die mit ein paar Mausklicks
in das eigene Programm eingebunden werden können.
Ereignis Ereignisse sind eine Art Signal, das von bestimmten Ak-
tionen ausgelöst wird. Zu den Aktionen, die ein Ereignis
auslösen, gehören zum Beispiel das Bewegen der Maus,
das Klicken, das Doppelklicken oder auch eine Tastatur-
eingabe.
Ereignisverarbeitung Die Ereignisverarbeitung ist eine Form der Programmie-
rung. Hier werden die einzelnen Anweisungen nicht
mehr der Reihe nach ausgeführt, sondern das Programm
kann auf Ereignisse reagieren – zum Beispiel einen
Mausklick an eine bestimmte Stelle.
Event handling Event handling ist die englische Bezeichnung für Ereig-
nisverarbeitung.
Extreme Programming Extreme Programming ist ein Vorgehensmodell zur Soft-
wareentwicklung.
Folge Eine Folge – auch Sequenz genannt – ist die einfachste
Programmstruktur. Hier werden die einzelnen Anwei-
sungen der Reihe nach ausgeführt. Wenn Anweisung 1
abgearbeitet ist, wird Anweisung 2 ausgeführt und so
weiter.
FORTRAN FORTRAN war eine der ersten höheren Programmier-
sprachen.
Heuristik Die Heuristik allgemein beschäftigt sich damit, mit we-
nig Aufwand und wenig Zeit zu guten Lösungen eines
Problems zu kommen. Die Heuristik will dabei vor allem
gute Lösungen liefern – keine optimalen.
Heuristiken Heuristiken sind Methoden zur Lösung von neuen,
unbekannten Problemen.
Hexadezimales Zahlensys- Das hexadezimale Zahlensystem ist ein Zahlensystem
tem mit der Basiszahl 16. Die Ziffern über 9 werden durch
Buchstaben dargestellt.
Hochsprache Hochsprachen erlauben eine Programmierung von
Computern in einer Form, die der menschlichen Sprache
in Teilen sehr nahekommt und bekannte Symbole – zum
Beispiel + – benutzt.
Eine typische Anweisung einer Hochsprache sieht zum
Beispiel so aus:
ergebnis = 10 + 20;
IMIT03B 57
B Glossar
International Standardiza- Siehe ISO.

tion Organization
Interpreter Ein Interpreter setzt die Anweisungen einer Program-
miersprache in ausführbare Anweisungen für den Com-
puter um.
Die Umsetzung erfolgt zur Laufzeit des Programms –
also unmittelbar vor dem Ausführen einer Anweisung
aus dem Quelltext.
ISO ISO (International Standardization Organization) ist
eine internationale Organisation, die international gül-
tige Standards aufstellt. Zu den Mitgliedern der ISO
gehört zum Beispiel das Deutsche Institut für Normung
DIN.
Java Java ist eine weitverbreitete Programmiersprache. Sie ist
plattformunabhängig.
Java Virtual Machine Die Java Virtual Machine setzt den Bytecode eines Java-
Programms in eine ausführbare Anwendung um. Die
Umsetzung erfolgt unmittelbar vor der Ausführung.
JIT JIT ist die Abkürzung für Just in Time-Compiler.
Just in Time-Compiler (JIT) Der Just in Time-Compiler übernimmt beim .NET-Kon-
zept die endgültige Übersetzung der Programme aus der
Zwischensprache.
Klasse Eine Klasse fasst bei der Objektorientierung Objekte mit
gleichen oder sehr ähnlichen Eigenschaften zusammen.
Lineare Suche Die lineare Suche ist ein einfaches Suchverfahren.
LISP LISP ist eine Programmiersprache mit dem besonderen
Schwerpunkt auf der Verarbeitung von Zeichenketten.
Lochkarten Eine Lochkarte ist eine Pappkarte mit Löchern. Über die
Position der Löcher können Informationen transportiert
werden.
Im großen Umfang wurden Lochkarten vom Amerika-
ner Hermann Hollerith eingesetzt. Die Karten werden
daher auch Hollerith-Karten genannt.
Nachfolger von Lochkarten sind zum Teil heute noch im
Einsatz.
Lochstreifen Ein Lochstreifen ist ein Papierstreifen mit Löchern. Über
die Position der Löcher können Informationen transpor-
tiert werden. Dazu werden die Löcher beziehungsweise
die Streifen von einem Mechanismus abgetastet.
Lochstreifen wurden unter anderem für die Steuerung
von Webstühlen verwendet und gaben das Muster vor.
58 IMIT03B
Glossar B
Makro Ein Makro ist eine Folge von Anweisungen für ein An-
wendungsprogramm. Makros werden vor allem für die
Automatisierung eingesetzt.
Maschinensprache Bei der Maschinensprache werden Anweisungen an den
Computer direkt in binär codierter Form in den Speicher
geschrieben.
Mehrfachverzweigung Die Mehrfachverzweigung ist eine Programmstruktur.
Hier können für unterschiedliche Fälle jeweils eigene
Anweisungen festgelegt werden.
Methode Methoden beschreiben bei der Objektorientierung das
Verhalten eines Objekts.
Mnemonic Ein Mnemonic ist ein Befehl eines Assemblers. Es han-
delt sich um kurze Befehle, die recht schwierig zu behal-
ten waren.
Typische Mnemonics sind zum Beispiel add zum
Addieren oder mov als Abkürzung für move (engl. „ver-
schieben“).
Multimedia Multimedia bezeichnet die synchrone Wiedergabe ver-
schiedener Medien wie Bilder, Video, Ton und Text. Der
Anwender hat die Möglichkeit, durch Interaktionen
selbst in den Ablauf einzugreifen.
Objekt Ein Objekt fasst bei der Objektorientierung Daten und
Verhalten zusammen.
Objektorientierung Die Objektorientierung ist ein Konzept beim Program-
mieren. Dabei werden – etwas vereinfacht ausgedrückt
– Daten mit dem Verhalten, das die Daten verändert, in
einem Objekt zusammengefasst. Die Daten bilden dabei
die Eigenschaften des Objekts und das Verhalten die
Methoden.
Oktalsystem Das Oktalsystem ist ein Zahlensystem mit der
Basiszahl 8.
Player Ein Player ist ein spezielles Programm zur Wiedergabe
von Multimedia-Informationen. Player werden zum Bei-
spiel zum Abspielen von Videos oder Audios eingesetzt.
Programm Ein Programm enthält eine Reihe von Anweisungen, die
der Computer zur Lösung einer bestimmten Aufgabe
ausführen soll. Der Aufbau und auch der Umfang der
Programme hängen dabei von der jeweiligen Aufgabe
ab.
Programmierer Ein Programmierer erstellt Computerprogramme. Dabei
setzt er in der Regel konkrete Vorgaben aus der Entwick-
lung mit einer Programmiersprache um.
IMIT03B 59
B Glossar
Programmiersprache Über eine Programmiersprache werden Anweisungen an

den Computer in einer für den Menschen verständlichen
Form erfasst. Diese Anweisungen werden dann in ein
für den Computer ausführbares Programm umgesetzt.
Programmiersprachen sind selbst auch Programme
Python Python ist ein universell einsetzbare Programmier-
sprache. Sie ist plattformunabhängig.
Python Virtual Machine Die Python Virtual Machine setzt den Bytecode eines
Python-Programms in eine ausführbare Anwendung
um. Die Umsetzung erfolgt unmittelbar vor der Aus-
führung.
Quelltext Als Quelltext bezeichnet man die Anweisungen einer
Programmiersprache für die Ausführung eines Pro-
gramms.
Der Quelltext selbst kann nicht direkt ausgeführt wer-
den. Er muss entweder von einem Compiler oder einem
Interpreter übersetzt werden.
Quicksort Quicksort ist ein Sortierverfahren.
RAD RAD ist die Abkürzung für Rapid Application Develop-
ment.
Rapid Application Beim Rapid Application Development wird ein Pro-
Development (RAD) gramm zum großen Teil aus vorgefertigten Elementen
zusammengesetzt. Der Programmierer kann die Eigen-
schaften und das Verhalten dieser Elemente an seine
Bedürfnisse anpassen.
Rational Unified Process Der Rational Unified Process ist ein Vorgehensmodell
zur Softwareentwicklung.
Register Ein Register ist ein spezieller Speicherbereich in einem
Prozessor.
SAP Das SAP©-System der SAP SE ist ein hochintegriertes
System zur Verarbeitung von Geschäftsvorfällen in
Unternehmen. Es verfügt über eine eigene Programmier-
sprache ABAP, über die das System angepasst und er-
weitert werden kann.
Schleife Mit Schleifen können bei der Programmierung Anwei-
sungen in Abhängigkeit von Bedingungen wiederholt
werden.
Scrum Scrum ist ein Vorgehensmodell zur Softwareentwick-
lung.
Sequenz Sequenz ist eine andere Bezeichnung für die Programm-
struktur Folge.
60 IMIT03B
Glossar B
Sequenzielle Suche Sequenzielle Suche ist eine andere Bezeichnung für die
lineare Suche.
Skript Ein Skript ist eine Sammlung von Befehlen für eine
Skriptsprache.
Skriptsprache Bei einer Skriptsprache wird ein Programm durch eine
Aneinanderreihung von Befehlen beschrieben. Moderne
Skriptsprachen haben nahezu die gleichen Möglich-
keiten wie Programmiersprachen.
Software Life Cycle Software Life Cycle ist die englische Bezeichnung für den
Software-Lebenszyklus.
Software Life Cycle-Modell Das Software Life Cycle-Modell ist ein Vorgehensmodell
zur Softwareentwicklung.
Software-Engineering Das Software-Engineering ist ein Teilgebiet der Infor-
matik. Es beschäftigt sich mit der Entwicklung umfang-
reicher und komplexer Software-Systeme.
Software-Lebenszyklus Der Software-Lebenszyklus beschreibt die Phasen bei
der Entwicklung und beim Einsatz eines Programms. Er
stellt also die Zeitspanne dar, in der ein Softwareprodukt
entwickelt und eingesetzt wird – bis zum Ende seiner
Benutzung.
Stapelprogramm Siehe Batchprogramm.
Stapelverarbeitung Siehe Batchprogramm.
Trial and Error Trial and Error ist die englische Bezeichnung für Ver-
such-und-Irrtum.
Vererbung Über die Vererbung können bei der objektorientierten
Programmierung Eigenschaften und Methoden aus
übergeordneten Klassen an eine untergeordnete Klasse
weitergegeben werden.
Die ererbten Methoden und Eigenschaften können ver-
ändert und erweitert werden.
Versuch-und-Irrtum Bei Versuch-und-Irrtum wird eine Vermutung ange-
stellt, die durch Ausprobieren überprüft wird. So kann
direkt herausgefunden werden, ob die Vermutung
stimmt oder nicht.
Visual Basic Visual Basic ist eine Programmiersprache von Microsoft.
V-Modell Das V-Modell ist ein Vorgehensmodell zur Software-
entwicklung.
IMIT03B 61
C. Literaturverzeichnis
Empfohlene Literatur
Boockmeyer, A.; Fischbeck, P.; Neubert, S. (2017). 
Fit fürs Studium: Informatik. 
Bonn: Rheinwerk.
Herold, H.; Lurz, B.; Wohlrab, J.; Hopf, M. (2017). 
Grundlagen der Informatik. 
3. Aufl., Hallbergmoos: Pearson Studium.
Hoffmann, D. W. (2016). 
Grundlagen der technischen Informatik. 
5. aktualisierte Aufl., München: Carl Hanser.
Mit den Themen Algorithmen, Suchen und Sortieren beschäftigen sich die folgenden
Bücher:
Sedgewick, R.; Wayne, K. (2014). 

Fit fürs Studium: Informatik. Algorithmen: Algorithmen und Datenstrukturen. 
Hallbergmoos: Pearson Studium.
Wirth, N. (2013). 
Algorithmen und Datenstrukturen. Pascal-Version. 
5. Aufl., Stuttgart: Teubner.
Beide Bücher gehen aber weit über die Inhalte dieses Studienheftes hinaus und sind in
Teilen sehr anspruchsvoll. Wenn Sie das Thema weiter interessiert, sollten Sie erst ein-
mal versuchen, die Bücher auszuleihen.
62 IMIT03B
D. Abbildungsverzeichnis
IMIT03B
Abb. 1.1 Ein Lochkartenlocher (Bild von Stahlkocher) .......................................... 5

Abb. 2.1 Der Stammbaum wichtiger Programmiersprachen ................................. 14
Abb. 2.2 Das Funktionsprinzip eines Compilers ..................................................... 15
Abb. 2.3 Das Funktionsprinzip eines Interpreters ................................................... 15
Abb. 2.4 Das ausgeführte Befehlsskript ................................................................... 17
Abb. 2.5 Das ausgeführte Skript im Terminal von macOS ..................................... 18
Abb. 2.6 Ein Objekt .................................................................................................... 19
Abb. 2.7 Eine einfache Klassenhierarchie ................................................................ 20
Abb. 2.8 Eine Entwicklungsumgebung für Rapid Application Development 
(hier Visual Studio von Microsoft) ............................................................ 20
Abb. 2.9 Die Python Virtual Machine ...................................................................... 21
Abb. 2.10 Die Java Virtual Machine ........................................................................... 23
Abb. 2.11 Ein Multimedia-Werkzeug (hier: Presenter von Adobe) ......................... 26
Abb. 2.12 Ein Autorensystem (hier: EasyProf® von Innovative Training 
Academy SAS) ............................................................................................. 27
Abb. 3.1 Eine Folge ..................................................................................................... 30
Abb. 3.2 Eine einfache Verzweigung ........................................................................ 31
Abb. 3.3 Eine alternative Verzweigung .................................................................... 32
Abb. 3.4 Eine Wiederholung ..................................................................................... 33
Abb. 3.5 Ein Programm ............................................................................................. 34
Abb. 4.1 Die Phasen bei der Software-Entwicklung ............................................... 38
Abb. 4.2 Der Algorithmus zum Umrechnen vom Dezimal- ins Dualsystem ....... 40
Abb. 4.3 Die aufsteigend sortierte Liste ................................................................... 44
Abb. 4.4 Die geteilte Liste .......................................................................................... 44
Abb. 4.5 Die erste Halbierung der Liste ................................................................... 45
Abb. 4.6 Die zweite Halbierung der Liste ................................................................ 45
Abb. 4.7 Die dritte Halbierung der Liste .................................................................. 45
Abb. 4.8 Die unsortierte Liste ................................................................................... 46
Abb. 4.9 Die Liste mit drei unsortierten Elementen und einem sortierten 
Element ........................................................................................................ 46
Abb. 4.10 Die Liste mit zwei unsortierten und zwei sortierten Elementen ............ 46
Abb. 4.11 Die sortierte Liste ........................................................................................ 47
Abb. 4.12 Die unsortierte Liste ................................................................................... 47
Abb. 4.13 Bubblesort .................................................................................................... 48
IMIT03B 63
E. Tabellenverzeichnis
IMIT03B
Tab. 3.1 Datentypen am Beispiel C++ ........................................................................ 29
64 IMIT03B
F. Codeverzeichnis
IMIT03B
Code 2.1 Ein einfaches Assembler-Programm ......................................................... 9

Code 2.2 Ein Assembler-Programm für die Berechnung von Quadrat-Zahlen .... 10
Code 2.3 Das „Hello World“-Programm in FORTRAN ........................................... 10
Code 2.4 Das Programm zum Berechnen von Quadratzahlen in FORTRAN ....... 11
Code 2.5 Das „Hello World“-Programm in LISP ...................................................... 11
Code 2.6 Das „Hello World“-Programm in COBOL ................................................ 12
Code 2.7 Ein COBOL-Programm .............................................................................. 13
Code 2.8 Ein C-Programm ......................................................................................... 13
Code 2.9 Ein Batchprogramm .................................................................................... 16
Code 2.10 Ein Shell Skript zum Kopieren und Vergleichen einer Datei 
unter macOS ................................................................................................ 18
Code 2.11 Ein Makro .................................................................................................... 19
Code 2.12 Ein einfaches Python-Programm ............................................................... 22
Code 2.13 Ein einfaches C++-Programm .................................................................... 22
Code 2.14 Ein einfaches Java-Programm .................................................................... 23
Code 2.15 Ein einfaches C#-Programm ...................................................................... 24
Code 2.16 Ein einfaches Visual Basic-Programm ...................................................... 25
IMIT03B 65
G. Medienverzeichnis
IMIT03B
Video 2.1 Compiler und Interpreter ........................................................................... 16

Video 2.2 Eine Entwicklungsumgebung für das Rapid Application 
Development im Einsatz ............................................................................ 21
Video 3.1 Die wichtigsten Programmstrukturen ...................................................... 35
Video 4.1 Die binäre Suche ......................................................................................... 45
Video 4.2 Die einfache Maximumauswahl ............................................................... 47
Video 4.3 Bubblesort .................................................................................................... 49
66 IMIT03B
H. Sachwortverzeichnis
IMIT03B
# H
1:1-Programmiersprache .................. 11 Heuristik ......................................... 43
1:n-Programmiersprache .................. 11 Hochsprache .................................... 10
A I
Algorithmus .................................... 39 Implementierung ............................. 41
Analogiebildung .............................. 43 Interpreter ....................................... 15
Analyse ........................................... 39
Assembler .......................................... 8 J
Auswahlstruktur .............................. 31 Java ................................................. 22
Automat ............................................ 4 Java Virtual Machine ....................... 22
Autorensystem ................................ 26
K
B Klasse .............................................. 19
Batchprogramm ............................... 16
Betrieb ............................................. 42 L
brute force ....................................... 43 LISP ................................................. 11
Bubblesort ....................................... 47 Lochkarten ........................................ 5
Bytecode ......................................... 22 Lochkartenlocher ............................... 5
Lochstreifen ....................................... 5
C
C (Programmiersprache) .................. 13 M
C# ................................................... 23 Makro .............................................. 18
C++ ................................................. 22 Maschinensprache ............................. 8
COBOL ........................................... 11 Maximumauswahl, einfache ............ 45
Compiler ......................................... 14 Mehrfachverzweigung ..................... 32
Methode .......................................... 19
D Methode, agile ................................. 42
Datentyp ......................................... 29 Mnemonic ......................................... 8
Dialekt ............................................ 14 Multimedia-Werkzeug ...................... 25
E N
Eigenschaft ...................................... 19 NET-Konzept ................................... 23
Entwurf ........................................... 39
Ereigniss .......................................... 35 O
Ereignisverarbeitung ........................ 35 Objektorientierung .......................... 19
event handling ................................. 35
F
Folge ............................................... 30
FORTRAN ....................................... 10
IMIT03B 67
H Sachwortverzeichnis
P W
Player .............................................. 26 Wartung .......................................... 42
Presenter .......................................... 25 Wiederholung .................................. 32
Programm .......................................... 4
Programmiersprache
Stammbaum ................................ 14
Python ............................................. 21
Q
Quelltext .......................................... 14
R
Rapid Application Development ....... 20
Rückwärtssuche ............................... 43
S
Schleife ............................................ 32
Sequenz ........................................... 30
Skript ............................................... 15
Skriptsprache ................................... 15
Software Life Cycle .......................... 39
Software-Engineering ...................... 38
Software-Entwicklung
Phasen der .................................. 38
Software-Lebenszyklus ..................... 39
Stapelprogramm .............................. 16
Stapelverarbeitung ........................... 16
Suche
binäre ......................................... 44
lineare ......................................... 43
sequenzielle ................................ 43
T
Test .................................................. 41
V
Variable ........................................... 29
Variation .......................................... 43
Versuch-und-Irrtum ......................... 42
Verzweigung
alternative ................................... 32
einfache ...................................... 31
Visual Basic ..................................... 24
68 IMIT03B
I. Einsendeaufgabe
Einführung in die Programmierung Code:
IMIT03B-XX1-N01
Name: Vorname: Fernlehrer/in:
Postleitzahl und Ort: Straße: Datum:
Studien- bzw. Vertrags-Nr.: Lehrgangs-Nr.:

1219N01
Note:
Unterschrift Fernlehrer/in:
Bitte reichen Sie Ihre Lösungen über die Online-Lernplattform ein oder schicken Sie uns
diese per Post. Geben Sie bitte immer den Code zum Studienheft an (siehe oben rechts).
1. Erweitern Sie den Algorithmus zur Umrechnung von Dezimalzahlen in Dualzahlen

aus diesem Studienheft so, dass er Dezimalzahlen in ein beliebiges anderes Zahlen-
format umrechnen kann – also zum Beispiel in Oktalzahlen oder in hexadezimale
Zahlen.
Stellen Sie den geänderten Algorithmus sowohl umgangssprachlich als auch in gra-
fischer Form dar.
30 Pkt.
2. Entwerfen Sie einen Algorithmus, der Dualzahlen in das Dezimalsystem umrechnen
kann. Beschreiben Sie auch diesen Algorithmus umgangssprachlich und grafisch.
Führen Sie für Ihren Algorithmus einen vollständigen Test durch. Dokumentieren
Sie den Test bitte für die Aufgabenlösung.
Hinweis:
Wenn Sie nicht mehr genau wissen, wie die Umrechnungen von einem Zahlen-
system in ein anderes erfolgen, lesen Sie bitte noch einmal im letzten Studienheft
nach.
50 Pkt.
3. Bilden Sie eine Klassenhierarchie für die folgenden vier Tiere: Goldfisch, Schild-
kröte, Wellensittich und Bär. Die Tiere sollen sich dabei auf der untersten Ebene der
Hierarchie befinden. Die oberste Ebene der Hierarchie soll die sehr allgemeine
Klasse Tiere bilden. Legen Sie zwischen diesen beiden Ebenen noch mindestens eine
weitere sinnvolle Ebene an.
10 Pkt.
IMIT03B 69
I Einsendeaufgabe
4. Sie haben folgende Zahlenfolge:
12 143 145 199 256 497
Suchen Sie in dieser Zahlenfolge per Hand mit der binären Suche nach dem Wert
497. Beschreiben Sie dabei bitte jeden einzelnen Schritt, den Sie durchführen.
Hinweis:
Ob Sie die Liste im ersten Schritt beim dritten oder vierten Element teilen, spielt
für die Lösung keine besondere Rolle.
10 Pkt.
insgesamt 100 Pkt.
70 IMIT03B

Imit03b N01

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Imit03b N01

Hochgeladen von

Copyright:

Verfügbare Formate

Das Studienheft und seine Teile sind urheberrechtlich geschützt.

Einführung in die Programmierung

1 Warum Computer programmiert werden müssen .............................................. 3

2 Wie Computer programmiert werden ................................................................... 8

4 Entwicklung von Software ...................................................................................... 38

1 Warum Computer programmiert werden müssen

Überlegen Sie einmal …

1 Warum Computer programmiert werden müssen

1.1 Eine kleine Geschichte der Automaten

Warum Computer programmiert werden müssen 1

Abb. 1.1: Ein Lochkartenlocher (Bild von Stahlkocher)

1 Warum Computer programmiert werden müssen

Warum Computer programmiert werden müssen 1

Aufgaben zur Selbstüberprüfung

2 Wie Computer programmiert werden

kann ein Computer überhaupt nichts anfangen.

Maschinensprache ist immer auf einen ganz bestimmten Prozessortyp zugeschnit-

Da diese direkte Programmierung über Maschinensprache sehr umständlich, aufwendig

2.1 Vom Assembler zur Hochsprache

1. Assembler bedeutet übersetzt so viel wie „Monteur“.

Wie Computer programmiert werden 2

MOV AX,4C00h; Exit to DOS

Code 2.1: Ein einfaches Assembler-Programm (Quelle: http://www.ntecs.de/)

;; Squares of integers 1..10 in MIDAS

2 Wie Computer programmiert werden

start: move p, [-lpdl,,pdl-1]

Code 2.2: Ein Assembler-Programm für die Berechnung von Quadrat-Zahlen

Code 2.3: Das „Hello World“-Programm in FORTRAN (Quelle: http://www.ntecs.de/)

3. Formula Translator bedeutet übersetzt „Formelübersetzer“.

Wie Computer programmiert werden 2

Code 2.4: Das Programm zum Berechnen von Quadratzahlen in FORTRAN

(print "Hello World")

Code 2.5: Das „Hello World“-Programm in LISP (Quelle: http://www.ntecs.de/)

4. Übersetzt bedeutet List Processing Language so viel wie „Listenverarbeitungssprache“.

2 Wie Computer programmiert werden

Code 2.6: Das „Hello World“-Programm in COBOL (Quelle: http://www.ntecs.de/)

Wie Computer programmiert werden 2

DISPLAY TEXTF AT 0301.

Code 2.7: Ein COBOL-Programm

Code 2.8: Ein C-Programm

2 Wie Computer programmiert werden

Abb. 2.1: Der Stammbaum wichtiger Programmiersprachen

2.2 Compiler und Interpreter

6. to compile bedeutet übersetzt so viel wie „zusammentragen“.

Wie Computer programmiert werden 2

Abb. 2.2: Das Funktionsprinzip eines Compilers

Abb. 2.3: Das Funktionsprinzip eines Interpreters

7. to interpret bedeutet übersetzt so viel wie „auslegen“ oder „dolmetschen“.

2 Wie Computer programmiert werden

In diesem Video stellen wir Ihnen die

Video 2.1: Compiler und Interpreter

Skriptsprachen finden Sie unter anderem bei Batchprogrammen auf Betriebssystem-

Code 2.9: Ein Batchprogramm

Wie Computer programmiert werden 2

Abb. 2.4: Das ausgeführte Befehlsskript

8. Den Editor von Windows finden Sie im Startmenü unter Windows-Zubehör.

2 Wie Computer programmiert werden

Die Ausführung des Befehlsskripts können Sie mit der Tastenkombination +

Abb. 2.5: Das ausgeführte Skript im Terminal von macOS

Ein weiteres Einsatzgebiet von Skriptsprachen ist die Automatisierung in Anwendungs-

Wie Computer programmiert werden 2

Code 2.11: Ein Makro

2.3 Die Objektorientierung