Das Thema in diesem Abschnitt sind Programmiersprachen, vor allem natürlich solche, die ich selber schon mal ausprobiert habe. Die Auflistung erhebt keinen Anspruch auf Objektivität oder Vollständigkeit.
Und vor allem ist das hier kein Lehrgang. Wer noch nie programmiert hat, wird wahrscheinlich einige Bemerkungen von mir nicht verstehen können, dies hier ist wohl eher eine Art Insidertext.
Zu manchen Sprachen gibt es ein Beispielprogramm, das einen kurzen Begrüßungstext ausgibt und dann die Zahlen von 0 - 9. Und das auch nicht immer zwangsläufig optimal, besonders in Assembler geht das wahrscheinlich auch schlauer, als ich es gemacht habe.

BASIC

Meine erste Programmiersprache war seinerzeit (1983) BASIC. Damals in Erscheinungsform des unsäglich langsamen BASICs des TI-99/4A Computers. Wie ich Jahre später las, lag das daran, daß der TI die BASIC Befehle in einen Zwischencode interpretierte, der seinerseits auch wieder interpretiert wurde.

Wenig später folgte der Commodore 64 und sein 64er BASIC. Das war schon etwas schneller, aber hatte ebenfalls Beschränkungen, die einem heute die Haare zu Berge stehen lassen:

• Vor jedem Befehl mußte eine Zeilennummer stehen. Wollte man nachträglich Zeilen einfügen, hatte das mit Nummern dazwischen zu geschehen, falls man keine Lücken gelassen hatte, konnte man alles umnummerieren.
• Variablennamen durften nur zwei Zeichen lang sein. Sprechende Namen, wie sie heute üblich sind, waren also fast unmöglich.
• Die IF Konstruktion hatte keinen ELSE Zweig.
• Eigentlich mußte man dauernd GOTO benutzen.
• Es gab nur globale Variablen.
• Merkwürdige PEEK und POKE Befehle dienten dazu, Speicherstellen zu ändern oder auszulesen.

Nach dem 64er war der Commodore Amiga dran. Das BASIC dieses Rechners war verglichen damit eine Wohltat. Anfänge der strukturierten Programmierung waren zu erkennen und man brauchte keine Zeilennummern mehr.
Schnell kam man aber dahinter, daß BASIC (egal welches) für viele Dinge (vor allem Spiele) viel zu langsam war. Viel Auswahl gab es ja nicht, besonders auf dem 64er.

10 REM BEISPIELPROGRAMM IN 64ER BASIC
20 PRINT "HERZLICH WILLKOMMEN ZU DIESEM BEISPIELPROGRAMM"
30 FOR I = 0 TO 9
40 : PRINT I
50 NEXT I

Assembler

Mit dem Commodore 64 fing es an und seitdem habe ich fast alle Rechner auch mal in Assembler programmiert. Nie besonders intensiv, aber immerhin auf den Chips 6510, 68000, i486 und Mikrocontroller von Atmel.

Assembler zu programmieren ist mühsam. Die kleinsten Dinge brauchen scheinbar viele Befehle und man kommt nur sehr schleppend voran. Außerdem ist es in keiner anderen Sprache so leicht, vernichtende Fehler zu machen, die früher grundsätzlich den ganzen Rechner abstürzen ließen.
Heute mit den moderneren Betriebssystemen ist das nicht mehr so schlimm, allerdings wird heute auch fast nicht mehr Assembler programmiert.
Hatte man aber ein fehlerfreies Programm zustande gebracht, war das Ergebnis sehr klein vom Speicherbedarf und schneller in der Ausführung als es mit jeder anderen Sprache möglich ist.

Trotz aller Handikaps habe ich immer mal gerne in Assembler programmiert. Man lernt den Prozessor und das Betriebssystem viel besser kennen als mit anderen Sprachen, weil man sonst nicht mal kleinste Aufgaben lösen kann.
Im direkten Vergleich ist der Befehlssatz des 68000er Prozessors (den zum Beispiel der Amiga hatte) viel angenehmer als der von den x86 Kompatiblen. Deswegen habe ich auch PCs fast nie in Assembler programmiert, eher schon wieder die Mikrocontrollerserie von Atmel, da machte das wieder Spaß.

; Beispielprogramm in x86 Assembler fuer Linux
section .data
msg1 	db 	'Herzlich willkommen zu diesem Beispielprogramm!',0x0A 
len1 	equ 	$ - msg1
align   4
msg2	db	'0',0x0A
align   4
section .text 	 	 	
global _start 
_start:
  mov 	eax,4
  mov 	ebx,1
  mov 	ecx,msg1
  mov 	edx,len1
  int 	0x80 
  mov	ecx,msg2
  mov	edx,2
  mov	eax,48
  mov   esi,msg2
_schleife1:  
  mov	[esi],al
  mov	edi,eax
  mov	eax,4
  int	0x80
  mov	eax,edi
  inc	al
  cmp	al,58
  jne	_schleife1
  mov 	eax,1
  int 	0x80

Forth

Diese ungewöhnliche Sprache war in den 70er und 80er Jahren relativ populär. Es gab auch ein Forth für den 64er, das ich mal irgendwo gesehen und ausprobiert habe.
Forth ist eine extrem stackbasierte Sprache mit Postfixnotation. Eine Berechnung wie 3 * (2 + 8) sieht in Forthsyntax so aus:

3 2 8 + *

Es gibt zwei Stacks in Forth, den üblichen um zum Beispiel aus Unterprogrammen zurückzuspringen (Returnstack) und den Datenstack.
Durch die intensive Benutzung der Stacks ist es in Forth nicht nötig, so viele Variablen wie in anderen Sprachen zu vereinbaren.

Es wurden auch spezielle Chips entwickelt im Embedded-Bereich, die zwei Stacks hardwaremäßig haben und darum natürlich mit Forth besonders gut zu programmieren sind.
Forth ist ziemlich schnell und braucht relativ wenig Platz für sein System, dadurch war es auf den Mikrocomputern damals recht beliebt. Heute gibt es leider nur wenige Leute, die sich überhaupt noch an Forth erinnern können...

/ Beispielprogramm in Forth
." Herzlich willkommen zu diesem Beispielprogramm!"
cr
: schleife 10 0 ?do
  i .
  cr
loop ;
schleife

Pascal

Im Studium lernten wir Pascal. Verglichen mit dem, was ich davor gekannt hatte, war Pascal sehr streng. Man konnte nicht mehr wie in BASIC oder Assembler verschiedene Datentypen der gleichen Variable oder Speicherzelle zuweisen, alle Variablen mußten vor der ersten Benutzung ausführlich deklariert werden usw.
Zuerst war das eine Umstellung, andererseits waren bei Pascal die Fehler zur Laufzeit deutlich reduziert. Als Ausgleich bekam man ja die Fehler beim Kompilieren. :-)

Eines der Hauptprobleme mit Pascal ist meiner Ansicht nach die Herkunft. Pascal wurde als reine Lehrsprache entwickelt, nicht für industriellen Einsatz. Daher fehlten viele nötige Konstrukte und es entstand eine Anzahl von Pascal Varianten, die diesen Umstand beheben sollten.

Pascal hat moderne Nachfolger wie Modula-2 und Oberon, die aber nie diese Verbreitung gefunden haben. In Form von Delphi lebt Pascal weiter.

{Beispielprogramm in Pascal}
Program Beispiel;
var
  i : integer;
begin
  writeln('Herzlich willkommen zu diesem Beispielprogramm!');
  for i:=0 to 9 do begin
    writeln(i);
  end
end.

C

C brauchte ich im Studium. Zuerst war ich wenig begeistert, und eigentlich bin ich es immer noch nicht.
C ist relativ schnell und bietet dem Programmierer viele Freiheiten. Dafür ist auch die Fehlerwahrscheinlichkeit größer.
Klar, in jeder Sprache kann man Fehler machen (und macht sie auch, garantiert). Aber C macht es einem etwas zu einfach in dieser Beziehung.

Viele Sicherheitsprobleme in heutigen Rechnern (man denke nur an die regelmäßigen Updates für Windows und auch Linux, die deswegen nötig sind) kommen von einigen Schwierigkeiten, die C verursacht. Besonders die Bufferoverflows sind ein typisches C Problem (und das seiner Nachfolger).

Trotzdem sind C und C++ häufig benutzte Sprachen, wie gesagt habe auch ich jahrelang fast alles in C programmiert. Betriebssysteme wie Unix/Linux sind nahezu komplett in C programmiert und auch die dazu gehörigen grafischen Oberflächen fast immer.

/* Beispielprogramm in C */
int main() {
  int i;
  printf("Herzlich willkommen zu diesem Beispielprogramm!\n");
  for (i=0; i<10; i++) {
    printf("%d\n",i);
  }
  return 0;
}


// Beispielprogramm in C++
#include <iostream>
using namespace std;
int main (void) {
  cout << "Herzlich willkommen zu diesem Beispielprogramm!\n";
  for (int i=0; i<10; i++) {
    cout << i << "\n";
  }
  return 0;
}

PHP

PHP als Skriptsprache wird hauptsächlich für die Erstellung dynamischer Webseiten benutzt. Es ist auch wie andere Skriptsprachen universell einsetzbar, aber dort gibt es stärkere Konkurrenz (Python, Tcl/Tk, Ruby, Perl usw).
Persönlich bin ich kein großer Fan von PHP, ausgenommen für Webseiten. Mir kommt das wie ein Mischmasch aus vielen anderen Sprachen vor. Und selbst für Webseiten würde ich JSP vorziehen, aber ich glaube, mein Provider bietet das nicht an.

<?php
// Beispielprogramm in php
echo "Herzlich willkommen zu diesem Beispielprogramm!\n";
for ($i=0; $i<10; $i++) {
  echo $i."\n";
}?>

Java

Erst 2003 geriet ich beruflich mit Java in Berührung.
Zuerst hatte ich die üblichen Vorurteile: Zu langsam, da interpretierter Bytecode ausgeführt wird, keine Pointer, Garbage Collection.
Nach einiger Zeit merkte ich aber, daß Java gar nicht mehr so langsam ist wie zu Beginn (1995). Zahlreiche Benchmarks, die durchgeführt wurden und auch eigene Tests zeigten mir, daß Java dicht dran ist an C++ von der Ausführungsgeschwindigkeit.
Die anderen Nachteile kann man auch als Vorteil sehen. Es gibt keine Pointer in Java, gut so! Kann man weniger Schindluder mit treiben. Gerade die Pointerfehler waren sehr eklig zu debuggen.

Inzwischen ist Java meine Lieblingssprache. Auch weil ich privat Windows, Linux und MacOS X verwende. Denn mit Javaprogrammen muß ich am wenigsten ändern, um es auf allen Systemen laufen zu lassen.
Inzwischen gibt es auch mehrere Projekte, die versuchen, ein ganzes Betriebssystem nahezu vollständig in Java zu programmieren.

// Beispielprogramm in Java
class Beispiel {
  static public void main (String [] argu) {
    System.out.println("Herzlich willkommen zu diesem Beispielprogramm!");
    for(int i=0; i<10; i++) {
      System.out.println(i);
    }
  }
}

Perl

Ebenfalls beruflich benutzte ich Perl. Diese Skriptsprache ist besonders für die Verarbeitung von Texten geeignet (Spamfilter beispielsweise oder Alignments in der Bioinformatik).
Gerne wird Perl auch eingesetzt (wie PHP), um dynamische Webseiten zu erzeugen (CGI Skripte sind oft in Perl).

Für bestimmte Anwendungen mag Perl große Vorteile haben, aber irgendwie gefällt mir diese Sprache nicht so sehr. Das kann durchaus an den seltsamen vordefinierten Variablennamen liegen, die so schwer zu merken sind: $_ $. $/ $" und wie sie alle heißen.

# Beispielprogramm in Perl
use strict;
print "Herzlich willkommen zu diesem Beispielprogramm!\n";
my $i;
for ($i=0; $i<10; $i++){
  print $i,"\n";
}

Common Lisp

Meine neueste Entdeckung ist Lisp. Ironischerweise, denn Lisp ist eine der ältesten Programmiersprachen, die es gibt.
Was soll an so einer alten Sprache noch interessant sein? Immerhin wurde Lisp in den 50er Jahren erfunden.

Nun, Common Lisp in seiner heutigen Erscheinung ist gar nicht so alt. Der ANSI Standard ist von 1996, also etwa in der Zeit, in der auch Java eingeführt wurde.
Einer der Hauptvorzüge von Lisp ist die Erweiterbarkeit der Sprache. Es wird gerne gesagt, Lisp sei eine programmierbare Programmiersprache oder eine Sprache, die selbst Programme schreibt. (Das hat jetzt nichts mit dem selbstmodifizierenden Code zu tun, wie es früher bei Assembler üblich war).
In Lisp ist die wichtigste Datenstruktur die Liste. Ein Lisp Programm selbst ist aber auch eine Liste. Daher sind für Lisp Programme und Daten mehr oder weniger das gleiche.

Es ist ein weit verbreiteter Irrglaube, daß Lisp-Programme nur interpretiert werden und sehr langsam sind. Man kann Lisp selbstverständlich compilieren, aber auch interpretieren. Und es ist ebenfalls möglich, schnelle Programme zu schreiben.

In Lisp ist es sehr gut möglich, funktional zu programmieren. Das bedeutet vereinfacht gesagt, daß alles durch Funktionen ohne Seiteneffekte berechnet wird. Es gibt Lisp Dialekte bzw. Sprachen, die von Lisp geerbt haben, wo diese funktionale Programmierung noch viel stärker ausgeprägt ist als in Common Lisp (zum Beispiel Scheme).
Mehr zu Common Lisp in einem eigenen Artikel.

;;;; Beispielprogramm in Common LISP
(format t "Herzlich willkommen zu diesem Beispielprogramm!")
(do ((i 0 (+ i 1)))
    ((> i 9) i)
    (print i))

Andere Sprachen

Diese kleine Übersicht war sehr subjektiv. Sowohl von der Auswahl als auch von den persönlichen Einschätzungen. Die Reihenfolge kommt chronologisch aus meiner Sicht zustande, also in welcher Reihenfolge ich mit diesen Sprachen programmiert habe.

Es gibt noch beliebig viele andere Programmiersprachen, einige habe ich mal ein paar Stunden angetestet:

• Fortran, die älteste höhere Programmiersprache der Welt
• Modula-2, Nachfolger von Pascal
• Noddy, eine grafische Sprache für den Memotech MTX512 (ich wette, die kennt kein Mensch)
• Prolog, PROgrammieren in LOGik, vor allem in der KI benutzt
• Python, eine moderne objektorientierte Skriptsprache, die meiner Meinung nach gut zu lernen sein müßte und recht leicht lesbar ist (böse Zungen behaupten allerdings, Python ist eine Art Lisp von Leuten, die Lisp nicht verstanden haben)
• Tcl/Tk, Skriptsprache, mit der einfach grafische Oberflächen zu machen sind
• Draco, eine komische Mischung aus Pascal und C (habe ich nur auf dem Amiga angetroffen)
• Brainfuck, die Realisierung der klassischen Turingmaschine (ja, diese Sprache heißt wirklich so, Beispiel folgt)

>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.
+++++++++++++.++++++++.--------------.---.------.+++++.
[-]>++++++++[<++++>-]<.
>++++++[>+++++[<<+++>>-]<-]<---.
--------------.+++..-.++++.--..--------.+++++++++.
[-]>++++++++[<++++>-]<.
>++++++[>+++++[<<+++>>-]<-]<.-----.
[-]>++++++++[<++++>-]<.
>+++++++++++[<++++++>-]<++.+++++.----.
++++++++++++++.--------------.++++++++.
[-]>++++++++[<++++>-]<.
>++++++++[<++++>-]<++.>+++++++[<+++++>-]<.
++++.++++++++++.---.-------.----.+++++++.++++.++.---.--------.
+++++++++++.>++++[<---->-]<-.++++++++++++..
[-]>++++++++[<++++>-]<+.[-]++++++++++.[-]
>++++++++[<++++++>-]
>++++++++++
<++++++++++[<.+>>.<-]

Und dann gibt es noch viele weitere Sprachen, von denen ich noch nie was gehört habe. Das liegt unter anderem auch daran, daß nicht wenige Programmierer als Übung sich sozusagen neue Sprachen selber ausdenken und einen Compiler dazu schreiben. :-)