Vorwort

• Ich habe nichts gegen funktionale Programmierung. Im Gegenteil, ich finde sie toll! Und ich versuche OCaml und Haskell zu lernen, wann immer ich die Zeit dazu habe... was leider nicht besonders oft ist - deswegen bin ich in beiden Sprachen auch noch der totale Anfänger. Wie elegant man einige Probleme mit diesen beiden Programmiersprachen lösen kann ist faszinierend! Wirklich hübsch.
• Ich verstehe, dass eine funktionale keine objektorientierte Programmiersprache ist. In der Vorlesung wurde aber genau das versucht - ein objektorientiertes Konzept auf ein funktionales abzubilden. Das geht, sicherlich; es ist nur wirklich häßlich und unpassend. Mein Kommentar bezieht sich hierbei also auf die Vorlesung die ich damals gehört habe.
• Leute, wenn ihr mich schon in meinem Gästebuch beleidigen wollt, dann habt doch wenigstens das bischen Mumm, eueren Namen mit einzutragen - dann nehme ich die Kommentare vielleicht sogar ernst. Anonymes stänkern ist einfach nur peinlich.
• Meine Meinung hat sich verändert, seitdem ich zum ersten Mal dazu gezwungen wurde, Scheme zu lernen. Obwohl ich immernoch nicht besonders viel von Scheme halte, glaube ich heute, dass mein ganzer Haß maßgeblich daher kommt, wie es in unserer Vorlesung gelehrt wurde: in einer ausgesprochen stupiden Art und Weise nämlich, die einem dem Spaß an Programmieren vollständig nehmen kann. Trotzdem lasse ich meine Flames hier noch stehen, hauptsächlich aus historischen Gründen und weil es zu vielen klugen und/oder lustigen Einträgen in meinem Gästebuch führt.

Ich halte ausgesprochen wenig von Scheme! Warum?

1. Scheme ist unübersichtlich. Ich kenne keine Sprache (Brainfuck und vielleicht Assembler Opcode ausgenommen) die chaotischer ist.
2. Scheme-Interpreter sind langsam, weil kein richtiger Programmierer seine Zeit damit verschwendet, einen Interpreter für eine nutzlose Kunstsprache zu optimieren.
3. Scheme ist interpretiert und erleidet dadurch nochmals Performancedefizite (ich habe mich schon eines besseren belehren lassen und eingesehen, dass irgendeine arme Seele wohl mal einen Scheme Compiler produziert hat. Dennoch habe ich von der Scheme-FAQ, die Prof. Görz selbst verlinkt hat, gelesen, dass Scheme u.a. deshalb so träge, langsam und groß ist, weil es beispielsweise erlaubt, das globale "+" zu überladen, oder Funktionen wie "cons" einfach in einem engeren Skopus zu überdefinieren - compile-time-Optimierungen fallen hier dann weg)
4. Scheme ist nicht korrekter als andere Programmiersprachen. Zwar mag die Definition mathematisch vollständig und korrekt sein (als Laie ist mir das unmöglich nachzuvollziehen, daher nehme ich es einfach mal an, weil es mir in der Vorlesung so oft gesagt wurde) - aber die Implementierung ist genauso fehleranfällig wie die anderer Programmiersprachen.
5. Scheme hat nicht mehr Funktionen als andere Programmiersprachen. Auch wenn uns in der Vorlesungen Funktionen höherer Ordnung (functions of higher order) als tolle Neuerung verkauft wurden, das ist nichts neues! Das kann man alles in C auch. Bestes Beispiel: Zur Not kann man sich einen Scheme-Interpreter in C programmieren!
6. Scheme ist nicht typsicher, ganz einfach, weil es keine Typen gibt. In C entspräche das genau einem Typ: "int" (implizit "void*"), mit denen man auch alles realisieren kann... wenn man nur immer weiß, was denn da jetzt nun übergeben wird. Das erhöht nicht nur die Fehleranfälligkeit von Codes beträchtlich, sondern führt auch noch zu einer viel schwereren Wartbarkeit (wenn nicht exzessiv Kommentare verwandt wurden). Strong Typing bereits zur Compilezeit macht es dem Programmierer unmöglich Typfehler zu begehen, die in Scheme womöglich erst irgendwann zur Laufzeit auftreten würden.
7. In Scheme kann man oft syntaktisch korrekten, aber semantisch inkorrekten Code erzeugen, indem man die Klammerung etwas verändert. Diese Fehler sind ausgesprochen schwierig zu finden.
8. Scheme läßt sich nur sehr schlecht debuggen. Einen Fehler zu finden dauert oft ewig, oft liegt es dann wirklich nur an einer verkehrten Klammerung: Katastrophal
9. [Dieser Punkt hat nichts mit Scheme selbst zu tun, sondern eher mit den Aufgaben, die in den Klausuren von Hr. Wilke gestellt wurden]: Die Klausuraufgaben sind nutzlos. So scheint eher die Qualität geprüft zu werden, sich durch endlos verwirrende Zeilen von Code zu wühlen (siehe Klausur 26.3.2003 Aufgabe 1c!) statt ein grundlegendes Verständnis für die Sprache abzuprüfen

Das ist natürlich nur meine persönliche Meinung. Scheme-Fetischisten können gerne ihre Flames in meinem Gästebuch hinterlassen, ich werde mich darüber sicher köstlich amüsieren.

(if Bedingung IfTeil)

(if Bedingung IfTeil ThenTeil)

(cond
    (Bedingung1 Code1)
    (Bedingung2 Code2)
    ...
    (BedingungN CodeN)
    (else CodeElse)
)

(cond
    ((= a 30) (display "A ist 30"))
    ((= a 40) (display "A ist 40"))
    ((= a 100) (display "A ist 100"))
    (else (display "A ist irgendwas anderes"))
)

(let
    ((Alt1 Neu1) (Alt2 Neu2) (Alt3 Neu3))
    Body
)

(let
    ((a 'Scheme))
    ((let
        ((a 'Ist))
        (let
            ((a 'Dreck))
            (let
                ((b 'Stimmt))
                (BodyAnweisung)
            )
        )
    )
)

(let
    Name
    ((Alt1 Neu1) (Alt2 Neu2) (Alt3 Neu3))
    Body
)

(define (sinus x)

)

; Hier mein zweiter Versuch (nach Achims Hilfe):
(define (sinus x)
    (let sinus2 ((sum 0) (pm 1) (nr 1))
        (let ((next (* pm (/ (expt x nr) (fak nr))) ))
            (display (list nr " " next " " sum))
            (newline)
            (
                if (< (abs next) epsilon)
                    (+ sum next)
                    (sinus2 (+ sum next) (* -1 pm) (+ 2 nr))
            )
        )
    )
)

(define x 123)

(let ((x 4)
      (y x))
      (+ x y)
)
=> 127

(define x 123)

(let* ((x 4)
       (y x))
       (+ x y)
)
=> 8

(define x 123)

(let* ((x 4)
       (y x))
       (+ x y)
)
=> 8

(let ((x 4))
    ((let ((y x))
        (+ x y)
    ))
)
=> 8

(cons 'Teil1 'Teil2) =
= (Teil1 . Teil2)

(cons 'Teil1 (cons 'Teil2 (cons 'Teil3 (cons 'Teil4 'Teil5)))) =
= ('Teil1 . ('Teil2 . ('Teil3 . ('Teil4 . 'Teil5)))) =
= ('Teil1 'Teil2 'Teil3 'Teil4 . 'Teil5)

(cons 'Teil1 (cons 'Teil2 (cons 'Teil3 (cons 'Teil4 '())))) =
= ('Teil1 . ('Teil2 . ('Teil3 . ('Teil4 . '())))) =
= ('Teil1 'Teil2 'Teil3 'Teil4)

(car(cdr x)) = (cadr x)
(cdr(car x)) = (cdar x)
(car(cdr(cdr(cdr x)))) = (cadddr x)
(cdr(car(car(car x)))) = (cdaaar x)

(define x '('Muh 'Macht '('Die 'Tolle) 'Kuh))

(cadaddr x) = (car (cdr (car (cdr (cdr x))))) =

(car (cdr (car (cdr (cdr
    '('Muh 'Macht '('Die 'Tolle) 'Kuh)
))))) =

(car (cdr (car (cdr
    '('Macht '('Die 'Tolle) 'Kuh)
)))) =

(car (cdr (car
    '('('Die 'Tolle) 'Kuh)
))) =

(car (cdr
    '('Die 'Tolle)
)) =

(car
    '('Tolle)
) =

'Tolle

(lambda
    (FormalerParameter1 FormalerParameter2 ... FormalerParameterN)
    (Body)
)

(lambda
    (x y z)
    (+ x (* y z))
)

=> #[closure 81b6f00]

((lambda
    (x y z)
    (+ x (* y z))
) 10 20 30)

=> 610

(define funktion (lambda
    (x y z)
    (+ x (* y z))
))

(funktion 10 20 30)

=> 610

(define Liste '('Scheme 'Ist 'Scheisse))
(define Paar (cons 'Sehr 'Richtig!))
(define LeereListe '())

Liste      = ('Scheme 'Ist 'Scheisse)
Paar       = ('Sehr . 'Richtig)
LeereListe = ()

(list? Liste)      = #t
(list? Paar)       = #f
(list? LeereListe) = #t

(pair? Liste)      = #t
(pair? Paar)       = #t
(pair? LeereListe) = #f

(null? Liste)      = #f
(null? Paar)       = #f
(null? LeereListe) = #t