[woody]

(1) Programmierung
(1.1) Geschichte
Die Befehle, die ein Prozessor ausführen kann (sein sog. Befehlssatz) werden seit jeher durch binäre Zahlen bestimmter Länge dargestellt. Auf einen Befehl folgen die zu verarbeitenden Daten, ebenfalls in binärer Form. Diese Nullen und Einsen in einer sinnvollen Wiese im Arbeitssprecher angelegt ergeben ein Programm.

In den Anfangstagen der Computergeschichte hat man nun diese Befehle mittels Lochstreifen, Steckverbindungen oder Kippschaltern dem Rechenwerk zugeführt. Ein entspreche langes Programm war allerdings nur sehr schwer zu verstehen und Entwicklung bzw. Fehlersuche besonders mühsam.

So begann man den einzelnen Befehlen Buchstabenkürzel zuzuordnen, die sog. Mnemonics. Die Buchstabenkürzel erinnerten an die Funktion des zugehörigen Befehls und erhöhten so die Lesbarkeit des Codes drastisch. Die Kürzel gefolgt von den Daten gab man nun in einen Texteditor ein, von dort wurden sie mit einem speziellen Programm, dem sog. assembler, wieder in Maschinensprache übersetzt. Die "Programmierumgebung" war geboren.

Aber auch diese Methode ist nicht besonders flexibel und umständlich. So begann man höhere Programmiersprachen zu entwickeln, die mit ihren syntaktischen (=Satzbau) und logischen (=z.B. Verzweigungen: WENN->DANN) Konstrukten stark der Menschlichen Sprache, bzw. Denkweise ähneln.
Der hochsprachliche Code wird nun von einem Compiler wieder in Maschinenbefehle übersetzt.

Wir arbeiten hier mit vb.net, einer Programmiersprache, die auf BASIC (Beginners All Purpose Symbolic Instruction Code) basiert. Sie ist besonders einfach zu verstehen, da sie der englischen Sprache auffallend nahe kommt. Auf die Bedeutung elementarer Codewörter wie z.B. "As" oder "New" werde ich daher nicht eingehen.

(1.2.1) Codewörter
Codewörter sind die "Anweisungen" der Programmiersprache. Sie "sagen" dem Compiler, was getan werden soll. Variablen oder Funktionen dürfen in ihrem Namen nicht mit vordefinierten Codewörtern übereinstimmen.
Biespiele

Code:

Dim
Private
Inherits
Function

(1.2.2) Variablen, Konstanten und Operatoren
Dies sind die elementaren Werkzeuge innerhalb eines Programmcodes. Variablen & Konstanten können verschiedene Informationen tragen: Ganzzahlen, Kommazahlen, Text, "Wahr/Falsch"
Daher unterscheidet man verschiedene Variablentypen:

-Integer (Byte, Int16, Int32, Int64): Vorzeichenbehaftete Ganzzahlen
-String: Alphanumerische Zeichen
-Boolean: True oder False
-Single/Double/Float: Vorzeichenbehaftete Kommazahlen, bestehend aus Mantisse und Exponent

Eine Variable kann in ihrem Wert geändert werden, eine Konstante nicht. Beide müssen jedoch vor ihrer Verwendung definiert werden (d.h. im Speicher wird entsprechender Speicherplatz reserviert):

Code:

Dim myVariable As Int32 'oder auch mit direkter Wertzuweisung:
Dim myVariable As Int32 = 12

Alle Zeichen innerhalb einer Zeile, die nach einem einfachen Anführungszeichen kommen, werden vom Compiler als Kommentar betrachtet.

Variablen unterschiedlichen Datentyps können in der Regel nicht direkt ineinander überführt werden. Entsprechende Wertzuweisungen sind unzulässig. Es existierten aber Funktionen zur Konversion der Datentypen.

Code:

Dim myStr As String
Dim myInt As Int32
Dim myDbl As Double = 2.5

'Falsch:
myInt = myDbl
myStr = myInt

'Richtig:
myInt = CInt(myDbl)
myStr = myInt.ToString()

Operatoren dienen nun dazu Variablen miteinander zu "verrechnen". Im einfachsten Fall kann man zwei Zahlen addieren:

Code:

Dim a, b, c As Int32
a = 5
b = 7
c = a + b  'Es folgt: c = 12

Wobei "+" hier den Operator darstellt.

Code:

i *= 4

ist eine Kurzschreibweise für:

Code:

i = i * 4

(1.2.3)Arrays
Ein Array ist eine Ansammlung von Variablen eines Datentyps. Es hat eine fest definierte Länge.

Code:

Dim i(2) As Double 'Länge = 3
i(0) = 2.3
i(1) = 7.978
i(2) = i(0) / i(1)

(1.3) Strukturen
(1.3.1) Verzweigungen
Verzweigungen werden verwendet, um Entscheidungen zu treffen:

Code:

If schoenesWetter = True Then
  MsgBox("lass uns rausgehen")
Else
  MsgBox("Mist!")
End If

Code:

Select Case hausnummer
Case 666
  MsgBox("The Number of the Beast")
Case 668
  MsgBox("Der Nachbar vom Biest")
Case 667
  MsgBox("Andere Straßenseite")
End Select

(1.3.2) Schleifen
Schleifen werden verwendet, um Anweisungen öfters als einmal auszuführen.

Code:

Dim i As Int
For i = 0 To 100
....
Next i

Diese Schleife wird durchlaufen, bis i den Wert 100 erreicht hat. Nach jedem Durchlauf wird i um den Wert 1 erhöht.

Code:

Do While myTester = True
...
Loop

Diese Schleife wird solange ausgeführt, wie die Variable "myTester" den Wert True hat.

(1.4) Paradigmen
(1.4.1) Imperative Programmierung
Das Programm besteht nur aus hintereinander ausgeführten Befehlen. (Verzweigungen und Schleifen existieren). Soll ein Teil des Codes erneut ausgeführt werden, ist eine Sprunganweisung nötig, die die Ausführung des Programms an einer anderen Stelle fortsetzt. Selbiger Code ist extrem unleserlich und wird daher als "Spaghetti-Code" bezeichnet.

(1.4.2) Prozedurale Programmierung
Bei der prozeduralen Programmierung werden immer wieder benötigte Programmteile in Funktionen ausgelagert. Diesen Funktionen können, bzw. müssen Variablen übergeben werden, mit denen die Funktion intern arbeitet. Subroutinen ("Subs") können keine Werte zurückgeben, Funktionen ("Function") dagegen schon.
Die übergebenen Variablen, können entweder nach Wert "ByVal" oder nach Referenz "ByRef" übergeben werden. Im ersten Fall wird nur der explizite Wert an die Funktion übergeben, im Zweiten eine Zeiger auf die Variable, die so auch von der Funktion manipuliert werden kann.

Code:

'Definitionen
Sub q_s(ByRef i As Int32)
i = i * i
End Sub

Function q_f(ByVal i As Int32) As Int32
Dim ergebnis As Int32
ergebnis = i * i
Return ergebnis
End Sub

'So werden die Funktionen aufgerufen:
Dim a As Int32 = 2
Dim b As Int32 = 2

q_s(a)     '->a = 4
b = q_f(a) '->a = 4; b = 16

(1.4.3) Objektorientierte Programmierung
Hier werden nicht nur Funktionen als wiederkehrende Elemente eingesetzt, sondern sog. Klassen. Eine Klasse besteht aus Variablen und Funktionen ? in diesem Kontext "Methoden" genannt.
Eine klasse kann beliebig oft instanziert werden. Die genauen Hintergründe würden hier den Rahmen leider sprengen, aber Wikipedia weiß Rat.
Wichtig ist, dass alle Methoden und Variablen, die eine Klasse beinhaltet entweder gekapselt "Private" oder öffentlich "Public" sein können. Erstere sind nur innerhalb der Klasse zugänglich, Letzere sind von außen sichtbar.
Wenn ich nun eine Klasse instanziert habe und auf öffentliche Methoden zugreifen will, benötige ich den Punkt-Operator (".").

Hier ein einfaches Beispiel, dass einen Auto-Tuner simuliert.

Code:

'die Klasse:

Public Class auto
'Variablen
Private marke As String
Private motrorleistung As Int32

'Methoden
Public Sub setMarke(m As String)
marke = m
End Sub

Public Sub setLeistung(l As Int32)
motorleistung = l
End Sub

Public Function getMarke() As String
Return marke
End Function

Public Function getLeistung() As Int32
Return motorleistung
End Function

Public Sub leistungVerdoppeln()
leinstung *= 2
End Sub

End Class




'mein Programm
Dim astra As New auto            'der Tuner (=Instanz)
Dim eKlasse As New auto            'und sein Konkurrent (=Instanz)

astra.setLeistung(65)
astra.setMarke("Opel")

eKlasse.setLeistung(500)
eKlasse.setMarke("Daimler")

Do While astra.getLeistung() < eKlasse.getLesitung()
astra.leistungVerdoppeln()         'der Tuner schraubt am Auto rum
Loop

Wir arbeiten Objektorientiert.