Mit einer von mir bisher wenig gebrauchten PS. Ocaml aka F#. Warum? Nun ich würde gerne Smalltalk benutzen, aber ich möchte auch so viel wie möglich Compilerunterstützung gegen Typos und andere Fehler nutzen. Ich denke mir, was der Computer testen kann, soll er auch testen. Ich mag es weiterhin nicht, mich zu wiederholen, als wäre ich eine gesprungene Schallplatte:

LongPathToSomeJavaClass<withTemplate1, withTemplate2> = myClass = new LongPathToSomeJavaClass<withTemplate1, withTemplate2>()

Ja, ich weiß, man braucht es nach dem New nicht mehr so zu schreiben. Was mir auch nicht so gefällt, wenn ich die Methoden in OO-Weise aufliste MyList.map(some function).filter(someCondition) …

Und ja, seiteneffektfreie Funktionen sind auch schön zu haben. IM Vergleich sieht
F# so aus:

let mutable i = 1
in
    let rec loop() =
        printf "i= %d >" i 
        let input = Console.ReadLine()
        if input = "exit" then 
            exit(0)
        else 
            printfn "You typed: %s" input
            i <- i + 1
            loop()


loop()

Es ist typsicher, ohne dass man es deklarieren muß. Man kann aber:
Also kann ich auch schreiben let mutable i:int = 1. Auf der anderen Seite ist e s nicht so jerkish wie Haskell: http://learnyouahaskell.com/input-and-output.

Ich finde, man kann es ziemlich “locker runter lesen – und verstehen. Mir gefällt vor allem auch ein Schlüsselwort wie ‘mutable’, damit teilt man F# mit, hey ich werde das ändern und man macht es dann einfach (i <- i+1)

Und vor allem mag ich es, wenn man Daten auch in Objekte packen kann, mit Polymorphismus (die Haskellianer verstehen etwas anderes als der Rest der Welt darunter) . Ich sehe hier wirklich eine Obermenge von Programmerweisen.

1. Simpel und “dumm” prozedural let a … let b let c
2. funktional (keine Seiteneffekte, keine Überraschungen bei Aufruf von Funktionen
3. objektorientiert (da kenne ich mich nun mal am besten aus und mir kommt es in meinem Programm am weitesten entgegen.
   

Ich schrieb ja oben von Smalltalk, ich kann viel von OCaml auch in Smalltalk bekommen (schließlich sind Blöcke nicht anderes als Funktionen. Aber nichts warnt mich während der Entwicklung ,wenn so was passiert (pseudo code)

aHouse := aCrodocile
.
.
.
aHouse openDoor. 

Ja, die IDES werden einen vielleicht warnen, aber im Endeffekt, wird uns zur Laufzeit mitgeteilt, da liegst’e mit dem Typ aber daneben. Das kann einem in Ocaml, F# und Haskell nicht passieren. Weithin passt F# komplett in die .NET Welt. Mir wäre kein Smalltalk bekannt, für das das gilt, ja es gab mal ich glaube IronSmalltalk oder so, aber AFAIK gibt es derzeit keine Unterstütztes auf Windows. Ich glaube eine Kombination in einer Sprache, die einen nicht bevormundet ist eine der besten Lösungen. Ich werde mal sehen, wohin mich dieser Trip führt, vielleicht liege ich falsch.

Es wäre nicht das erste Mal und nicht das letzte Mal. Ich werde mal sehen wie’s läuft und ich denke, man kann in diesem Blog auch nachlesen, wenn ich meine Meinung zu etwas geändert habe. Vielleicht passiert es wieder mit F#, vielleicht auch nicht …

Für mich als Einzelprogrammierer gibt es ein paar Wege. Ich kann wie Millionen von andere auf die großen Spieler setzen, ich kann etwas nehmen, was für meinen Bereich am besten zu gebrauchen ist und ich kann nehmen, was mir eher gefällt und auch wenn ich es von Eiffel anders kenne, sehe ich durchaus einen Punkt in dem Sprichwort: “In der Kürze liegt die Würze”

Man kann den Code ja mal in Java, C# oder C++ programmieren und schauen, wie es dann aussieht …