Schleifen und Skriptunterbrechung

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
4 messages Options
Reply | Threaded
Open this post in threaded view
|

Schleifen und Skriptunterbrechung

Markus Schlager-2
Liebe Squeaker,

Tweak ist leider noch nicht so weit, wie ich es mir wünschen würde, und so
stehe ich immer noch vor dem Problem, so etwas wie Zaehlschleifen und bedingte
Wiederholungen in eToys zu benötigen, wenn ich ab Februar Squeak im
Informatikunterricht einsetzen möchte.

Ich habe durchaus verstanden, daß diese imperativen Konzepte nicht so ganz im
objektorientierten Sinne der eToys sein mögen, aber Lehrplan ist Lehrplan und
so ganz unsinnig ist es dann ja auch wieder nicht, diese Konzepte
kennenzulernen (Zielgruppe sind bei mir Siebtklässler, die schon etwas über
Kalssen, Objekte, Nachrichten und Methoden gelernt haben und nun in die
Ablaufmodellierung einsteigen sollen. Grob gesagt möchte ich mit Squeak das
machen können, was z.B. Robot Karol bietet).

Die Grundidee, an der ich momentan herumzubasteln versuche, ist letztlich eine
Klasse 'Schleifenblock', realisiert in eToys als ein Behälter-Morph, das als
Objektlager Zuweisungskacheln für seine eigenen Variablen enthält (sowie
evtl. deren Beobachter). Die Variablen sind das Objekt, dem der Schleifenblock
dienen soll, die Schleifenzahl bzw. -bedingung sowie das Skript, das in der
Schleife ausgeführt werden soll.

In einer Vorversion (noch ohne eigene Schleifenblock-klasse) z.B. zum Zeichnen
von Vielecken sieht das etwa so aus:

+++++++++++++++++++++++++++++++++
zaehlschleife
        self getSchleifenzaehler > 0 ~~ false
             ifTrue: [self doScript: self getSchleifenskript.
                           self setSchleifenzaehler: self getSchleifenzaehler
        - 1]
          ifFalse: [self stopScript: #zaehlschleife]

machZaehlerMal: t1
                self setSchleifenskript: t1.
                self startScript: #zaehlschleife

schritt
        self forward: 50.
        self turn: 36

weg
        self setSchleifenzaehler: 10.
        self machZaehlerMal: #schritt
++++++++++++++++++++++++++++++++++

Das läuft soweit ja auch ganz schön. Daß der Schleifeninhalt ein
eigenständiges Skript ist (schritt), stört mich nicht gar zu sehr und hat
didaktisch durchaus auch gute Seiten.

Mein echtes Problem tritt in dem Moment auf, in dem im Hauptprogramm 'weg' vor
und nach der Schleife mit den zehn Schritten noch andere Dinge passieren
sollen, etwa weil das MorphObjekt ein Muster aus solchen Zehnecken zeichnen
soll (wobei ich gerne zusehen können möchte, wie die Zehnecke Seite für Seite
gezeichnet werden - als extreme Notlösung, bei der so ein Zehneck dann auf
einmal da wäre, habe ich bei den Spaniern schon einen Patch für ein
TimesRepeatTile gefunden).

Konkretes Bsp:

+++++++++++++++++++++++++++++++
langerWeg
        self forward: 100.
        self setSchleifenzaehler: 10.
        self machZaehlerMal: #schritt.
        self forward: 200.
        self turn: 20
+++++++++++++++++++++++++++++++

Das führt dazu, daß die 'forward: 200' parallel zu den zehn Schritten
ausgeführt werden anstatt erst im Anschluß.

Daher die Frage: Gibt es eine Möglichkeit, das Skript 'langerWeg' anzuhalten,
sobald die Zehnerschleife beginnt, und es im Anschluß daran _beginnend mit der
Zeile 'self forward: 200'_ wieder zu starten? Oder läßt mir der
Step-Mechanismus hier keine Chance?

Und weil ich schon einmal am Fragen bin: Weiß jemand von euch zufällig, ob ich
größere Komplikationen zu erwarten habe, wenn das squeakland-Image ohne ein
secure-Verzeichnis laufen soll? (So ganz habe ich Sinn, Zweck und
Funktionsweise des Security-Systems noch nicht verstanden. Wozu sind die
Schlüssel gut, solange ich nicht mit Nebraska, Netmorphs oder solchen Dingen
arbeite?)

Hintergrund der Frage ist der, daß ich mit schreibgeschützten,
rechnerbezogenen Images arbeiten möchte und wir inzwischen ein
MultiSeat-System aufgezogen haben, bei dem vier Benutzer gleichzeitig an ein
und demselben PC und folglich in der einfachsten Variante auch gleichzeitig
mit ein und demselben Image arbeiten (alles unter ubuntu-Linux). Erste
Testläufe zeigen, daß das auch zu gehen scheint. Die USERDIR-Umgebungsvariable
leistet mir dabei gute Dienste. Für das Secure-Dir gibt es so etwas leider
(noch?) nicht, was mich vor die Wahl stellt, entweder das secure-Verzeichnis
im Grunde einfach zu streichen oder aber die Schreibrechte auszuweiten. Was
ist schlimmer?

Schöne Grüße

Markus
-----------------------------------------------
 Markus Schlager               m.slg(at)gmx.de

Reply | Threaded
Open this post in threaded view
|

AW: Schleifen und Skriptunterbrechung

Knut Polkehn
Hallo Markus,

> Das führt dazu, daß die 'forward: 200' parallel zu den zehn Schritten
> ausgeführt werden anstatt erst im Anschluß.
>
> Daher die Frage: Gibt es eine Möglichkeit, das Skript
> 'langerWeg' anzuhalten,
> sobald die Zehnerschleife beginnt, und es im Anschluß daran
> _beginnend mit der
> Zeile 'self forward: 200'_ wieder zu starten? Oder läßt mir der
> Step-Mechanismus hier keine Chance?

Die Lösung besteht meiner Ansicht nach nicht darin, das Skript zu stoppen,
sondern andersrum, die Vorteile der Objektorientierung auszuspielen. Ich
würde für das angegebene Beispiel einen Morph für das abstrakte Objekt
"Zeichnung erstellen" benutzen (z. B. einen Button, der das Ganze startet)
und da alle Skripte zur Generierung der Zeichnungen unterbringen, also:
- ein allgemeines Skript "allesZeichnen" welches im wesentlichen die
Zustandsvariablen "vObjektzahl" (Anzahl der noch zu zeichnenden Objekte),
sowie "vInArbeit" (ob gerade ein Objekt gezeichnet wird) überwacht und das
Skript "Objekt zeichnen" aufruft.
- ein Skript "Objekt Zeichnen", das die Schleife realisiert, gegen die
Schrittzahl (auch eine Variable dieses Morphes)testet und nach Erreichen der
Vorgabe das Skript "neue Positionen" aufruft und das
- Skript "neue Position", welches die abschliessenden Befehle (z. B.
'forward: 200') und das setzen der Zustandsvariablen  realisiert.
Über die Tickzeit für das Skript "Objekt zeichnen" kann ich dann
realisieren, dass nicht zu schnell gezeichnet wird.
Falls das jetzt zu unklar formuliert war oder ich Dein Problem nicht richtig
verstanden habe, schreibe mir einfach nochmal.

In bezug auf die anderen Fragen habe ich keine Ahnung.

Viele Grüsse

Knut

-------------------------------------------------------
Dipl.-Psych. Knut Polkehn
Ingenieurpsychologie / Kognitive Ergonomie
Institut für Psychologie
Humboldt-Universität zu Berlin
Rudower Chaussee 18
12489 Berlin
-------------------------------------------------------
mailto:[hidden email]

Tel. : +49(30)2093 9357
Mobil: +49(172)803 7387
Fax  : +49(30)2093 2021 9357
-------------------------------------------------------
http://www3.psychologie.hu-berlin.de/ingpsy
-------------------------------------------------------
Usability bei
artop - Institut an der Humboldt-Universität zu Berlin
http://www.artop.de
-------------------------------------------------------



Reply | Threaded
Open this post in threaded view
|

AW: Schleifen und Skriptunterbrechung

Knut Polkehn
In reply to this post by Markus Schlager-2
Hallo Markus,
Habe gerade nochmal schnell das Beschrieben umgesetzt. Vielleicht hilft es
ja.

Viele Grüsse

Knut

-------------------------------------------------------
Dipl.-Psych. Knut Polkehn
Ingenieurpsychologie / Kognitive Ergonomie
Institut für Psychologie
Humboldt-Universität zu Berlin
Rudower Chaussee 18
12489 Berlin
-------------------------------------------------------
mailto:[hidden email]

Tel. : +49(30)2093 9357
Mobil: +49(172)803 7387
Fax  : +49(30)2093 2021 9357
WWW  : http://www3.psychologie.hu-berlin.de/ingpsy
-------------------------------------------------------

> -----Ursprüngliche Nachricht-----
> Von: [hidden email]
> [mailto:[hidden email]] Im
> Auftrag von Markus Schlager
> Gesendet: Donnerstag, 15. Dezember 2005 23:15
> An: e.V. Squeak
> Betreff: [Squeak-ev] Schleifen und Skriptunterbrechung
>
> Liebe Squeaker,
>
> Tweak ist leider noch nicht so weit, wie ich es mir wünschen
> würde, und so
> stehe ich immer noch vor dem Problem, so etwas wie
> Zaehlschleifen und bedingte
> Wiederholungen in eToys zu benötigen, wenn ich ab Februar Squeak im
> Informatikunterricht einsetzen möchte.
>
> Ich habe durchaus verstanden, daß diese imperativen Konzepte
> nicht so ganz im
> objektorientierten Sinne der eToys sein mögen, aber Lehrplan
> ist Lehrplan und
> so ganz unsinnig ist es dann ja auch wieder nicht, diese Konzepte
> kennenzulernen (Zielgruppe sind bei mir Siebtklässler, die
> schon etwas über
> Kalssen, Objekte, Nachrichten und Methoden gelernt haben und
> nun in die
> Ablaufmodellierung einsteigen sollen. Grob gesagt möchte ich
> mit Squeak das
> machen können, was z.B. Robot Karol bietet).
>
> Die Grundidee, an der ich momentan herumzubasteln versuche,
> ist letztlich eine
> Klasse 'Schleifenblock', realisiert in eToys als ein
> Behälter-Morph, das als
> Objektlager Zuweisungskacheln für seine eigenen Variablen
> enthält (sowie
> evtl. deren Beobachter). Die Variablen sind das Objekt, dem
> der Schleifenblock
> dienen soll, die Schleifenzahl bzw. -bedingung sowie das
> Skript, das in der
> Schleife ausgeführt werden soll.
>
> In einer Vorversion (noch ohne eigene Schleifenblock-klasse)
> z.B. zum Zeichnen
> von Vielecken sieht das etwa so aus:
>
> +++++++++++++++++++++++++++++++++
> zaehlschleife
> self getSchleifenzaehler > 0 ~~ false
>     ifTrue: [self doScript: self getSchleifenskript.
>   self setSchleifenzaehler: self
> getSchleifenzaehler
> - 1]
>  ifFalse: [self stopScript: #zaehlschleife]
>
> machZaehlerMal: t1
> self setSchleifenskript: t1.
> self startScript: #zaehlschleife
>
> schritt
> self forward: 50.
> self turn: 36
>
> weg
> self setSchleifenzaehler: 10.
> self machZaehlerMal: #schritt
> ++++++++++++++++++++++++++++++++++
>
> Das läuft soweit ja auch ganz schön. Daß der Schleifeninhalt ein
> eigenständiges Skript ist (schritt), stört mich nicht gar zu
> sehr und hat
> didaktisch durchaus auch gute Seiten.
>
> Mein echtes Problem tritt in dem Moment auf, in dem im
> Hauptprogramm 'weg' vor
> und nach der Schleife mit den zehn Schritten noch andere
> Dinge passieren
> sollen, etwa weil das MorphObjekt ein Muster aus solchen
> Zehnecken zeichnen
> soll (wobei ich gerne zusehen können möchte, wie die Zehnecke
> Seite für Seite
> gezeichnet werden - als extreme Notlösung, bei der so ein
> Zehneck dann auf
> einmal da wäre, habe ich bei den Spaniern schon einen Patch für ein
> TimesRepeatTile gefunden).
>
> Konkretes Bsp:
>
> +++++++++++++++++++++++++++++++
> langerWeg
> self forward: 100.
> self setSchleifenzaehler: 10.
> self machZaehlerMal: #schritt.
> self forward: 200.
> self turn: 20
> +++++++++++++++++++++++++++++++
>
> Das führt dazu, daß die 'forward: 200' parallel zu den zehn Schritten
> ausgeführt werden anstatt erst im Anschluß.
>
> Daher die Frage: Gibt es eine Möglichkeit, das Skript
> 'langerWeg' anzuhalten,
> sobald die Zehnerschleife beginnt, und es im Anschluß daran
> _beginnend mit der
> Zeile 'self forward: 200'_ wieder zu starten? Oder läßt mir der
> Step-Mechanismus hier keine Chance?
>
> Und weil ich schon einmal am Fragen bin: Weiß jemand von euch
> zufällig, ob ich
> größere Komplikationen zu erwarten habe, wenn das
> squeakland-Image ohne ein
> secure-Verzeichnis laufen soll? (So ganz habe ich Sinn, Zweck und
> Funktionsweise des Security-Systems noch nicht verstanden.
> Wozu sind die
> Schlüssel gut, solange ich nicht mit Nebraska, Netmorphs oder
> solchen Dingen
> arbeite?)
>
> Hintergrund der Frage ist der, daß ich mit schreibgeschützten,
> rechnerbezogenen Images arbeiten möchte und wir inzwischen ein
> MultiSeat-System aufgezogen haben, bei dem vier Benutzer
> gleichzeitig an ein
> und demselben PC und folglich in der einfachsten Variante
> auch gleichzeitig
> mit ein und demselben Image arbeiten (alles unter ubuntu-Linux). Erste
> Testläufe zeigen, daß das auch zu gehen scheint. Die
> USERDIR-Umgebungsvariable
> leistet mir dabei gute Dienste. Für das Secure-Dir gibt es so
> etwas leider
> (noch?) nicht, was mich vor die Wahl stellt, entweder das
> secure-Verzeichnis
> im Grunde einfach zu streichen oder aber die Schreibrechte
> auszuweiten. Was
> ist schlimmer?
>
> Schöne Grüße
>
> Markus
> -----------------------------------------------
>  Markus Schlager               m.slg(at)gmx.de
>

quadrateZeichnen.gif (1K) Download Attachment
quadrateZeichnen.009.pr (171K) Download Attachment
Reply | Threaded
Open this post in threaded view
|

Re: AW: Schleifen und Skriptunterbrechung

Markus Schlager-2
Hallo Knut,

Vielen Dank für den Tip mit den Semaphoren! Das bringt mich in der Tat ein
gutes Stück weiter. An der Stelle auch einen kleinen Dank an Uwe für sein
MazeProjekt. Die Idee, in einem Behälter mit Kacheln zu programmieren und dann
auch durch den Zeiger dem Programm schön beim Laufen zuschauen zu können, habe
ich mir frech zu klauen erlaubt. Nur möchte ich halt auch Kacheln für
Verzweigungen und Schleifen sowie evtl. Unterprogramme. Es sieht im Moment
nicht schlecht aus. (Teilweise scheine ich noch Synchronisationsprobleme beim
Setzen der Semaphoren zu haben. Meine Schleifen lassen z.B. den ersten Schritt
aus und machen den letzten doppelt.)

Bislang habe ich mir das alles mit eToys zusammengeklickt, stoße jetzt aber
wohl doch an die Grenzen dieses Vorgehens. Naja, darf ich halt wieder einmal
etwas dazulernen - auch recht.

Vielleicht noch zwei konkrete Fragen:

1. Gibt es bei eToy-Skripten auch so etwas wie Kacheln für lokale Variablen,
   die nur innerhalb des Skripts benutzt werden? Oder ist das nur im Textmodus
   zu machen?

2. Meine Schleifenkacheln sind einfach Behälter, die einen Beobachter für eine
   ihrer Variablen (die Schleifenzahl) und einen weiteren Behälter für den
   Schleifeninhalt enthalten. Diese beiden Objekte sind in dem Behälter
   eingebettet und auch als Variablen des Behälters diesem bekannt. Wenn ich
   nun so eine Schleifenkachel in einem Objektlager deponiere und in der Folge
   Kopien erzeuge, darf ich dann davon ausgehen, daß diese Kopien ihre beiden
   Bestandteile (Zähler und Block) als solche auch automatisch kennen, oder
   muß ich die betreffenden Variablen immer erst eigens mit Hilfe des Zeigers
   mit den richtigen Objekten belegen?

3. Werden Variablen eines Objektes durch gleichnamige lokale Variablen etwa
   eines Skriptes dieses Objektes verdeckt oder gelten sie als global und
   werden bei solchen Namenskollisionen auch überschrieben (Seiteneffekt)?

Hintergrund: Ich habe ein Objekt 'Programm', mit einer Variablen
'Programmblock', der jeweils ein Behälter voller Kacheln (der 'Programmtext',
oder, wenn im Programmtext ein Schleifenbehälter auftaucht. zwischendurch
dessen 'Schleifenblock') als Wert zugewiesen wird, und einer Methode
'werteAus', die innerhalb des gerade aktuellen Programmblocks den Zeiger von
Kachel zu Kachel wandern läßt und die zu den Kacheln gehörigen Befehle
aufruft. Jeder der Blöcke hat eine eigene Semaphore
'SchrittInArbeit'. Spätestens bei einer Schleife innerhalb einer anderen stehe
ich dann vor solchen Namensüberschneidungen.

Schöne Grüße

Markus
-----------------------------------------------
 Markus Schlager               m.slg(at)gmx.de