Wie oft wird man gefragt, welche Programmiersprache die beste ist. Diese Frage lässt sich aber nicht ohne weiteres beantworten. Vielmehr hängt dies von der Problemstellung, dem gewünschten Laufzeitverhalten, Größe etc. ab. Daher drücke ich mich vor dieser Frage und möchte mal ein Beispiel für verschiedene Programmiersprachen geben.
Dazu ein Problem: Gesucht ist ein Programm, dass die Fibonacci-Zahlen für 0-17 berechnet. Die Fibonacci-Zahlen sind wie folgt definiert:
F(0)=1
F(1)=1
F(n)=F(n-1)+F(n-2)

Zunächst ein Algorithmus in Assembler:

;Gebe die ersten 17 Fibonacci-Zahlen aus
;(c) 2003 by Gereon Schüller

.include output

  mov      ax,1           ;F(0):=1
  mov      bx,1           ;F(1):=1
  mov      cx,17          ;17 mal ausführen

  Iterate:                ;Schleifenkopf
    push   ax,bx,cx,dx    ;Register sichern
    #DosWordln (ax)       ;F(17-cx) ausgeben1
    pop    dx,cx,bx,ax    ;Register zurückholen
    add    ax,bx          ;F(n):=F(n-1)+F(n-2)
    xchg   ax,bx          ;Rollen vertauschen
  loop Iterate            ;Iterieren bis cx auf null

.halt

¹Hier mache ich es mir einfach, denn #DosWordln stellt ein Makro dar, dass den Inhalt von ax ausgibt. Darin ist ein Modulo-Algorithmus enthalten, der Zahlen in ASCII-Zeichen konvertiert. Das Listing wäre dann länger... Dafür ist das Programm sehr schnell und klein (214 Bytes)
Ein Assembler-Programm beinhaltet praktisch jeden Schritt des Prozessors und wird daher als maschinennah bezeichnet. Assemblerprogramme sind u.U. schwer zu verstehen, aber man kann Code damit soweit optimieren wie es nur geht, ohne eine Prozessorschritt zu verschwenden.

Basic:

rem Berechne die Fibonacci-Zahlen
a=1
b=1
for i=0 to 16
        print a
        r=a+b
        a=b
        b=r
next i

Das Programm dürfte zwar langsamer sein, um etwas zu merken ist das Programm aber zu kurz. Besonders gut kann man dieses Programm aber auf dem C64 beobachten, wo lediglich Zeilennummern vor das Listing zu setzen sind.

Pascal:

var
   a,b,r,i:Integer;
begin
a:=1;
b:=1;
for i:=0 to 16 do
    begin
        writeln(a);
        r:=a+b;
        a:=b;
        b:=r;
    end
end.

Das Programm ist 2245 Bytes groß, verschwendet also schon einiges, obwohl es das gleiche leistet wie der Assembler-Code. Pascal erfreut sich in Informatik- Lexika etc. immer noch großer Beliebtheit.

JavaScript:

function fibonacci() {
     var a=1;
     var b=1;
     var r=0;
     for(var i=0;i<17;i++) {
         document.writeln(a);
         r=a+b;
         a=b;
         b=r;
     }
}

An dem Programm seid ihr eben schon vorbeigekommen, es steht nämlich im Header dieser Datei. Man kann es hier starten. Die Größe ist natürlich nicht messbar, denn es wird ja erst auf eurem Computer interpretiert.

Java:

public class fibo {
        public static void main(String args[]) {
                int a,b,r,i;
                a=1;
                b=1;
                for(i=0;i<17;i++) {
                        System.out.println(a);
                        r=a+b;
                        a=b;
                        b=r;
                }
        }
}

Nicht zu verwechseln mit JavaScript. Java ist eine vollwertige Programmiersprache, die Programme erstellt, die auf verschiedenen System lauffähig sind. Eigentlich wollte man damit Elektrogeräte steuern, aber wer braucht eine Kaffeemaschine mit Fibonacci-Zahlen? Was mich beim Kompilieren selbst erstaunt, ist die Größe von 454 Bytes. Allerdings braucht man noch ein Hilfsprogramm, um das Programm auszuführen.
Es ist übrigens kein Zufall, dass das nächste Beispiel ähnlich aussieht:

C:

/*Berechne Fibonacci-Zahlen von 0-17*/
#include <stdio.h>
int main(int argc, char *argv[])
{
        int a=1;
        int b=1;
        int r=0;
        int i=0;
        for (i=0;i<=17;i++) {
                r=a+b;
                printf("%i.Fibonacci-Zahl ist %i \n",i,a);
                a=b;
                b=r;
        }
}

Auch schnell, aber mit einer Größe von 11425 Bytes (GCC unter Linux) ein bisschen größer als der Assembler-Code... C/C++ ist heute die mit Abstand beliebtiste Programmiersprache der Welt. In ihr werden auch Betriebssysteme wie Linux oder Windows und Programme wie Word etc. geschrieben.

Haskell:

--Berechne die Fibonacci-Zahlen
fibonacci (0) = 1
fibonacci (1) = 1
fibonacci (n) = fibonacci (n-1) + fibonacci (n-2)

>map [0..15] fibonacci

Was hierbei erstaunt ist die Einfachheit des Programms, das liegt daran, dass Haskell eine funktionale Programmiersprache ist. Dafür darf man mit dem Interpreter Hugs auch zusehen :)

Zur allgemeinen Verwirrung sei noch gesagt, dass das letzte Programm rekursiv ist, sich also selbst aufruft. Das geht auch mit Sprachen wie C:

public int fibonacci(int n) {
       if (n==0 || n==1) {
           return 0;
       else {
           return fibonacci(n-1)+fibonacci(n-2);
       }
}
int main(int argc, char *argv[])
{
        for(i=0;i<17;i++) {
             println("%i\n",fibonacci(i));
        }
}

Programme werden dadurch oftmals eleganter, wenn auch nicht zwangsläufig schneller oder kleiner, ist aber auch möglich.