AsmL Abstract State Machine Language Humboldt Universität zu Berlin Institut für Informatik Seminar Systementwurf WS 05/06 Vortrag: Mike Herzog

2 ins kalte Wasser var A = [3, 10, 5, 7, 1] indices = {0, 1, 2, 3, 4} Main() step DO_SORT: until fixpoint choose i in indices, j in indices where i A(j) A(i) := A(j) A(j) := A(i) step OUTPUT: WriteLine(A) var A = [3, 10, 5, 7, 1] indices = {0, 1, 2, 3, 4} Main() step DO_SORT: until fixpoint choose i in indices, j in indices where i A(j) A(i) := A(j) A(j) := A(i) step OUTPUT: WriteLine(A)

3 ins kalte Wasser (2) class Person var age as Integer var Amy as Person(20) var Bob as Person(16) var Jim as Person(40) People = {Amy, Bob, Jim} GrowOlder() forall p in People p.age := p.age + 1 var year = 2006 class Person var age as Integer var Amy as Person(20) var Bob as Person(16) var Jim as Person(40) People = {Amy, Bob, Jim} GrowOlder() forall p in People p.age := p.age + 1 var year = 2006 Main() step while year < 2012 WriteLine(`In ` + year) WriteLine(Amy.age) WriteLine(Bob.age) WriteLine(Jim.age) GrowOlder() year := year + 1 Main() step while year < 2012 WriteLine(`In ` + year) WriteLine(Amy.age) WriteLine(Bob.age) WriteLine(Jim.age) GrowOlder() year := year + 1

4 ins kalte Wasser (3) reachable of T(root as T, arcs as Set of (T,T)) as Set of T var reachable = {root} step until fixpoint forall (l, r) in arcs if l in reachable and r notin reachable then add r to reachable step return reachable Main() arcs = {(1,2), (2,3), (4,5), (3,1), (5,6)} WriteLine(reachable(3,arcs)) reachable of T(root as T, arcs as Set of (T,T)) as Set of T var reachable = {root} step until fixpoint forall (l, r) in arcs if l in reachable and r notin reachable then add r to reachable step return reachable Main() arcs = {(1,2), (2,3), (4,5), (3,1), (5,6)} WriteLine(reachable(3,arcs))

5 Gliederung 1.Propaganda Offizielles von Microsoft 2.Einsatz Vorbereitungen In Aktion 3.Arbeitsweise Interessantes aus den Innereien 4.Referenz und Beispiele Symbole Variablen Schlüsselwörter

6 1. Propaganda Yuri Gurevich Wolfgang Grieskamp Wolfram Schulte Nikolai Tillman Margus Veanes

7 Ausführbare Spezifikationssprache basierend auf der Theorie der Abstract State Machines Aktuell Version 2 für Visual Studio.NET Nutzung von MS Word 2002 und XML-Technologie für Spezifikation Enge Zusammenarbeit mit anderen Visual Studio.NET Komponenten 1. Propaganda

8 2. Einsatz in Word XP Nutzung eines speziellen AsmL- Templates Spezielle Formatierungen für AsmL in Word anlegen... und benutzen

9

10 2. Einsatz in Word XP Kompilieren Fehler beseitigen (?) Ausgaben angucken...

11 2. Einsatz in der DOS-Box AsmL Datei kompilieren... dann ausführen

12 2. Einsatz im.NET Framework Integration in Visual Studio.NET Nutzen von Daten und Typen Aufrufen von Methoden etc. Nur leider nicht bei....

13 3. Arbeitsweise Zustände sind Belegungen von Variablen Zustandsübergänge sind Schritte, in denen sich Belegungen ändern Ein Lauf einer Maschine ist eine Folge von Zustandsübergängen

14 3. Arbeitsweise Parallelität So oft wie möglich zu verwenden Realisiert durch step Anweisung Reihenfolge der Anweisungen innerhalb eines Schrittes nicht deterministisch Updatemengen Vorrat an bei nächstem step zu aktualisierenden Variablen Konsistenz von Updates beachten

15 Gliederung 1.Propaganda Offizielles von Microsoft 2.Einsatz Vorbereitungen In Aktion 3.Arbeitsweise Interessantes aus den Innereien 4.Referenz und Beispiele Symbole Variablen Schlüsselwörter

AsmL - Referenz Wie sich das Große aus den Kleinen zusammensetzt

17 Die step Anweisung Markiert den nächsten Schritt Fasst alle Anweisungen eines Schrittes zusammen Main() initially F as File? = null initially FContents = ´´ step 1: F := Open(´MyFile.txt´) step 2: FContents := Read(F, 1) step 3: FContents := FContents + Read(F, 1) step 4: WriteLine(FContents) const myList = [1, 2, 3] Main() step foreach i in myList WriteLine(i)

18 Die step Anweisung (cont.) kennt Abbruchbedingungen für Anweisungsblöcke Main() initially x = 1 step until x > 9 x := x + 1 oder: Main() initially x = 1 step while x < 10 x := x + 1

19 Die step Anweisung (cont.) AsmL erkennt Fixpunkt-Operationen enum EnumMode Initial Started Finished Main() initially Mode = Initial initially Count = 0 step until fixpoint if Mode = Initial then Mode := Started Count := 1 if Mode = Started and Count 10 then Mode := Finished

20 Updates Variablen mit neuen Werten belegen Durch das := Symbol angezeigt Immer bei der nächsten step Anweisung Reihenfolge innerhalb eines Blocks nicht vorhersagbar Auf Konsistenz achten!

21 Updates (cont.) Udates passieren erst bei der nächsten step Anweisung: var x = 0 var y = 1 Main() step x := 5 WriteLine(`erst ist x=0: ` + x) step WriteLine(`x wurde aktualisiert` + x)

22 Updates (cont.) das Austauschen von Variablen-Werten ist ebenfalls ASM-konform: var x = 0 var y = 1 Main() step // x und y vertauschen x := y y := x step // x ist nun 1 // y ist nun 0

23 Methoden Ähnlich anderen Programmiersprachen Funktionen vs. Update-Prozeduren Unterscheidung lokaler und globaler Variablen Method Overloading ebenfalls unterstützt

24 Methoden (cont.) var Count Increment() // update Prozedur Count := Count + 1 CurentCounter() as Integer // Funktion return Count Main() step Increment() step WriteLine( currentCounter ) var Count Increment() // update Prozedur Count := Count + 1 CurentCounter() as Integer // Funktion return Count Main() step Increment() step WriteLine( currentCounter )

25 Methoden (cont.) s = {1, 8, 2, 12, 13, 6} Max ( i as Integer, j as Integer) as Integer return (if i > j then i else j) Max (s as Set of Integer) as Integer return (any m | m in s where not (exists n in s where n > m) ) Main() step WriteLine( Max(s)) WriteLine( Max(2,3)) s = {1, 8, 2, 12, 13, 6} Max ( i as Integer, j as Integer) as Integer return (if i > j then i else j) Max (s as Set of Integer) as Integer return (any m | m in s where not (exists n in s where n > m) ) Main() step WriteLine( Max(s)) WriteLine( Max(2,3))

26 Werte Normale Variablen Eingebaute Datentypen Null, Bool Byte, Short, Integer, Long, Float, Double, Char, String Seq, Set, Map Tupel Benutzerdef. Strukturen und Klassen Konstanten Optional typisiert lokal oder global

27 Werte: Strukturen structure InputEvent case KeyInput key as Char case SwitchInput toggle as Boolean case CoinReturn //no data needed HandleInput(e as InputEvent) match e KeyInput(k):WriteLine(`Key: ` + k) SwitchInput(t):WriteLine(`Switch: `+ t) CoinReturn():WriteLine(`Coin return`) Main() step 1:HandleInput(KeyInput(`a`)) step 2:HandleInput(CoinReturn()) structure InputEvent case KeyInput key as Char case SwitchInput toggle as Boolean case CoinReturn //no data needed HandleInput(e as InputEvent) match e KeyInput(k):WriteLine(`Key: ` + k) SwitchInput(t):WriteLine(`Switch: `+ t) CoinReturn():WriteLine(`Coin return`) Main() step 1:HandleInput(KeyInput(`a`)) step 2:HandleInput(CoinReturn())

28 Werte: Klassen Enthalten (Daten-) Felder Ermöglichen Referenzen Ableitungen wie OO class Person var name as String var age as Integer p1 = new Person(`Anne`, 37) p2 = new Person(`Kurt`, 12) Writeline(p1.name)

29 Werte: Klassen (cont.) class BasicBox var length as Double var width as Double var heigth as Double Volume() as Double return (length * width * heigth) class FragileBox extends BasicBox Volume() as Double return (0.85 * length * width * heigth) basicBox1 = new BasicBox(1.0, 1.0, 2.0) WriteLine(basicBox1.Volume()) class BasicBox var length as Double var width as Double var heigth as Double Volume() as Double return (length * width * heigth) class FragileBox extends BasicBox Volume() as Double return (0.85 * length * width * heigth) basicBox1 = new BasicBox(1.0, 1.0, 2.0) WriteLine(basicBox1.Volume())

30 Werte: Mengen A = {1, 3,5,7, 11} B = {1..20} C = {i | i in B where 2 * i in B} E = (L union F) I = (L intersect F) n = size(L) A = {1, 3,5,7, 11} B = {1..20} C = {i | i in B where 2 * i in B} E = (L union F) I = (L intersect F) n = size(L) Definition durch Aufzählung Wertebereich arithmetischen Ausdruck Operationen Vereinigung, Durchschnitt, Mächtigkeit,... Relationen Teilmenge, Element,...

31 Werte: Listen leer = [] l = [1, 2, 4, 4, 2] Main() step WriteLine(l(1)) // gibt 2 aus, da Listen null-basiert sind leer = [] l = [1, 2, 4, 4, 2] Main() step WriteLine(l(1)) // gibt 2 aus, da Listen null-basiert sind Wie Mengen: nur Elemente gleichen Typs zulässig Anders als Mengen: Reihenfolge wird beachtet Elemente können mehrfach vorkommen

32 Werte: Maps var phoneNumber as Map of String to Integer phoneNumber = {`Bob`-> 100, `Carla`-> 102} WriteLine(`Carlas number is ` + phoneNumber(`Carla`)) var phoneNumber as Map of String to Integer phoneNumber = {`Bob`-> 100, `Carla`-> 102} WriteLine(`Carlas number is ` + phoneNumber(`Carla`)) Abbildungen von Schlüsseln auf Werte Definition durch: Explizite Einträge Arithmetische Ausdrücke Operationen Indizes, Werte Vereinigung

33 Werte: Maps (cont.) var phoneNumber as Map of String to Integer = {`Bob` -> 100, `Carla` -> 101, `Jim` -> 102, `Denni` -> 103 } Main() step y = {j | i -> j in phoneNumber where j < 103} WriteLine(y) var phoneNumber as Map of String to Integer = {`Bob` -> 100, `Carla` -> 101, `Jim` -> 102, `Denni` -> 103 } Main() step y = {j | i -> j in phoneNumber where j < 103} WriteLine(y)

34 Werte: Arrays Nutzung von Mengen, Listen und Abbildungen statt Arrays Iteration mit step foreach step forall Adressierung eines bestimmten Eintrags c = [r, b, g] WriteLine(c(0)) Auswahl eines beliebigen Eintrags choose x in {`ja`, `nein`, `vielleicht`}

35 Werte: Aufzählungstypen enum Farben Rot Gelb Grün Blau var f as Farben = Rot WriteLine(f) // gibt Rot aus enum Farben Rot Gelb Grün Blau var f as Farben = Rot WriteLine(f) // gibt Rot aus Symbolische konstanten wie beispielsweise in C++ Initialisierungen automatisch, partiell oder total möglich

36 Exkurs: Datentypen f. F. Einfache Datentypen String, Integer, Boolean, Null,... var v0 as Integer var v1 as (Integer, Integer, String) Options-Typen var v2 as Integer or String var v3 as String or Null var v3 as String? var v4 as (Integer?, Set of String)?

37 Exkurs: Datentypen f. F. (cont.) SomeFunction(x as Integer or String) as String if x is Integer then return `Found Integer.` else return `Found String.` Main() step 1:WriteLine(SomeFunction(2)) step 2:WriteLine(SomeFunction(`abc`) step 3:WriteLine(SomeFunction(3.0) SomeFunction(x as Integer or String) as String if x is Integer then return `Found Integer.` else return `Found String.` Main() step 1:WriteLine(SomeFunction(2)) step 2:WriteLine(SomeFunction(`abc`) step 3:WriteLine(SomeFunction(3.0)

38 Auswahl Ausdrücke Main() let S = {1, 2, 3, 4, 5} let T = {-1, 2, 5, 7} step let u1 = (any i | i in S where i < 4) let u2 = (the i | i in S where i < 1) let u3 = (sum i | i in S) step let v1 = (max x + y | y in S, y in T) let v2 = (the value | value in T where value notin S) let v3 = (min x | x in S union T) Main() let S = {1, 2, 3, 4, 5} let T = {-1, 2, 5, 7} step let u1 = (any i | i in S where i < 4) let u2 = (the i | i in S where i < 1) let u3 = (sum i | i in S) step let v1 = (max x + y | y in S, y in T) let v2 = (the value | value in T where value notin S) let v3 = (min x | x in S union T)

39 Quantoren S = {1, 2, 3, 4, 5, 6} //... Main() v1 = forall i in S holds odd(i) v3 = forall i in S where i > 4 holds odd(i) v2 = forall i in S, j in S holds i mod j < 6 v2 = exists i in S where i > 4 v4 = forall i in S holds exists j in S where i < j v5 = exists i in S where exists j in S where i < j v6 = exists i in S, j in S where i + 1 = j S = {1, 2, 3, 4, 5, 6} //... Main() v1 = forall i in S holds odd(i) v3 = forall i in S where i > 4 holds odd(i) v2 = forall i in S, j in S holds i mod j < 6 v2 = exists i in S where i > 4 v4 = forall i in S holds exists j in S where i < j v5 = exists i in S where exists j in S where i < j v6 = exists i in S, j in S where i + 1 = j

40 Zusicherungen Incr(x as Integer) as Integer require x >= 0 ensure result = x + 1 return ((((x + 1) * 2) - 2) / 2) + 1 Main() step WriteLine(Incr(1)) step WriteLine(Incr(99)) Incr(x as Integer) as Integer require x >= 0 ensure result = x + 1 return ((((x + 1) * 2) - 2) / 2) + 1 Main() step WriteLine(Incr(1)) step WriteLine(Incr(99))

41 Die Explore-Anweisung Finden verschiedener Möglichkeinten bei deterministischen Fkt. nur eine sonst entspr. mehrere Choose() as (Integer, Integer) x = any i | i in {1..3} y = any i | i in {2..x} return (x,y) Main() WriteLine(explore Choose()) WriteLine(search Choose()) Choose() as (Integer, Integer) x = any i | i in {1..3} y = any i | i in {2..x} return (x,y) Main() WriteLine(explore Choose()) WriteLine(search Choose())

42 Auswahl der Schlüsselwörter addandanyascasecatchchoose classelseelseifensureenum enumerated error existsexploreextendsfixpointforallforeachholds ififnone implements impliesimportininitially interface intersect isletmatchmaxmerge minmod namespace newnotnotinof operatororremoverequire resulting returnsearch skipstepstructuresumthethenthrow trytypeunionuntilvarwherewhile ->..:= +=( )[ ]{ }| + - * /< (lt)> (gt)= (eq)<= (le)>= (ge)<> (ne)

43 AsmL Informationen bei Microsoft Folien zum Vortrag unter

44