Lava Feed Back / Erfahrungsbericht
 
StartSeite | LavaFeedBack/ | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern

Mein Erfahrungsbericht über den Einstieg in LAVA

Vorwort

Da ich letzten Herbst (September 2003) ein Informatik-Studium begonnen habe und derzeit unter anderem gerade einen Kurs zur objektorientierten Programmierung (inbesondere mit Java) belegt habe, wühlte ich mich heute mit dem Stichwort JAVA durch das Internet und stiess dabei auf die Programmiersprache LAVA ( http://lavape.sourceforge.net/index.htm). Zu meiner Person sollte ich vielleicht noch erwähnen, dass ich schon seit 1987 hauptberuflich Software entwickle und dabei schon etliche Programmiersprachen kennen und hassen gelernt habe. Trotzdem erstelle ich gerne Software, da ich dies als einen schöpferischen und somit höchst interessanten Prozess betrachte. Objektorientierung habe ich zwar immer wieder gestreift, aber ich habe nie aus tiefster Seele objektorientiert programmiert. Langer Rede kurzer Sinn: LAVA erschien mir visionär und vor allem bewunderte ich, dass das System tatsächlich von lediglich zwei Leuten erstellt wird.

Mir ist beim Lesen der Dokumente und des Hilfetextes zu LAVA schnell aufgefallen, dass das gesamte System sehr „akademisch“ beschrieben wird. Für Informatiker (aehm.... fertig ausgebildete) ist das zwar von Vorteil, aber ich behaupte mal, es gibt eine ganze Menge Programmierer (so wie mich), die nicht Informatik studiert haben und deshalb doch so etliche Probleme haben dürften, einen Einstieg in LAVA zu schaffen. Dies steht aber grundsätzlich im Widerspruch zur Intention von LAVA, derzufolge man schnell Zugang zu dieser Programmiersprache finden soll (in der Doku heisst es, dass man zBsp nicht mühseelig die Syntax der Sprache zu lernen braucht).

KlausGünther: Wir sprechen nach wie vor von einer "experimentellen" Programmiersprache, was deutlich machen soll, dass wir uns eher an Programmiersprachen-Experten als an den Praktiker wenden und mit Lava vor allem neue Konzepte unter die Leute bringen wollen. Was das Syntaxlernen angeht: Man muss ja tatsächlich z.B. nicht auswendig wissen, wie ein Function-Call syntaktisch gebaut ist, man muss nur wissen, dass es in Lava so etwas gibt, welchen Button man klicken muss, um einen Function-Call einzufügen und man muss die besondere Semantik von Function-calls in Lava kennen, insb. die Unterscheidung von Input- und Output-Parametern.

Aber es ist ganz klar, und du hast uns dankenswerterweise noch einmal mit der Nase darauf gestoßen, dass man noch mehr gezielte Online-Hilfe geben muss, die dem Neuling, ohne dass er erst vorbereitend eine Menge Erklärungen "auf Vorrat" lesen muss,

In dem neuesten Lava-Release (0.7.5) sind schon die Buttons und Handler für eine solche "What's this?"-, "What next?"- und "How to..."-Hilfe vorhanden, nur die Hilfe-Texte fehlen noch. (Das wird noch eine größere Fleißarbeit, aber du hast uns den Anstoß gegeben, das jetzt doch mal in Angriff zu nehmen. Danke!)

Ich möchte nun hier diese Lücke schließen, indem ich (ausdrücklich als (noch) Nicht-Informatiker) schildere, wie ich mich in das LAVA-System eingearbeitet habe, bzw. wie ich mich einarbeite, denn ich will möglichst viele von den Anfängerproblemen dokumentieren und das geht meiner Meinung nach im nachhinein weniger gut, als wenn man gerade vor dem Problem steht.

Noch ein Hinweis: Nicht-Programmierer werden mit diesem Erfahrungsbericht eher nichts anfangen können.

So, genug der Worte – lasset Taten folgen ;-)

Installation
Ich habe die Installation unter Windows 2000 Professional vorgenommen. Ausser ein paar Klicks war da nichts zu tun – die Installation kann man daher getrost als äußerst simpel bezeichnen. Ich habe Version 0.6.4 der IDE (Entwicklungsumgebung) installiert – das Installationsfile war nur 1,6 MB gross – daher habe ich mir auch gar nicht grossartig die Mühe gemacht zu prüfen, wie viel Speicher das System nach der Installation „verschlingt“ (vermutlich maximal 5 MB). Trotz dieser geringen Größe waren auch etliche Musterprogramme und ein (englischsprachiger) Hilfetext vorhanden!

Erste zaghafte Schritte
Ja, okay – ich hätte den Hilfetext lesen können, aber ich war einfach zu neugierig, daher legte ich schon mal auf eigene Faust los. Ich öffnete das Musterprogramm „HelloWorld“ (die „Programmierer“, die sich darunter nichts vorstellen können, sollten sich nicht unnötig quälen indem sie hier weiter lesen... - Auf Wiedersehen!). Von diesem Punkt an werde ich jetzt live berichten:

Hm. Irgendwie sieht alles hübscht bunt und gut strukturiert aus. Naja, Java-Programme habe ich vor ein paar Jahren schon mal entwickelt, aber leider inzwischen fast schon alles wieder vergessen – trotzdem sagt mir der Begriff „Package“ etwas. Ganz unwissenschaftlich formuliert ist das einfach eine Zusammenfassung von zusammengehörigen Programmteilen. Tja, und dann gibt es innerhalb dieses Packages Declarations (darin werden wohl Funktionen und Variable? deklariert). Innerhalb der Deklarationen gibt es ein Symbol neben dem „HelloWorld := Initiator“ steht. Initiator ist für mich ein völlig neuer Begriff. Mal nachlesen... Aha. Der Hilfetext erklärt mir, dass Initiator quasi das selbe ist, wie

main
in einem C- oder JAVA-Programm – also ein Einsprungpunkt an dem der Programmablauf beginnt. Laut Hilfetext können hier auch Eingabe-Parameter übergeben und vom Programm ausgelesen werden.

Die Bezeichnung "Initiator" war wohl tatsächlich nicht so glücklich; wir haben sie in "Main program" geändert. Danke.

Ah, da stosse ich gerade auch wieder auf ein Stichwort das ich an anderen Stellen schon im Hilfetext gesichtet habe und das mich etwas „verschreckt“ hat: Rekursion. Im Zuge meines bisher 1semestrigen Informatikstudiums (*g*) bin ich mit diesem Begriff schon einige male konfrontiert worden – in meiner bisherigen Berufspraxis habe ich erst ein einziges mal eine Rekursion selbst programmiert. Es geht letzten Endes darum, dass sich eine Routine selbst aufruft. Da dies prinzipiell zu einer Endlosschleife führen würde, muss man natürlich eine Ausstiegsbedingung definieren. Dies hier aber nur, um kurz den Begriff Rekursion zu erläutern. LAVA scheint aber intensiv von Rekursionen Gebrauch zu machen (genaueres muss ich aber erst noch herausfinden). Das Gegenteil von rekursiv heisst übrigens iterativ.

Über die Rolle von Rekursion in Lava gibt es zwar schon einen Abschnitt in der Online-Hilfe. Aber wir sollten auch in der geplanten "How to"-Hilfe und in der "What's this"-Hilfe zu dem Function-Call-Button einen Querverweis dorthin einbauen. Danke.

Ein Doppelklick auf HelloWorld bringt ein kleines Fensterchen, in dem man einen Namen festlegen kann. Da steht HelloWorld drin. Ich frage mich, ob es unbedingt sein muss, dass diese Deklaration gleich heisst, wie das ganze Lava-Programm. Also ändere ich das einfach mal ab – ich nenne diesen Initiator nun „GummiSchuh?“. Ich klicke in der Symbolleiste auf das kleine schwarze Männchen, da mir das intuitiv am ehesten nach „RUN“ aussieht. Bingo! Es wird ein Programm gestartet, das im Gegensatz zur IDE nur Lava heisst (die IDE heisst LavaPE?) und darin öffnet sich tatsächlich eine kleine Messagebox mit dem Text „Hello World“. Wow, programmieren macht müde *ggg*. Ich schließe jetzt die Messagebox und dann auch gleich diese Runtime-Umgebung (ich nenne das jetzt einfach mal so) die mir ausserdem mitgeteilt hat, dass das Programm normal beendet wurde und bin jetzt wieder in der IDE.

Feststellung: Initiatoren müssen nicht gleich wie das Programm heissen.

Innerhalb des Initiators gibt es wiederum ein Symbol. Es sieht wie ein Zahnrad aus und nennt sich „Exec“. Ich möchte in der Hölle schmoren, wenn exec nicht irgendwas mit execution zu tun hat... Hätte ich vielleicht auch einfach hier einen Doppelklick machen könne, um das Programm zu starten? Mal probieren... Nein, da scheint jetzt der eigentliche Programmcode geöffnet worden zu sein. Da steht

initiator GummiSchuh (hüstel...)

call „Hello World“.MessageBox

Hm... da war doch versprochen worden, dass man sich nicht mit Syntax abplagen muss und jetzt kommt da trotzdem wieder so Zeug daher? Moment mal – wenn ich im Editor herumklicke, merke ich, dass das ein ziemlich ungewöhnlicher Texteditor ist. Man kann gar nicht so ohne weiteres einfach irgendwo hinklicken und Programmcode tippseln.

Auf der Lava-Home-Page wird gleich als erstes darauf hingewiesen, dass Lava alle herkömmlichen Texteditoren durch Struktureditoren ersetzt, aber Struktureditoren sind so ungebräuchlich, dass mancher dann vielleicht trotzdem überrascht ist, wenn er keinen Text zeichenweise eintippen kann.

Ich kenne ein Entwicklungssystem, das sich teilweise zumindest ansatzweise ähnlich verhält wie dieser Lava-Editor und ich muss sagen: die Idee ist gut! Leider komme ich noch nicht so ganz klar mit dem Ding. Ich würde hinter dem Call gerne selbst irgendwas hinpfriemeln – und wenn's nur eine simple Zuweisung ist (wie zBsp Herrensocken:=3). Ich klicke in der links angezeigten Menüleiste mit den offensichtlichen Schlüsselwörtern der Sprache auf set. Schön: hinter der call-Anweisung schreibt das System automatisch hin: set <var> <- <expr>. Schön, fein. Jetzt brauche ich <var> wohl nur durch „Herrensocken“ ersetzen. Hm... wie geht denn das?

Da wird die "What next?"-Hilfe künftig sicher weiterhelfen.

Ich kann zwar herumklicken und gelegentlich wird <var> auch schwarz hinterlegt, aber ich kann dort nichts eingeben. Das Kontextmenü (rechte Maustaste) wird nicht angezeigt. Langsam dämmert's mir: die Sprache laesst mich wohl nicht einfach so schlampig mitten im Programmtext eine neue Variable verwenden, ohne dass sie zuvor deklariert wurde – also versuche ich jetzt erst mal eine Variable zu deklarieren. Ich vermute mal stark, dass das VOR der ersten Verwendung der Variablen erfolgen muss, deswegen bringe ich die Markierung im Programmtext mittels Mausklick mal weiter nach oben und wähle dann aus der Menüleiste declare aus.Aha. Da haben wir ja den Salat:

declare
<type> <varName>
do
<stm>
#declare;

Jetzt muss ich erstmal einen Datentyp auswählen. Herrensocken sind natürlich vom Typ Integer (das wussten Sie nicht? ts ts ts). So, wie sag' ich LavaPE? nun aber, dass ich statt <type> gerne Integer oder meinetwegen INT da stehen hätte? Ah, das ist mir gar nicht richtig aufgefallen: oben im aktuellen Fenster sind zwei Comboboxes aktiv geworden. In der rechten davon steht (Basic Types) – na wenn das nicht genau das ist, wonach ich suche.... Ja, da wähle ich Integer aus und schon stehts im Programmtext – toll eigentlich viel weniger Arbeit, als Integer hinzuschreiben – jetzt können auch Legastheniker programmieren. Aus purer Neugier schaue ich mir jetzt die linke Combobox auch noch gleich an – da steht nur (Types) drin und angeboten werden Dinge, die mir eher schleierhaft sind... Callbacks und HardwareExceptions? und RuntimeExceptions?. Halt. So ganz unbekannt ist mir der Begriff Exception nun doch nicht – muss irgendwas mit der Fehlerbehandlung zu tun haben. Ach quatsch: wir sind so gute Programmierer, sowas brauchen wir nicht (keine Sorge, das war nur Spaß – ich wollte damit nur zum Ausdruck bringen, dass ich momentan nicht weiss, wie man das unter Lava einsetzt). So, nun klicke ich noch auf <varName> und ändere das in den Variablennamen „Herrensocken“ - sehr schön!

sosososo. Was'n das? Das Declare hat ja noch ein Do und <stm> (was wohl für Statement steht). Äh – was soll ich denn da machen? Das lass' ich erstmal frei – man wird ja sehen, was dabei rauskommt. Jetzt klicke ich wieder unten auf mein Set-Statement und hier wiederum auf <VAR>. Ahja, auch hier ist die Combobox aktiv – da kann ich jetzt bestimmt meine Variable Herrensocken auswählen. Schnief.... das war wohl nix – die Variable wird hier nicht angezeigt. Hm. Ob das wohl so eine Kapselungsangelegenheit ist? Ich schau nochmal rauf zum Declare und füge anstatt des <stm> ein Set ein. Jawolli – das war's. Jetzt kann ich beim Set-Statement die Variable auswählen. Also darf man wohl nur innerhalb dieser Deklaration auf die Variable zugreifen. Das muss ich erst mal verdauen – wie kann ich denn dann diese Variable zum Beispiel benützen, um deren Wert in der Messagebox also dem Call von „Hello World“.MessageBox? auszugeben?

Ich denke mir, dass ich wohl zuerstmal der Variable Herrensocken den Wert 3 zuweise. Das ging problemlos. Klicken und 3 hintippen – das wars. Da ich mein Declare aber nach der Messagebox stehen habe, kann in der Messagebox auf gar keinen Fall was drin stehen, also Reihenfolge tauschen. STRG-X zum Ausschneiden des Declares und STR-V zum Einf......... aehm. LavaPE?.exe – Fehler in Anwendung. Die Anweisung in „0x0028fb75“ verweist auf Speicher in „0x00000008“. Der Vorgang „read“ konnte nicht auf dem Speicher durchgeführt werden. - Ich liebe Windows.

An der MFC-basierten alten Windows-Version, die du anscheinend benutzt hast, haben wir seit über einem Jahr nichts mehr gemacht. Wenn das bei der aktuellen Version noch passieren sollte, sag' uns bitte Bescheid.

Okay. IDE neu gestartet, HelloWorld-Programm geöffnet und das ganze nochmal von vorne (inzwischen komme ich mit dem Editor schon recht gut zugange. Ein paar Symbole der Toolbar sind mir schon verständlich: insbesondere eines: es fügt neue, leere (mit <stmt> gefüllte) Zeilen hinzu – und eines in der Nähe des gerade erwähnten Symbol welches steuert, ob eine Zeile VOR der aktuellen oder NACH der aktuellen eingefügt werden soll).

Jetzt habe ich mein Declare also vor dem call. Vielleicht kann ich im Call ja jetzt doch auf die Variable zugreifen? Nö, die Combobox zeigt die Variable um's Verrecken nicht an. Mein Instinkt sagt mir, dass das nicht klappen wird, aber ich versuche es trotzdem: ich ändere den Text „Hello World“ einfach in Herrensocken (ohne Anführungszeichen natürlich). Gut, das klappt NICHT – LavaPE? möchte hier gerne eine Konstante sehen. Schreibe ich halt wieder eine Konstante hin: „Schade“.

Okay – noch hab' ich Ideen: Versuche ich doch einfach mal einen Call direkt nach dem Set Herrensocken <- 3 einzubauen. Call, call.... ja verdammt, wo ist denn das in der Menüleiste? Nirgends. Nach 2 Minütchen Sucherei hab ich den Button gefunden – er ist mit x.f bezeichnet, wobei das x unterstrichen ist. Yipieh: Jetzt habe ich ein call und kann als Variable doch tatsächlich Herrensocken auswählen. So, nun noch die Funktion Messagebox. Oh. Schade. Ein Integer hat wohl keine Funktion „MessageBox?“. In der Combobox, die mit (Virtual call) bezeichnet ist, kann ich nur andere Funktionen auswählen. Ich sag's Euch: das macht mich nicht glücklich. Was denn nun?

Könnte ich nicht irgendwie selbst eine Funktion Messagebox für einen Integer basteln? (am besten von String raubkopieren *g*). Da gibt es tatsächlich einen Button der „New exported function“ heisst. Klingt vielversprechend. Ein Klick darauf öffnet ein Dialogfenster mit mir überwiegend unverständlichem Zeug. Da ich dem Integer-Typ durch meine Stümperei keinen Schaden zufügen möchte, nenne ich die Funktion „killme“ (das mache ich immer so, wenn ich irgendwas in ein Programm einbaue, das ich später aber jederzeit rausnehmen kann und soll). Ja, das hat irgendwie funktioniert. Killme kann jetzt per Call aufgerufen werden. Aber killme kann ja eigentlich noch gar nichts machen (ist ja kein code hinterlegt). Ich mache einen Doppelklick auf killme und komme zum Programm std.lava und hier finde ich auch den Datentyp Integer mit seinen Funktionen – unter anderem meine killme-Funktion. Soso, native read-only function steht da. Das halte ich irgendwie für falsch. Aber lassen wir das einstweilen mal. Wie ich sehe hat die Funktion zwei untergeordnete Blätter – Inputs und Outputs. Schön und gut, aber wo hinterlege ich den Programmcode? Der Button „Go to implementation“ klingt gut, sagt mir aber, dass er die Implementierung von diesem Interface nicht gefunden hat. Hä? Kein Wunder, dass er die nicht findet, ich möcht die Funktion ja erst erstellen! Dummes Ding.

Ich lass mich nicht so leicht aus der Ruhe bringen. Ich mache dieses Fenster (std.lava (read only)*) einfach mal zu. Änderungen in std.lava speichern? Naja, speichere ich halt mal, obwohl mein killme-Dingens immer noch drin ist. Oh Mann, das File kann ich nur unter einem anderen Namen abspeichern, denn es ist read only. Nenne ich die Datei halt stdkillme.lava – ist mir eh' sympathischer – so wird an den Originalbibliotheken (sind doch so eine Art Bibliotheken oder?) nichts beschädigt.

Wir haben inzwischen, über die read-only-Eigenschaft von std.lava hinaus, insb. durch Deaktivieren vieler Buttons, dafür gesorgt, dass man in std.lava als Benutzer erst gar nichts ändern kann und std.lava auch nicht durch ein anderes, selbst-erstelltes Lava-File unerkannt ersetzen kann.

Die restlichen Probleme im nachfolgenden Text habe ich nicht mehr alle so genau verstanden, aber ich habe die generelle Hoffnung, dass viele Irrwege durch die im Entstehen begriffene "What's this?"-, "What next?"- und "How to"-Hilfe frühzeitig vermieden werden können.

Bin wieder zurück in meinem modifizierten HelloWorld-Programm. Da steht immer noch call Herrensocken.killme. Mal sehen wie schön das Programm abstürzt, wenn ich das jetzt ausführe. Andererseits: warum sollte es überhaupt abstürzen? killme habe ich zwar aufgerufen, ist aber leer – da dürfte eigentlich gar nichts passieren. Wozu lange nachdenken, einfach mal auf run klicken:

static_check_exception: Broken reference blabla...

Gut, oder besser: Mist, das hat sich jetzt nicht so verhalten, wie ich es erwartet hätte. Kopf nicht hängen lassen – das wird schon. Mal ein wenig in anderer Richtung weiter forschen:

Ich schau mir ein paar der Sample-Programm an. Dabei fällt mir auf, dass manche Programme im Declare-Block mehrere Variablen deklariert haben. Achso – jetzt verstehe ich das erst richtig! Das ist praktisch wie bei PASCAL, da hat man seine Deklarationen und irgendwo sein begin/end und in diesem begin/end (das heisst hier do und #declare;) schreibt man seinen Programmcode. Warum hat denn der Initiator nicht von Haus aus dieses declare und restliche Zeug drin stehen? Naja, vielleicht war das ja mal so, und derjenige, der das HelloWorld-Programm geschrieben hat, hat das rausgeworfen, weil's hier nicht benötigt wird?

Das schreit geradezu nach einer Untersuchung. Ich wechsle zum Fenster mit der Package-Ansicht und sage mittels Klick auf das entsprechende Symbol der Toolbar „New Initiator“, dass ich eben dieses wünsche. Ich nenne den Initiator liebevoll „Main“. Ein Doppelklick auf das erstellte Excec-Symbol zeigt mir schnell, dass meine Vermutung falsch war – auch hier ist nicht automatisch ein Declare-Block drin (nur ein <stm>. Auch egal. Was mich jetzt mehr interessiert ist, warum hat eigentlich MEIN Initiator gleich 4 Blätter (Virtual types, Inputs, Declarations und Exec) in der Package-Ansicht bekommen und der ursprüngliche Initiator Gummischuh (aeh HelloWorld) hat nur 1 Blatt (nämlich Exec)? Ah, in der Symbolleiste gibt's ein Fragezeichen in eckigen Klammern. Wenn man da den ursprünglichen Initiator aktiviert hat und darauf klickt, dann sieht man auch bei diesem die anderen 3 Blätter.

Ich spiele mal mit den restlichen Buttons in dieser Gegend herum: Da kann man Unterzweige ein-/ausblenden (hm, das könnte man doch in einem Button realisieren – wozu zwei? Naja, mir soll's recht sein). Dann kann man „leere optionals“ ein-/ausblenden (auch hier würde 1 Button reichen).

Die Knoten des Unterbaumes können ja in unterschiedlichem Zustand sein, einige so, andere andersherum. Wenn man nur einen Button zum Umschalten des ganzen Unterbaumes hätte, so könnte dieser entweder jeden Knoten einzeln von seinem jetzigen in den jeweils anderen Zustand umschalten, was ja aber nicht der Sinn des Buttons ist, oder man könnte es von dem aktuellen Zustand des selektierten Knotens abhängig machen, in welchen Zustand man den ganzen Unterbaum umschaltet: dann müsste man aber zweimal klicken, wenn der selektierte Knoten bereits in dem gewünschten Zustand ist, seine Unterknoten aber nicht. Deshalb jeweils zwei Buttons, um eindeutig ausdrücken zu können, in welchen Zustand man den ganzen Unterbaum umschalten will, unabhängig vom jetzigen Zustand des selektierten Knotens.

Ein Button heisst Utility-Window. Ob der wohl so'n Tool zum Zeichnen von Bildschirmmasken hervorzaubert? -> Nö. Ein eher langweiliges Fenster wird angezeigt. Kommentare Fehlermeldungen und Suchergebnisse werden im Utility-Fenster angeboten. Dann gibt's da noch Buttons um von Kommentar zu Kommentar zu springen (erscheint mir durchaus praktisch) und weitere Buttons um von Fehler zu Fehler zu springen. Achja. meine Variable Herrensocken benützt ja immer noch die killme-Funktion, die total leer ist. „Broken reference“ sagt die IDE zu diesem Problem. Hm. Vielleicht muss ich die stdkillme.lava erst in mein Projekt einbinden? Das mach' ich gleich mal! Zurück zum Packagefenster und Insert Include ausgewählt. So, jetzt habe ich std.lava und stdkillme.lava in meinem Projekt drin.

Ein Klick auf Run demotiviert mich etwas. Das Ding geht immer noch nicht. Gleicher Fehler wie vorhin (static_check_exception: Broken reference). Schade. Broken reference. Die IDE hat wohl nicht mitbekommen, dass meine leere killme-Funktion in dem anderen File enthalten ist. Wenn ich es genau bedenke aber eigentlich logisch. Woher soll denn die IDE nun wissen, welche von den Includes verwendet werden soll? Da muesste man vermutlich einstellen bzw. festlegen, dass ein Include vom anderen erbt – was bei mir aber sicher nicht der Fall ist, da ich ja einfach „Speichern unter“ gesagt habe, um die stdkillme.lava zu erzeugen (und die ist eine Kopie von std.lava – nix geerbtes).

Ich mache mal ein paar Aufräumungsarbeiten. Ich lösche die stdkillme.lava wieder aus dem Projekt heraus (Menüpunkt dazu habe ich keinen gefunden, aber mit der ENTFERNEN-Taste hat's problemlos geklappt). Dann entferne ich den eigenen Initiator Main und schalte die leeren optionals wieder ab. Ich bin jetzt wieder im Initiator HelloWorld wo ich den call auf killme in einen Call auf IsEqualTo?(5) ändere. Okay, ich erwarte mir nun eigentlich nicht wirklich etwas intelligentes, denn der Call wird meiner Meinung nach den aktuellen Wert von Herrensocken (nach meiner Zuweisung = 3) mit dem Wert 5 vergleichen und dann einen Boolean zurückgeben, den ich aber nicht auswerte. Run.

execution_failed: Call Stack: initiator HelloWorld, file HelloWorld.lava

Aha. Soso. Irgendwas ist jetzt faul. Ich entferne mal dieses hässliche IsEqualTo?-Ding und dann läuft das Programm wieder problemlos. Hm. Ausser dass es jetzt nach meinen Aufräumungsarbeiten wieder HelloWorld ausgibt und die Variable Herrensocken den Wert 3 hat (was ich leider nicht mal überprüfen kann), habe ich nicht viel erreicht.

Das soll für die ersten Schritte einstweilen reichen. Demnächst geht's weiter.

Erich

Lieber Erich, ich danke dir herzlich für die Arbeit, die du dir bisher schon gemacht hast. Auf einen solchen Erfahrungsbericht eines Lava-Neulings haben wir schon lange gewartet. So etwas hilft uns ungemein. Auf die Fortsetzung sind wir gespannt. Gruß, Klaus.


StartSeite | LavaFeedBack/ | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern
Text dieser Seite ändern (zuletzt geändert: 5. Juni 2004 8:51 (diff))
Suchbegriff: gesucht wird
im Titel
im Text