Squeak-Etoys-Homepage aus dem Dornröschenschlaf wecken

Am 12.11.2011 um 23:54 schrieb "R. Baumann" <[hidden email]>:

> Hallo Guido,
>
> was du über Byob schreibst, überzeugt mich.
> Werde ab sofort Byob lernen.

Das freut mich sehr!!! :-)

>
> Noch eine Frage: Ab welchem Alter kann man mit Byob anfangen?

Seltsamerweise ist dadurch, dass in BYOB alles "first class object" ist, die Programmierung für Neulinge (als Kids) viel "intuitiver".

Gibt 5-jährige sogar, die's kapieren ... das Gros der Schüler sollte so ab 10., 11. Lebensjahr damit locker klar kommen ..

Viele liebe Grüße, Guido Stepken

>
> (An Enno - bitte baldmöglichst eine Byob-Rubrik in der Homepage einrichten!)

Squeak ist nicht Scratch oder BYOB!!! Aber pädagodische Hinweise können nie schaden!!! :-)

> Welche Sprachen lernt Informatikstudent heutzutage eigentlich im Studium? Hier heißt es unter anderem auch deshalb, Java sei die Sprache der Wahl, weil die dann auch im Studium kommt.
>
> Markus

Hallo, Markus!

Als Pädagoge muß man doch Schüler dazu bewegen, genau das zu lernen, was sie *noch nicht können* !!!

Wenn Java später im Studium eh kommt, dann ist *gerade das* ein Grund, daß sie auf der Schule was anderes lernen.

Und da das *zuerst gelernte* die Grundlage bildet, weiteres Wissen einzuordnen, sollte man gerade auf der Schule in Informatik eine Programmiersprache lehren, die das "objektorientierte Denken" und funktionale Algorithmen bzw. Programmiersprachen (Haskell, ML, LISP) in die Hirne eintrichtern.

Haskell, warum? Die Algorithmen der Prigrammiersprache Haskell sind automatisch parallelisierbar.

Da jetzt aus Stromspargründen Multiprozessor - Handys auf den Markt kommen (4 Prozessoren bei halber Taktfrequenz macht doppelte Gesamt-Rechenleistung bei gleichem Stromverbrauch), tippe ich mal darauf, dass in wenigen Jahren Haskell DIE universitäre Lehrsprache wird.

Java ist bereits jetzt schon tot: "Unparallelizable by design"

Gerade unternehmen die Compilerhersteller riesige Anstrengungen, wenigstens die Libraries in C++ auf automatisch parallelisierende, funktionale Algorithmen umzustellen.

Viele liebe Grüße, Guido Stepken

Hallo Guido,

Kann ich eigentlich alles nur abnicken. Abgesehen davon, daß ich von den
technischen Details eher weniger Ahnung habe, sehe ich das sehr genauso.
Schadet nicht, das wieder einmal bestätigt zu bekommen.

(Ich selber habe OO auch erst dank Etoys und Squeak wirklich verstanden.
War eine schöne Erkenntnis.)

Markus

Markus Schlager:

> Ich selber habe OO auch erst dank Etoys und Squeak wirklich verstanden.

Ich leider noch nicht. Im Byob-Handbuch lesen wir:

"The idea of object oriented programming is often taught in a way that makes it seem as if a special object oriented programming language is necessary. In fact, any language with first class procedures allows objects to be implemented explicitly; this is a useful exercise to help demystify objects.
The central idea of this implementation is that an object is represented as a dispatch procedure that takes a message as input and reports the corresponding method."

Was ist eine "dispatch procedure"? Gibt es dafür einen (für Schüler) verständlichen Ausdruck?

Dank für Aufklärung.

R. Baumann

Am 14.11.2011 20:34, schrieb R. Baumann:
>
> Was ist eine "dispatch procedure"? Gibt es dafür einen (für Schüler)
> verständlichen Ausdruck?
Ein Versandverfahren. Wobei der Begriff im dt. Sprachgebrauch eher beim
Zoll zu finden ist ;-)

Mirek

Dis- aus dem Lateinischen Zer- Ent- und patch - Flicken

Bedeutet, dass ich von aussen in einen Prozess eingreife, diesem die Kontrolle entziehe (Dis-) und dann daraus einen neuen Prozess "zusammenflicke" (patch).

Gruß, Guido Stepken

Am 14.11.2011 um 20:38 schrieb Mirek Hancl <[hidden email]>:

> Am 14.11.2011 20:34, schrieb R. Baumann:
>>
>> Was ist eine "dispatch procedure"? Gibt es dafür einen (für Schüler)
>> verständlichen Ausdruck?
> Ein Versandverfahren. Wobei der Begriff im dt. Sprachgebrauch eher beim Zoll zu finden ist ;-)
>
> Mirek

"R. Baumann" <[hidden email]> writes:

Hallo Rüdeger

Ich habe das BYOB-Handbuch nicht gelesen, denke aber das der Autor hier
auf das von LISP (Clos) verwendete Verfahren Bezug nimmt.

http://www.ravenbrook.com/doc/2003/07/15/clos-fundamentals/

Ab Kapitel 4 wird der Dispatch-Vorgang beschrieben. Sollte aber auch in
jedem anderen guten Buch zu CLOS enthalten sein. Obs da was deutsches
gibt weiss ich nicht.

BTW: Auf Squeakmap findet man ein aktuelles LispKit (allerdings ohne
CLOS). Trotzdem ganz lehrreich.

Bis dann
Enno

Enrico Schwass <[hidden email]> writes:

Kurzer Nachtrag,

Jetzt habe ich doch mal auf die BYOB-Seite geschaut und dort folgendes
gefunden

--------------------------------------------------------------------
The detailed design of first class procedures in BYOB was strongly
influenced by Scheme, a Lisp dialect invented in the late 1970s by
Gerald Jay Sussman and Guy Steele, which brought Lisp closer to its
roots in lambda calculus by introducing lexical scoping rules.
---------------------------------------------------------------------

Damit lag ich also fast richtig :)

R. Baumann schrieb: Ich denke wie Enrico, das kommt aus der Ecke der funktionalen Sprachen,
wenn die Objekte mit ihren eigenen Sprachmitteln implementieren ("das
konnte Lisp doch schon immer...").

"Dispatch" heißt versenden auf englisch.

Zitat aus einem CLOS-Buch:-----------
Dispatching [ist ein] Begriff aus der realen Welt, der von der
Computerwelt übernommen wurde. Das Dispatching beschreibt die Reaktion
auf einen bestimmten Wert oder Eingabe. Man kann sich das sehr schön
bildhaft in einer Postverteilstation vorstellen: Ein Postbeamter (der
Verteiler), umgeben von Postsäcken. Entsprechend der Postleitzahl auf
dem Päckchen oder Brief, wird es in den dafür bestimmten Sack geworfen.
In CLOS sind die Postsäcke die Methoden, der Postbeamte ist der
dispatcher, die Päckchen und Briefe sind die Instanzen, und die
Postleitzahlen sind die Klassen, nach denen sie klassifiziert werden.
----------------------
(Paul Graham: ANSI Common Lisp)

In meinen eigenen Worten:

Die Lisp-Leute "simulieren" bzw. "implementieren" (je nach Sichtweise
und Wertung) Objekte durch eine Funktion, die einen Aufruf wie

objekt tuWasMit: parameter

auch in Lisp möglich machen (an die richtige Stelle schicken), ohne eine
neue Sprache zu erfinden.

Im Hintergrund müssen dafür Methoden als spezielle Funktionen definiert
werden, die nur mit einem bestimmten Typ von Argument (Klasse) arbeiten,
und die erst vom diapatcher aufgerufen werden. Das geht im Prinzip in
allen Sprachen, wo eine Funktion als Parameter weitergereicht werden
kann (first class fuction).

in Smalltalk-Syntax:

dispatcher versende: objekt anMethode: methode

Der dispatcher kann das Objekt inspizieren, erfährt dessen Klasse und
findet dann die korrekte Methode.

Schöne Grüße

Christian Mascher

Dank für interessante Ausführungen, auch an Mirek und Enno.

Zu Guidos Etymologie: "Dispatch" dürfte dem dt. Lehnwort  "Depeche" entsprechen, das aus dem Lateinischen (lat. pedica = Fußfessel) kommt: "Von der Fußfessel befreien" = beschleunigen, absenden.
Wo kommt "patch" eigentlich her?

Im übrigen scheint das Handbuch von Byob auf einem informatisch hohen Niveau zu stehen.

R. B.

Hallo Rüdeger,

OOP nach SICP-Art (Abelson & Sussman) kann man natürlich nicht nur in Scheme selber bauen, sondern auch in Smalltalk, denn auch Smalltalk hat first class Funktionen, nämlich Blöcke, und zumindest in den meisten Dialekten inzwischen auch echte Closures, also temporäre Variables, welche die Ausführung ihrer Funktion "überleben" können.

Mit diesem Effekt kann man objektorientierte Systeme nach dem Prinzip "Objekte sind auch nur Closures" selbst erfinden.

Um das Schulbeispiel eines einfachen Zählers in Smalltalk nachzuvollziehen, kannst Du z.B. in einer Smalltalk Workspace sinngemäß folgendes ausprobieren (und dabei der Einfachheit halber die Variablen "CounterClass", "Counter1" und "Counter2" global deklarieren):

    CounterClass := [ | count |
        count := 0.
        ^[count := count + 1.
            ^count]].

Damit hast Du der Variable namens "CounterClass" einen Dispatch-Block zugewiesen. Führt man diesen Block aus, erhält man als Ergebnis einen anderen Block, den man wiederum anderen Variablen zuweisen kann:

    Counter1 := CounterClass value.
    Counter2 := CounterClass value.

Auch diese Blöcke kann man jetzt jeweils einzeln ausführen:

    Counter1 value.

ergibt als Ergebnis "1".

Jedesmal wenn Du diesen Ausdrück erneut ausführst, erhältst Du ein um 1 inkrementiertes Ergebnis. Gleiches gilt für weitere Counter-Instanzen:

    3 timesRepeat: [Counter2 value].

Das Besondere daran ist, dass sich jede Counter-Instanz ihren eigenen Zählerstand merkt, ganz wie ein echtes Objekt eben. Das liegt daran, dass die temporäre Blockvariable "count" in einer äußeren Scope, nämlich im Dispatch-Block angelegt ist. Die inneren Blöcke (Counter1 und Counter2) verweisen auf diese eigentlich temporäre Variable, und machen sie somit persistent, sogar nachdem der ursprüngliche "CounterClass" Block längst ausgeführt worden ist.

Nun kann man natürlich den Dispatch-Block noch wesentlich komplexer gestalten, und insbesondere den "Objekt-Blöcken" noch Block-Argumente mit Fallunterscheidungen zuweisen. Auf diese Art kann man dann z.B. verschiedene Nachrichten und auch Parameter an solche Closure-Objekte implementieren, und sogar Vererbung selber bauen.

Viele Grüße
-Jens

Danke, Jens, für diese Ausführungen.
Vielleicht lassen sie sich in einem LOG-IN-Artikel zum Vergleich von Squeak/Etoys mit Byob verwenden.

Enno, wenn du dies liest, richte bitte in unserer Homepage cmsbox unter „Literatur“ eine Unter-Rubrik „Didaktische Aufsätze“ ein und bringe dann folgenden Text:

Modrow, E.; Möning, J.; Strecker, K.: Wozu Java? – Plädoyer für grafisches Programmieren.
In: LOG IN, 31. Jg. (2011), H. 168, S. 35–41.

Dieser Beitrag plädiert dafür, das Aufkommen universeller grafischer Programmiersprachen (wie z. B. Squeak/Etoys, Byob) zum Anlass zu nehmen, über die Rolle des Programmierens im Informatikunterricht neu nachzudenken. „Java“ ist dabei als Synonym für jegliches textbasierte Programmieren gemeint.

Oldenburg, R.: Klassensysteme selbstgebaut – Ein genetischer Weg zu OOP und OOM.
In: LOG IN, 30. Jg. (2010), H. 166/167, S. 85–91.

In diesem Beitrag wird gezeigt, dass die Konzepte der Objektorientierung kein grundlegend neues Paradigma darstellen, sondern sich ganz natürlich aus dem Bemühen ergeben, Daten und Strukturen zweckmäßig zu strukturieren. Im letzten Beispiel (von vieren) wird ein Konstruktor definiert, also eine Funktion, die ein Objekt erstellt, wobei dieses Objekt seinerseits eine Funktion ist, mit deren Aufruf man die verschiedenen Methoden ansteuert.

Den geneigten Teilnehmern dieser Liste wird die genannte Zeitschrift zwecks Bezug und Lektüre wärmstens empfohlen, da sie offenbar den Finger am didaktischen Puls der Zeit hat.

R. B.