MGSE

DSL, Generator und Templates für eine spezielle Zielplattform

Erstellung eines (graphischen) DSL-Editors

Manuelle Erstellung einer Referenzimplementierung

Separation des modellabhängigen Codes

Extraktion der Generierungs-Templates aus dem modellabhängigen Code

Erzeugung vom Referenzmodell mit dem DSL-Editor

Ggf. Definition von Modell-zu-Modell-Transformationen

Generierung und Test

Erzeugung weiterer Modelle mit dem DSL-Editor

Generierung, ggf. Test

Modell zu Modell (m2m)

Modell zu Text/Code (m2t)

• Textual DSLs

– EBNF-Grammar

– Xtext

• Internal DSLs

– In Ruby, Groovy, Clojure or

– Scala

• Graphical DSLs

– UML Profiles, SysML, BPMN

– GMF

– Poseidon for DSLs

- Java ist schlecht

- Ruby, Scala

• Modeling used to be equivalent to Graphical modeling

• Tooling for textual and internal DSLs has surpassed

graphical DSLs in the past few years

• Graphical Tooling is catching up

– MDSD: Generate from Models

GMF

Poseidon for DSLs

- Layer M3: Grammar, BNF

- Layer M2: Programmiersprache, Java-Expression

- Layer M1: Klassen

- Layer M0: Objekte

Non Turing-Acceptable

- Turing-Acceptable

-- decidable

--- Context-sensitive

---- Context-free

----- Regular

- Regular Expressions are very simple textual languages

- For a parser it is sufficient to read left to right to recognise an instance of a grammar

- Examples are Telephone numbers, Zip codes, Email Adresses

Primitive regular expression: ∅, λ, α

Given regular expressions r_1 and r_2

Regulare Exppressions

r_1 + r_2

r_1 * r_2

r_1 *

(r_1)

A regular expressions: (a + b⋅ c)*⋅(c +∅)

Not a regular expressions (a+b+)

language of regular expression: L(r) = r

Example L((a + b⋅ c)*) = {λ,a,bc,aa,abc,bca,...}

- Einfache Erstellung textueller DSLs

- Minimierung der Entwicklungszeit und Kosten von DSLs

- Optimale Toolunterstützung für den Anwender

- Text-based DSL

- Based on an EBNF grammar: ANTLR3-based parser, EMF.based metamodel, Eclipse editor

- Rules similar to EBNF

Entity : "entity" name "{" (Feature)* "}";

Feature : type name ";";

- Creates a language that allows to say

entity Customer {

String name;

String street;

Integer age;

}

- The grammar only defindes rules: a = A
-- Variable a contains instances of Type A
-- Example: name = ID

- We want to read out instances of the grammar and use it for code generation: (a?='t')?
-- a is true if t is used
-- resetting? = 'resetting'

- For that we need variables in the grammar with Types: (a+=A)*
-- Multivalued variable
-- events+=Events

- Ein EPackage pro Grammatik
- Eine Parser Rule wird in eine EClass übsetzt
- Zuweisungen werden zu EAttributes oder EReferences
- Pro Terminal Rule einen EDataType
- Alternative wird als Vererbung abgebildet

- Sprache spezialisiert auf Codegenerierung aus Modellen
- Einfache Vermischung Text und dyn. Inhalt
- statisch typisiert

Dekomposition (hierarchische Zerlegung von Systemen in Teilsysteme) ist Gruundlage für arbeitsteilige Entwicklung und gute Wartbarkeit von software.

- Struktur der fachlichen Domäne
  jedes fachgebiet hat etablierte Zerlegung in Teilgebierte

- Struktur der technischen Plattform
  z.B. Multitier-Architektur bei Web-Anwendungen

- Struktur der Abläufe und Daten, softwaretechnische Prinzipien

- Organisation der beteiligten Entwcikler

In jeder Dekomposition dominiert ein Aspekt auf Kosten der anderen.

- Höhere Abstraktionsebene                - Konkretisierung ->
- Niedrigere Abstraktionsebene           <- Abstrahierung -

- problemorientierter (mehr Was, Modellierung)

- domänenspezifischer

- mehr generalisierend (unwichtige Details weglassen, Spezialfälle zusammenfassend)

Beispiel:

ein UML Klassendiagramm ist abstrakter als Quellcode
Quellcode ist abstrakter als das ausführende Programm

- lösungsorientierter (mehr Wie, Programmierung)

- plattformspezifischer

- detaillierter, spezialisierter

- mehr Redundanz

Beispiel:

eine Klasse ist konkreter als ein Interface

niedrigste Abstraktionsebene ist das ausführbare Programm

Beschreibungen auf höhreren Abstraktionsebenen veralten, weil in späten Projektphasen nur noch auf niedrigen Abstraktionsebenen geabrietet wird.

Redundanz bezeichnet allgemein das mehrfache Vorhandensein funktions-, inhalts- oder wesengleicher Objekte

Objekte in diesem Sinne bei der SE: z.B. Bezeichner, Klassen, Entwurfsmuster, Codessequenzen, ...

- Vertikale Redundanz

- Horizontale Redundanz

Informationen aus höheren Abstraktionsebenen sind zwangsläufig explizit oder implizit auch in den niedrigeren Abstraktionsebenen enthalten

Bsp: Klassen aus UML-Diagrammen werden explizit im Quellcoder wiederholt. Anwendungsfälle aus Usecase-Diagrammen sind implizit im Quellcode enthalten.

Informationen wiederholen sich innerhalb einer Abstraktionsebene.

Bsp: Klassen müssen programmiert und in Konfigurationsdateien eingetragen werden. Informationssysteme: für jeden Datentyp "Anlegen", "Abfragen", "Ändern", "Löschen", ...

Erhhter Entwicklungsaufwand und Inkonsistenzen durch Redundanz.

- Externe Abhängigkeiten

- Interne Abhängigkeiten

- Explizite Abhängigkeiten

- Implizite Abhängigkeiten

Software enthält Annahmen über den Kontext, in dem sie eingesetzt wird.
(Datenaufkommen, Benutzerzahlen, Benutzerverhalten, ...)

Software benötigt eine Plattform um ablaufen zu können
(Hardware, Betriebssystem, Standardsoftware, ...)

Innerhalb einer Software bauen Lösungen für Teilprobleme aufeinander auf oder sind vermischt.
Vermischung von fachlichen und technischen Aspekten, ...

programmiersprachlich formuliert und zur Compile-/Linkzeit überwacht
(Abhängigkeit zwischen Klassen durch Methodenaufrufe - Überwachung per Compiler)

Stillschweigende Annahmen, die nicht automatisch überwacht werden

(Reihenfolge von Elementen in einer Collection, ...)

Verringerte Felxibilität und Wiederverwendbarkeit durch Abhängigkeiten

Formalisierung bedeutet die Beschreibung eines Phänomens oder die Formulierung einer Theoorie in einer formalen Sprache.

In der Softwareentwicklung geht es darum, Anforderungen aus der realen Welt mit einer zu erstellenden Software zu erfüllen:

Anforderungen in natürlichen Sprachen -- Formalisierung --> Software in formaler Sprache