Wir setzen fort mit einer weiteren Entscheidung, wie ich eine Sprache implementiere.
Und zwar hatten wir bei der Implementierung oder bei der Entscheidung hier die Entscheidung,
ob wir grafisch oder textuell diese Sprache ausdrücken wollen.
Vielleicht denken die meisten bei Modellierungen an etwas Grafisches.
Bei Sprache denken die meisten an etwas Textuelles,
in der Möglichkeit kann es beides sein.
Das Entscheidende ist, was ist in der Anwendungsdomäne akzeptabel,
womit können die intendierten Nutzer dieser Sprache,
Anwender dieser Sprache
gut arbeiten
Diese Gegenüberstellung habe ich jetzt so ein bisschen tabellarisch hier aufgebaut.
Links haben wir das grafische Recht, das Textuelle.
Lassen Sie uns mit grafisch beginnen. Grafisch ist auf jeden
Fall gut für Kommunikation. Sie kennen alle diesen Spruch,
ein Bild sagt mir als tausend Worte.
Ja, es ist gut für durch Diskussionsgrundlage,
es ist gut um Strukturen zu veranschaulichen, Bezüge darzustellen.
Schon die Anordnung hilft uns, viele Sachen zu verstehen.
Etwas wird oben, unten, rechts, links dargestellt,
die Vorzugsleserichtung hilft uns dabei
Allerdings, wir haben nur zwei Dimensionen. Das begrenzt und
wir haben nur die begrenzte Möglichkeit, etwas darzustellen.
Also ein Bildschirm, selbst wenn er sehr groß ist oder
sie nehmen zwei, hat trotzdem eine sehr begrenzte Informationsmenge.
Selbst wenn sie das auf eine Wand projizieren,
so ein A-Null-Plakat, was in vielen Projekträumen, Projektbüros hängt,
ist dadurch ziemlich begrenzt und wir können nicht so viel darstellen.
Wenn wir uns dann reinzoomen, rauszoomen,
verliert das Ganze schon wieder. Das ist etwas,
wo wir hier grenzen sehen
Und wir sollten auf jeden Fall Werkzeuge haben,
wenn wir das nur mit Papier und Stift machen,
dann sind Änderungen sehr schnell nicht mehr möglich.
Auch wer sinnvoller oder kaum möglich, Sichten darzustellen,
wenn wir oder Einblenden ausblenden, Abstraktionslevel-Sachen zusammenzufassen,
Hierarchien bilden, indem wir Dinge zusammenfassen.
Das wäre alles erst möglich, wenn wir Werkzeuge benutzen,
die diese Sprache, diese grafische, dextuelle, grafische DSL unterstützen.
Und das macht natürlich das Ganze aufwendig. Ja,
also die Werkzeugunterstützung ist unabdingbar, die muss sich für eine solche Sprache erst entwickeln.
Wir hatten kurz vorher gesagt, bei der internen DSL kann
ich auf die Mittel und aufbauen, die es schon gibt.
Bei einer externen muss ich das Neue entwickeln.
Das wäre also hier ein relativ hoher Aufwand.
Okay, demgegenüber Textuelle, Informationen darstellen. Ganz klar,
ich brauche auch Werkzeuge, aber die sind relativ einfach und vielmals schon vorhanden.
Gerade ein Textidutor ist doch ganz einfach, das ist fast ein Standardwerkzeug.
Wenn ich natürlich noch ein bisschen was mehr möchte,
Syntax-Highlighting, Autocomplete, Prüfungen oder so etwas,
dann brauche ich ein bisschen mehr,
aber auch das ist relativ einfach
Relativ einfache Bearbeitung im Team ist möglich. Gemeint ist damit,
dass Merch, indem man das aussplittet, Merch dafür gibt es erfahren,
erprobte Technologien bei grafischen Darstellungen ist das noch nicht so weit.
Dann können wir sagen, ja, Versionierung ist auch
ganz einfach, indem ich einfach ein DIF bilde.
Wo sind Zeichen hinzugekommen, wo ist es in Fehlenzeichen bis
zur Formatierung hin, das ist alles gar kein Problem.
Auch dafür gibt es Standardwerkzeuge, deswegen ist das auch
relativ einfach
Ich brauche aber doch in vielen Fällen eine Visualisierung zusätzlich,
ja, indem ich zum Beispiel etwas aufklappe oder indem ich einen Überblick darstelle,
nehme ich Strukturen darstelle, Flüsse, darstelle,
Bezüge darstelle,
eben um genau dieses Verstehen auch zu unterstützen.
Dafür brauche ich auch Werkzeuge, auch wenn es die einfachen
Editor und selbst Merch-Werkzeuge schon gibt.
Lassen Sie uns das anhand eines Beispiels mal darstellen.
Ich habe hier eine DSL mal mitgebracht,
für die es eine textuelle und eine grafische Repräsentation gibt
Ich habe hier dieses Molekül, müssen Sie nicht kennen, die Chemiker kennen es.
Und zwar ist das das Pelezilin-Molekül und wir möchten,
ich habe es eigentlich nur deswegen mitgebracht,
um mal was aus einem ganz anderen Gebiet zu haben.
Ja, wir sehen, also die meisten von Ihnen haben schon,
auf jeden Fall erinnern sich an Ihr Chemieunterricht, dann haben Sie,
kennen Sie auf jeden Fall die Symbole der Atome und so ein Sechseck für einen Kohlenstoffring,
haben Sie vielleicht auch schon mal irgendwo gesehen und können sich vorstellen,
dass das für irgendwo etwas steht.
Ja, so und Was wir hier sehen als Beschreibung,
ist die Beschreibung, was hier passiert.
Ja, also wir haben hier Bindungen,
Double Bond mit bestimmten Winkeln, Backbond, Frontbond.
Es gibt hier Bezeichnungen. Und diese Bezeichnungen stehen jetzt für
links von dem N, ist hier ein C. Ja,
und nach oben geht es in ein doppelte Bindung zum O,
das ist jetzt hier.
Und dann kann ich hier noch das CH2 anbinden.
Und dann gibt es ein Bäcker, den Zohlen-Benzinring hier.
Ja, so und den kann ich, dass diese Strukturen,
kann ich hier unten, ist sie auch nochmal dargestellt für das andere.
Ich gehe das nicht im Einzelnen durch. Ich wollte die
nur zeigen damit, es gibt sowohl hier eine grafische Darstellung
als auch eine textuelle und jetzt zu den Vor- und Nachteilen.
Natürlich ist das hier schlechter zu verstehen. Das versteht der
Chemiker relativ schnell, hoffentlich entdeckt der Chemiker auch gleich,
dass er das Penicillin ja vielleicht schon mal irgendwo gesehen hat.
Aber unabhängig davon, das Bild sagt natürlich mehr.
Aber wenn wir eine sehr große Struktur haben, Dann wird es,
könnte es sein, dass das nicht mehr auf unserem Bildschirm passt.
Also sie haben auch vielleicht schon sehr große Moleküle mal gesehen,
dann ist das, das stellt man dann nur noch in Übersicht dar.
Und man würde das nicht mehr so grafisch veranschaulichen,
aber in einer Textdarstellung kann ich das immer noch beherrschen.
Ich kann es immer noch editieren, ich kann darin Strukturen suchen.
Ich möchte das Beispiel auch noch gleich für was anderes nehmen,
indem ich mich mal zurückschlage und diese Frage 2 damit angehe.
In der Frage 2 ging es darum,
Welche Rolle Modelle bei der Entwicklung einer DSL spielen?
Ich habe hier in dieser Sprache auch ein Modell dahinter,
nämlich das Modell der Bindungen. Und ich würde mal vermuten,
das könnte, also ich bin ja kein Chemiker und kenne mich da nur so ein bisschen,
weiß nur das, was man aus der Schule weiß.
Ich habe, erinnere mich an so einfache Atommodelle mit den Bindungen,
über Elektronen, ich weiß jetzt nicht, wie das jetzt heißt,
ist das das Ratherfortschirm-Atommodell?
Vielleicht weiß das jemand von ihnen,
aber auf jeden Fall, es ist ein Modell der Atome
mit ihren Bindungen drin
Und dieses, dieses Modell stiehlt hier dahinter,
gleichzeitig die Symbolik stammt aus dem Periodensystem der Elemente,
die Symbolik der Bindungen beschreibt das, was in dem Modell halt drin ist.
Und dieses Modell muss sich erstmal entwickeln und das wäre jetzt in dem Entwicklung unserer DSL-Vorgehens,
wir gehen hier ein Stück zurück, das wäre das,
ich muss erstmal entwickeln, okay, was sind denn die Konzepte?
Ja, es gibt diese Atome,
es gibt die Bindungen und was kommt da drin alles vor?
Es gibt auf jeden Fall mindestens eine Bindung,
es gibt auch Teile, die können sein,
können nicht sein und das entwickeln, das ist das in etwa,
ich packe ich dann in ein Modell.
Und ihr entwickelt daraus eines Syntax. Nicht nur,
wir haben jetzt gerade nicht nur die abstrakte Syntax gesehen.
Es gibt diese Atome und Modeküle, sondern auch gleich noch,
dass wir eine konkrete Syntax haben, nämlich eine konkrete grafische und eine konkrete textuelle Syntax.
Ja, zurück zu unserem Beispiel. Ja, also,
dass wir dieses Backbond und Double Bond haben und Frontbond für Beziehungen,
die hier grafisch dargestellt sind,
für diese Beziehungen,
diese Ausdrucksmittel,
das wäre eine konkrete Syntax
Dass das Ganze dieses Wissen, was dahinter steckt,
was hier, wie man das hier darstellen will.
Zum Beispiel, dass es so eine Ringstruktur überhaupt gibt.
Oder vielleicht gibt es noch, dass es die Doppelhelix gibt,
dass es so dreidimensionale Darstellungen irgendwie machen kann.
Das ist das Wissen, was wir am Ende in ein Modell packen.
Soweit mit diesem Beispiel und zur Frage zwei,
wir kommen jetzt dazu, ein Werkzeug kurz zu besprechen.
In der Übung haben Sie vielleicht Gelegenheit, das nochmal anzuschauen.
Ich möchte das Werkzeug X-Text hier mal ins Spiel bringen.
X-Text ist ein schon relativ lange, bekanntes Werkzeug.
Es ist ein hervorgegangen aus einem Open-Architecture-Wehr, genannten Projekt.
Und ist da ist mittelbar auch Bestandteil von Eclipse,
nämlich in Clips gibt es ein Graphical-Modelling-Technology, genanntes Framework.
So, ich habe die Möglichkeit, eine Sprache zu beschreiben.
Das hatten wir schon beim Meta-Modell genannt, Syntax und Semantik brauchen wir.
Und wir haben jetzt diese Bacos Nower vorm BNF erweitert,
EBNF, die hier die Basis darstellt.
Also ich kann mit dieser Grammatikbeschreibungssprache BNF jeden Fall ein bisschen erweitert,
aber damit kann ich beschreiben, was die DSL denn macht.
Und daraus generieren wir später einen Paser, Pasers,
das Werkzeug zum Programmschmiersprache durchgehen, zum Erkennen der Sprachelemente.
Das wird später uns den abstrakten Syntaxbaum erzeugen.
Wir erzeugen daraus ein Meta-Modell, dass diese Pakus-Norro-Form repräsentiert und
damit auch die Typen enthält
Und wir haben sogar die Möglichkeit, deswegen ist das X-Text auch sehr mächtig.
Wir haben daraus Möglichkeiten, gleich ein Texteditor,
der in das Eclipse passt, also in diese Fensterform und so weiter,
da zu entwickeln, der auch aus der Sprachbeschreibung gebaut wird.
Und dieser Text, die Tür ist nicht nur ein einfacher Editor,
sondern ich habe hier Syntax-Highlighting, Code Completion,
ich habe sogar die Validierung entsprechend der Kunsttrainings der Sprache,
ich kann Codefooding und Outline-View machen,
das sieht also ganz genauso aus wie eine Sprache,
wie sie Sprachentwicklung,
Programmierung in Eclipse kennen
Dieses Werkzeug ist nicht komplett From is Crage gebaut, nein
, es nutzt andere Werkzeuge. Es gibt ein Paser-Generator,
Handler, wir hatten vorhin Jak genannt,
ich gehe nochmal hier zurück zu diesen DLL-Beispiels, ja,
also Jak ist auch ein Paser-Generator und hier haben wir jetzt
also Ahndler als ganz mächtiges Werkzeug und wir können Modelle auch tatsächlich bearbeiten mit Expand.
Ich habe hier in den Kasten mal geschrieben,
dass wir was ist jetzt eigentlich hier die Modellebene?
Was machen wir eigentlich? Und wenn wir jetzt sagen,
wir beschreiben jetzt ein Meta-Modell, ja, was ist das dann?
Wir generieren eine Grammatik. Dann ist das, kann das
die M2 sein? Es kann aber auch seit etwas sein,
wenn wir etwas generieren daraus, es ist konkreter,
es kann auch im einen sein, es hängt ein bisschen ab,
was sie selbst für ein Standwort entwickelt,
den Sprachentwickler oder den,
der dann mit der Sprache arbeitet
Ich hatte hier AST genannt, Abstrakt-Syntax-Trieb,
der nächste Folie ist dem gewidmet für diejenigen von Interindi,
das nicht oder nicht mehr wissen, nochmal,
was war das?
Abstrakt-Syntax-Trieb ist eine Baumstruktur, die die grammatikalische Struktur,
die Syntax eines Ausdrucks wiedergibt. Hier oben ein Beispiel,
haben wir etwas, was so eine Pascal-Vortrang- ähnliche Sprache sein könnte.
Und was wir hier sehen, es gibt in dieser Sprache,
gibt es einen Deklarationsteil und einen Anweisungsteil und das spiegelt sich dann hier unten wieder.
Ja, also das Ganze ist offensichtlich
ein Block
Weil es mit Ende und Semikol und endet und der hat ein Deklarationsteil,
vielleicht hier durch Declarations und ein Anweisungsteil durch Statements dargestellt wird.
Ja, also erstmal zwei Teile, die sind vermutlich hier an dem Beginn geteilt.
Wir sehen jetzt hier auf diesem Beispiel keine Grammatikbeschreibung dazu,
die würde uns, ich würde uns hier noch fehlen,
die Südaxbeschreibung, wir sehen nur, wie ist das ineinander überführt.
Ja, und in dem Deklarationsteil gibt es zwei Dinge,
also hier eine Sequenz, da Teil 1 und der Teil 2,
der Teil 1 ist diese Zeile hier,
eine Typdeklaration würden wir jetzt erraten, ohne die Sprache ganz genau zu kennen,
und zwar eine Typdeklaration für Tee, die Intager ist,
Type Declaration mit einem Edentifier Tee und der Type,
den dazugewiesen wird, ist Intecher.
Das Gleiche können wir auf der rechten Seite verfolgen, ach ne,
hier hören wir noch das zweite, nämlich das V wird dem,
wir nehmen Tee dann zugewiesen, also dem, sorry,
das Tee wird dem V überwiesen, den gerade generierten Typ hier,
wird der Variablen V zugewiesen, das ist eine Variablendeklaration,
V und mit dem wird zugewiesen der Typ Tee.
Okay, hier drüben nur eine einzige Anweisung,
die ist nicht mal sinnvoll, aber hier gibt es eine Zuweisung,
Asignment, das ist die Zuweisung und da addiere ich etwas,
aber ich addiere hier zwei Konstanten, zwei Literale, ja,
das ist nicht ein literal und noch ein literal und die werden addiert und auf der linken Seite,
Left-Hand-Seite, was bestimmt heißen, haben wir halt eine Variable.
Gut, das soll ja nur als Beispiel dienen,
damit sie wissen, was ein abstrakter Syntaxbaum ist.
Sie sehen hier, ist kein Platz für irgendwelche Kommentare,
es ist kein Platz für Steuerzeichen, es ist der Kern des sprachlichen Ausdrucks bezogen auf die Syntax. Ich kann hier auch noch semantische Bezüge darstellen,
das sind die Pfeile hier, zum Beispiel,
dass das V hier drin sich auf die Variablendeklaration bezieht,
das wäre die Semantik der Programmiersprache,
also dieses V bezieht sich auf dieses und der Typ hier bezieht sich auf den vorher deklarierten Typ,
das Tee, auf das Tee, ja,
und hier können wir noch sagen, die Literale,
weil die hier in dem gleichen Zusammenhang mit V stehen,
beziehen sich auch auf die Typdeklaration Tee, ja,
weil das kann man hier aus auch noch ableiten,
das ist auch etwas, was der Parser,
nennt der Parser nicht,
aber der Compiler dann prüfen würde.
So, wenn wir als Beispiel ein Implementierung für einen abstrakten Syntaxstrie machen,
dann könnte das zum Beispiel dadurch aufgerufen werden,
das interpretiere und dann kommt ein Ausdruck rein und dann könnte man hier solche Operationen haben,
die etwas machen, linke Operant, rechter Operant.
Und dann gibt es von der Operation, kann ich noch ableiten,
die Addition, das ist also eine abstrakte Klasse.
Hier könnte ich eine konkrete Klasse ableiten, Addition und die macht dann
interpretiere rechter Operant, linke Operant und gibt das zurück.
Das wäre dann die Implement, schon eine Implementation als eine Java-Klasse.
Das gleiche Multiplikation, rechtsmal links. Nur als Beispiel,
wie könnte ich etwas implementieren, wie könnte ich so etwas realisieren, als Sprachelement.
Okay, als Beispiel, wie das Ganze, wie das Syntaxbaum aussehen kann.
Wir hatten schon in der vergangenen Veranstaltung im vergangenen Kapitel das Playbegriff E-Core verwendet.
Das war das Meta-Modell, was wir im Eneclipse mit Modelling Framework haben.
Und hier ist mal dargestellt, wie dieser Ausdruck,
den wir eben formuliert haben, denn in diesem E-Core als E-Core-Ausdruck aussehen würde,
ja, wir haben den Ausdruck, die Operation
Mit linker Operant und rechter Operant, Multiplikation als Ableitung von Operationen,
Additionen als Abbauableitung von Operationen, zahlliteral als Ableitung von Ausdruck.
So würde das hier aussehen, ich kann das aufklappen,
kann das zuklappen, man sieht aus wie eine Programmiersprache,
aber es ist doch ein Modell,
nämlich in dem Fall auf Basis von diesem ICO-Ausdruck für ASTs,
was wir gerade implementiert hatten,
wer würde die Implementierung hier so aussehen.
Soweit zu dem Beispiel und wir haben hier vorne
eine Frage dazu
Ach so, das hat mir Vor- und Nachteile,
der DSL hatten wir schon bei der entsprechenden Folien behandelt.
Und wir haben dann noch eine Frage zu,
was ist, wann ist eine Sprache gut?
Das ist ja letztlich hiermit gemeint. Das werden wir
gleich nochmal besprechen. Wir gehen erstmal weiter mit damit,
wie ich eine grafische Modellierungssprache dominspezifische Sprache darstellen kann.
Als Beispiel möchte ich Ihnen ja angeben, auch etwas,
was auf Eclipse basiert, das Graphical Modelling Framework, EMF,
könnte ich darstellen, das blasiert auf dem EMF, Eclipse Modelling Framework,
wir im vergangenen Kapitel dargestellt hatten als Beispiel für die Implementierung,
wo ich ein Meta-Modell damit bauen kann.
Und ich nenne mehr oder weniger hier nur die Begriffe,
damit sie weitersuchen können, wenn sie das wollen.
Also es gibt hier ein Editor dafür, Graphical Editor, Editing Framework.
Damit kann ich tatsächlich etwas generieren, nämlich grafische Editoren.
Ich muss den Editor nicht komplett selbst bauen, sondern ich definiere die Sprache.
Auf der Basis des Eclipse-Modelling Frameworks beschreibe ich das Meta-Modell
und damit kann ich die grafische und natürlich,
da muss ich natürlich die einzelnen grafischen Elemente auch Aber dann habe ich gleich den Igitor fertig.
Der Editor wird mir erzeugt. Und den kann ich dann benutzen,
um auf dessen Basis dann das Verhalten, was ich dazu brauche,
für die Übersetzung auch noch zu implementieren.
Dieses Bild zeigt mal so ein bisschen diese M1, M2, M3-Ebenen.
Ja, wie hängen denn das zusammen? Also wir haben
das Meta-Modell unserer DSL. Das könnt ihr in Igor formuliert sein,
damit wir für dieses Beispiel jetzt,
und der GMF-Generator generiert dann etwas,
was dann wirklich als benutzbar ist,
um dieser Sprache zu arbeiten
Ich kann durchaus auch um die Implementierung so einer Sprache zu machen,
kann ich tatsächlich auch Editoren von anderen oder andere Werkzeuge als Editor sozusagen missbrauchen.
Ich könnte zum Beispiel ein Mahlwerkzeug, was Vorlagen zulässt,
wie zum Beispiel Microsoft Visio, könnte ich missbrauchen, um eine grafische DSL zu implementieren.
Warum kann ich nicht? Es gibt verschiedene Zeichengrafiksetsvorlagen,
Vorlagen grafischer Elemente und ich kann diese grafischen Elemente als Blog oder als Sammlung laden in das Visio,
wenn ich eigene Typen vergeben habe und diese Typisierung auch in einem Meta-Modell hinterlegt habe,
kann ich sagen, okay,
der Kasten mit dem abgeschreckten Ecke bedeutet das,
Kasten mit abgerundeten Ecken bedeutet das, ein Kasten mit 3D bedeutet das.
Und da kann ich Typen definieren. Und für diese Typen
muss ich dann im Meta-Modell etwas hinterlegen, muss natürlich sagen,
was passiert da, wie soll das gespeichert werden.
Und das könnte ich dann mittels dieser vorfestgeregten Speicherung auch tatsächlich
als XML exportieren und könnte über dieses XML das woanders importieren,
was wieder etwas damit macht, entweder was daraus implementieren,
etwas ausführen, etwas prüfen, was auch immer.
Kopplung mit anderen Werkzeugen via XML ist ja eine etablierte Technik
Als weiteres fremdendes Werkzeug möchte ich Ihnen Pure Variance nennen. Pure Variance ist ein Werkzeug, mit dem man Feature-Modellierungen macht. Feature-Modelle ist etwas für Software-Produktlinien,
wo ich sage, das gehört immer dazu,
in jeder Ausprägung, also jedes Auto hat einen Motor,
aber nicht jedes Auto hat eine Sitzheizung,
kann ich angeben, okay, Motor ist ein Mandatory,
also ein Werkzeug, ein Teil,
was immer dabei ist und lädt das jetzt Heizung ist,
Optional, das ist nicht immer dabei, das kann ich konfigurieren,
ja, und es ist ein Werkzeug,
was man zu viel Konfigurationen benutzt,
dieses Pure Variance
Und ich kann damit ja eine Sprache zusammen konfigurieren.
Die Elemente brauche ich, die Elemente brauche ich vielleicht nicht.
Und damit ist der sprachliche Ausdruck, die DSL,
am Ende eine Konfigurationsergebnis. Bestimmte Sachen nehme ich dazu,
bestimmte Sachen nehme ich nicht dazu, manches darf sich wiederholen.
Damit kann ich mir eine Sprache zusammenbauen. So,
dazu brauche ich natürlich auch nicht die Typen,
muss ich natürlich ablegen, hier in dem Fall als Features.
Damit habe ich die syntaktischen Elemente, die ich habe.
Und ich muss sagen, was ist wann erlaubt,
was bedeutet bedingt einander?
Und das wäre die Semantik
Und damit kann ich die Sprache konfigurieren. Auch hier gibt
es einen Export von XML. Und damit könnte ich
auch dieses Werkzeug als Edito für eine DSL missbrauchen.
Syntax-Highlighting und solche Sachen gibt es da natürlich nicht,
weil das nur für die Features vorgesehen ist. Und als weiteres Beispiel,
und damit nehmen wir uns schon so langsam im Schluss,
möchte ich Ihnen vorstellen, dass es Werkzeuge gibt,
mit denen ich auch grafische DSLs darstellen möchte, darstellen kann.
Als Beispiel möchte ich hier das Meta-Edit Plus nennen,
mit der NL Plus ist es ein Werkzeug,
wo man was damit wirbt,
dass man damit jede grafische Sprache darstellen kann.
Und zwar für Modellierung,
Dokumentation, Koderzeugung
Sie haben natürlich eine Kernidee von dem Meta-Modell drin,
das Meta-Modell selbst, müssen sie frei konfigurieren können,
weil sie wollen ja ihre Sprache bauen,
aber eine Kernidee haben sie und die Kernidee ist,
dass es so eine, dass es Elemente gibt,
Graphen mit Objekten, Eigenschaften, Ports, Role und Relationship.
Herr Graf steht für die visuelle Darstellung, Object ist das Hauptelement,
das grafische Element, was sich dann halt irgendwie zusammenbauen kann,
was halt in Property und einen Port hat,
wie das zusammenhängt, Object ist,
das wird dann nochmal erweitert durch diesen Port,
Ich kann da durch diesen Beziehungen,
kann ich Rollen zuweisen und explizit auch Namen und Typen für diese Beziehung vorgeben.
Und damit kann ich so Knoten und Kanten,
diese üblichen grafischen Elemente, kann ich alle ganz gut darstellen.
Es gibt hier in diesem Werkzeug eine Skriptsprache,
um die lexikalischen Ausdrücke zu beschreiben, um das zu verarbeiten.
Ich kann einen Generator editieren lassen,
diesen Generator editieren damit, um das grafische Element in lauffähigen
Quellcode umzusetzen
Ja, das kommt, das Finnland, das ganze Ding,
hat eine Zeit lang furchtbar viel Geld gekostet.
Ich glaube, im Moment gibt es eine akademische Lizenz.
In diesem Jahr habe ich es nicht nachgeschaut. So,
ich möchte mit den letzten Bildern nochmal darstellen,
wo wir hier das Modell sehen und worauf es uns ankommt.
Wenn wir jetzt mal ein Beispiel nehmen und damit komme ich
zu diesem Punkt, wann ist denn ein Modell gut?
Ich hatte bei den Eigenschaften ganz vorn gesagt,
diese Sprache soll in gewisser Weise
mächtig sein
So die DSL mächtig im Sinne von, sie sollen,
ich möchte mit wenigen Elementen, aber treffe genau das ausdrücken, was ich brauche in dem Anwendungsgebiet.
Und wenn wir jetzt mal hier was haben für ein Beispiel,
wo es um Arbeitsvorgänge mit dem Computer geht, ja,
dann wäre das zum Beispiel so, dass wir hier etwas darstellen wollen,
ein Softwaresystem und eine Personenrolle, ja, eine Tätigkeit,
die etwas tut und dazu wären zum Beispiel,
hört sowas wie Verarbeitungsprozess,
der hat einen Namen und der wäre automatisch semi-automatisch manuell,
Und wir haben ein Softwarewerk, ein Softwarewerkzeug,
was das machen kann, hat auch einen Namen.
Und der Prozess erfordert ein Werkzeug, null bis viele.
Das wäre erst mal so auf der Meta-Modelle-Ebene. Und wir
können dazu eine Invariante diskutieren und die uns die Semantik ausdrückt.
Und da können wir eine Prüfung machen. Zum Beispiel,
dass wir sagen, ja, SAP R3 gehört zu einem Passt,
zu einem Rechner unterstützten Prozess,
eine Rechnung vorzubereiten,
dann passt das erst mal hier dazu
Der Prozess erfordert eine Surftware, null bis eine Jahr,
hier ist es genau eine, nämlich diese, die hier erfordert wird.
Steht hier drunter gültig, ja, weil sie diese Invariante beschreibt,
nämlich für die Software, ist der Typ anders als manuell.
Wenn das ein Typ ist, nehmen wir mal an,
das wäre der Typ automatisch. Ja, so,
wenn wir das Ganze hier für ein Manuelle, für eine manuelle Operation schreiben,
würde dieser trifft das hier oben auch zu. Ja,
also wir haben hier ein Prozess und wir haben eine Software,
aber das ist der Typ manuell vielleicht dargestellt,
dass die Menschen hier, dann trifft das nicht zu.
Also nur um zu sagen, ich kann mit solchen Dingen
etwas beschreiben und ich sollte das so sein,
dass es möglichst mächtig ist. Voraussetzung ist natürlich,
dass der Entwickler dieser Sprache oder jetzt auf Abläufe hier damit umgehen kann,
dass es in der Lage ist, seine Inhalte, zum Beispiel als dieses,
das sieht ja hier so eine Art wie OCL aus,
das so darstellen zu können.
Wenn das ein bisschen umfangreicher ist,
müssen wir versuchen mit dem Meta-Modell möglichst effizient zu arbeiten.
Deswegen können wir das auch so machen,
dass wir zum Beispiel hier mit Ableitungen arbeiten und die Beziehungen,
dann hier ist es eine Darstellung,
wo wir OCL nicht verwendet haben und das Gleiche,
den gleichen Ausdruck auch haben.
Soweit zu schlank und jetzt möchte ich kurz noch mit Ihnen zusammenstellen,
eine Antwort auf die Frage,
wann ist denn
eine DSL gut
Die Qualität von Softwaresystemen teste ich, indem ich sie mit den Anforderungen vergleiche.
Ich teste zum Beispiel ein Use Case für den Use Case
aus, kommt das erwartete Verhalten aus.
Ich vergleiche das tatsächlich verwalten, mit dem erwarteten Verhalten.
Bei der Softwareentwicklung sind es also Tests. Und da könnte
man sagen, ist okay oder wir haben Fehler gefunden.
Ich könnte das qualitative, qualitative Eigenschaften beschreiben von dem Softwaresystem
wie Benutzbarkeit
Oder sowas. Das könnte ich zum Beispiel durch Prüfungen,
durch Assessments beschreiben, durchführen. Zum Beispiel könnte ich
das Richtung Performance-Testen prüfen. Ich könnte es mit einem Lasttest
oder mit einem Durchsehen richten, ob ich Beutelnecks finde.
Ich könnte es Richtung Security prüfen,
indem ich typische Fehler suche in einem Audit oder sowas.
Das wäre für Softwareentwicklung möglich. Bei der DSL-Entwicklung Kann ich denn dort
das Verhalten prüfen? Für eine Sprache gibt es kaum ein Verhalten.
Ich kann nur eigentlich prüfen, ist es angemessen?
Wir verhalten hier, würde ich vielleicht noch hinzufügen, Korrektheit.
Denn hier kann ich keine Korrektheit prüfen als solche.
Ich kann nur sagen, die Sprachelemente passen zu den Sachen, die ich brauche.
Die Sprachelemente drücken das aus, was ich brauche.
Wir hatten ja hier bei der DSL-Entwicklung so ein paar Beispiele geben,
sind die Abstraktionen alle da, passen die.
Jetzt habe ich genug davon, bloß sind es zu viele,
das wäre diese Angemessenheit. Ja,
Korrektheit können wir eigentlich nur sagen für Semantik,
für die Syntax wohl kaum, wir können nur sagen,
ist die im Syntax zu viel,
zu wenig oder wie auch immer
Und für Qualitätseigenschaften können wir natürlich auch Prüfungen durchführen,
aber Qualitätseigenschaften sind dort weniger wie Zuverlässigkeit,
Sicherheit oder sowas, sondern eher Benutzbarkeit.
Das wäre eine wichtige Qualitätseigenschaft
Also gibt es den grundsätzlichen Unterschied zwischen Softwaresystemen, Softwareentwicklung,
wo es auf Korrektheit ankommt und solchen Sprachen,
wo es eigentlich auf Angemessenheit ankommt und korrekt hat sich eigentlich
nur auf die Semantik beziehen kann.
Damit wird mir diesen Abschnitt beschließen und sie haben ja hoffentlich
die Gelegenheit mal, sich das irgendwann mal anzuschauen.
X-Text wäre ein Beispiel davon,
aber die anderen möglichen Implementierungen, die wir besprochen haben,
können vielleicht auch ein Anstoß sein,
das mal auszuprobieren