Ein Interview mit Markus Amshove zum Thema Domänenspezifische Sprachen gibt es in der einhundersiebten Episode des Anwendungsentwickler-Podcasts.
TL;DR
Mit meinem ehemaligen Azubi Markus bespreche ich, wie du domänenspezifische Sprachen (DSLs) für fachliche Aufgaben entwickelst. Sein IHK-Abschlussprojekt zeigt, wie eine eigene Sprache Regeln für eingescannte Dokumente verständlich abbildet und daraus C#-Code samt Unit Tests erzeugt. Xtext übernimmt dabei viele technische Aufgaben und liefert einen passenden Editor. Dazu kommen Erfahrungen mit Konferenzvorträgen sowie Empfehlungen, wie du dich in DSLs und die Grundlagen von Programmiersprachen einarbeitest.
Podcast: Play in new window | Download (Duration: 1:02:16 — 29.7MB)
Abonnieren: Apple Podcasts | Spotify | RSS
Kapitelmarken
- [00:00:01] Thema und Anlass des Interviews
- [00:01:24] Markus und sein Weg in die IT
- [00:03:49] Programmiersprachen im Beruf und privat
- [00:05:41] Sprachmerkmale und Entwicklungsumgebungen
- [00:08:42] Was ist eine domänenspezifische Sprache?
- [00:10:44] Domäne und Sprachumfang festlegen
- [00:11:27] Zielgruppe und fachliche Begriffe
- [00:14:24] Dokumente mit einer DSL zuweisen
- [00:17:07] Regeln verständlich und nachvollziehbar gestalten
- [00:18:34] Eine DSL gemeinsam mit dem Fachbereich entwerfen
- [00:20:44] Grammatik und Backus-Naur-Form
- [00:23:05] Was Xtext aus der Grammatik erzeugt
- [00:24:34] Editorfunktionen und Verweise zwischen Elementen
- [00:26:56] Code mit Java und Xtend erzeugen
- [00:29:33] Einstieg und Erfahrungen beim Lernen
- [00:32:27] Programmiersprachen besser verstehen
- [00:34:15] Die DSL als IHK-Abschlussprojekt
- [00:35:36] Feedback der Prüfer:innen und Projektdokumentation
- [00:36:36] Zeit sparen und Unit Tests generieren
- [00:38:44] Parser und Codegenerator testen
- [00:40:14] Formelmanager für Versicherungsmathematik
- [00:41:44] Grenzen und Updates von Xtext
- [00:43:35] DSL-Vortrag auf der JavaLand
- [00:45:40] Begleitung durch einen Mentor
- [00:47:20] Eigene Themen für Konferenzvorträge finden
- [00:49:12] Weitere DSL-Plattformen: MPS und Nitra
- [00:50:43] Einstieg mit Büchern und Tutorials
- [00:52:00] ANTLR und die Grundlagen hinter dem Framework
- [00:53:05] Weitere Bücher zu Sprachen und Laufzeitumgebungen
- [00:56:30] Geplanter Vortrag über Mutation Testing
- [00:59:21] Kontaktmöglichkeiten von Markus
- [01:00:49] Rückblick und Shownotes
Inhalt
Wir haben uns u.a. über die folgenden Fragen ausgetauscht.
Allgemeines zur Person
- Wie ist dein Name und wo arbeitest du?
- Wie bist du zur Informatik bzw. Softwareentwicklung gekommen?
- Welche Ausbildung bzw. welches Studium hast du im Bereich der Informatik absolviert?
- Mit welcher/n Programmiersprache/n arbeitest du im Alltag?
- Was ist deine Lieblingsprogrammiersprache und warum?
Domänenspezifische Sprachen
- Was ist eine domänenspezifische Sprache?
- Was unterscheidet DSLs von „normalen“ Programmiersprachen?
- Was sind interne und externe DSLs?
- Womit kann man DSLs entwickeln?
- Welche DSLs hast du bisher entwickelt und wofür werden sie eingesetzt?
- Welche Plattform nutzt du für deine DSLs und warum?
- Wie geht man bei der Umsetzung einer DSL vor?
- Was sind Grammatik, Parser und Lexer?
- Bringen DSLs wirklich so viel Mehrwert, dass sich eine Entwicklung lohnt?
- Wie schwierig ist die Entwicklung einer eigenen Programmiersprache?
- Was macht dir am Entwickeln von DSLs Spaß?
- Was stört dich beim Entwickeln von DSLs?
- Wie bist du zum Thema DSLs gekommen?
- Können auch schon Azubis eigene DSLs entwickeln?
- War das Thema nicht zu schwierig für ein IHK-Abschlussprojekt?
- Welche Literaturempfehlungen hast du für den Bereich DSLs?
Vorträge auf Konferenzen
- Wie kam es zu deinem Vortrag auf der JavaLand?
- Was kann man sich unter dem „Newcomer-Track“ vorstellen und wie wurdest du dort betreut?
- Wie hast du das Thema deines Vortrags gefunden?
- Wie hast du dich auf deinen Vortrag vorbereitet?
- Was hast du selbst durch den Vortrag gelernt?
- Was hat dir der Vortrag rückblickend gebracht?
- Sollten auch Azubis oder Berufseinsteiger schon Vorträge halten?
Aus- und Weiterbildung
- Was ist das letzte Fachbuch mit Bezug zur Programmierung, das du selbst gelesen hast?
- Was ist dein absolutes Lieblingsbuch mit Bezug zur IT/Programmierung und warum?
Literaturempfehlungen
Links
- Permalink zu dieser Podcast-Episode
- RSS-Feed des Podcasts
- Markus‘ Blog
- Meine praktische Abschlussprüfung – Markus Amshove
- Markus‘ IHK-Projektarbeit über DSLs
- Markus Amshove bei GitHub
- Presentations by Markus Amshove // Speaker Deck
- SEROM – Softwareentwicklung im Mittelstand
- Markus‘ Vortrag: Domänenspezifische Sprachen mit Xtext
- Xtext – Language Engineering Made Easy!
- ANTLR
Zusammenfassung
Markus und sein Weg zur Softwareentwicklung
Mein ehemaliger Azubi Markus arbeitet bei der Alten Oldenburger und studiert nach seiner Ausbildung dual Wirtschaftsinformatik. Über Gaming und Delphi-Bücher seines Vaters kam er zum Programmieren. Im Unternehmen entwickelt er domänenspezifische Sprachen und Werkzeuge für Entwickler:innen.
Beruflich arbeitet er hauptsächlich auf der Java-Plattform, wobei auch Xtend und Groovy dazugehören. Privat programmiert er gern mit C# und beschäftigt sich mit Kotlin. Dabei gefallen ihm funktionale Sprachmittel und die Möglichkeit, ausdrücklich festzulegen, ob ein Wert null sein darf. Bei Entwicklungsumgebungen legt er Wert darauf, viel mit der Tastatur erledigen zu können. Vim-Erweiterungen und eine Command Palette helfen ihm dabei.
Was eine domänenspezifische Sprache abbildet
An SQL lässt sich das Prinzip einer domänenspezifischen Sprache, kurz DSL, nachvollziehen: Du beschreibst Aufgaben aus einem bestimmten Bereich, während die Technik dahinter deine Angaben auswertet. Bei SQL betrifft das den Zugriff auf Datenbanken.
Eine DSL kann auch Bedingungen oder Schleifen enthalten. Welche Sprachmittel dazugehören, hängt davon ab, welche Aufgaben du lösen möchtest. Wenn du zusätzliche Funktionen einbaust, wächst die Komplexität der Sprache.
Beim Entwerfen klärst du deshalb zuerst, welche fachlichen Aufgaben deine Sprache abbilden soll und wer damit arbeiten wird. Als Zielgruppe kommen Entwickler:innen ebenso infrage wie Mitarbeiter:innen eines Fachbereichs. Deren Anforderungen fließen in den Sprachumfang ein.
Du kannst deutsche Schlüsselwörter verwenden und sogar ganze Sätze zulassen. Ein Satz wie "Ein Vertrag hat viele Versicherte" könnte eine Struktur beschreiben, aus der später eine Liste von Versicherten entsteht. Wenn du die Begriffe des Fachbereichs übernimmst, erleichtert das den Austausch mit deinen Ansprechpartner:innen. Dieser Gedanke findet sich auch im Domain-driven Design.
Eine DSL als IHK-Abschlussprojekt
Für sein Abschlussprojekt entwickelte Markus eine Sprache, die festlegt, welche:r Mitarbeiter:in ein eingescanntes Dokument erhält. Die Regeln dafür standen zuvor direkt in einem .NET-Programm und waren mit der Zeit unübersichtlich geworden.
In der DSL erscheinen fachliche Begriffe wie "Regel" und "Zuweisung". Aus den beschriebenen Regeln entsteht C#-Code. Wer eine Regel verfasst, kann sie dadurch deklarativ mit den Begriffen des Fachbereichs ausdrücken.
Auf Wunsch des Fachbereichs beschreibt jede Regel einen einzelnen Fall. Für alternative Bedingungen werden separate Regeln angelegt. Soll etwa ein Vorname mit A oder B beginnen dürfen, entstehen dafür zwei Regeln. Über deren Namen lässt sich nachvollziehen, warum ein Dokument einer bestimmten Person zugewiesen wurde.
Beim Entwerfen ging Markus gemeinsam mit einem Ansprechpartner aus dem Fachbereich die vorhandenen C#-Regeln durch. Sie schrieben diese direkt in einer geordneten Textform auf, aus der sich die spätere Sprache entwickelte.
Mit Xtext eine eigene Sprache entwickeln
Zum Einstieg definierst du in Xtext die Grammatik deiner Sprache in einer Form, die auf der Backus-Naur-Form beruht. Darin legst du fest, wie gültige Texte aufgebaut sind. Die Grammatik des Abschlussprojekts umfasste ungefähr 40 bis 50 Zeilen.
Aus dieser Grammatik erzeugt Xtext unter anderem:
- Lexer und Parser, die den eingegebenen Text verarbeiten.
- Ein Eclipse-Plugin beziehungsweise einen Language Server für die Arbeit etwa in Visual Studio Code.
- Einen Editor mit Syntax-Highlighting und kontextbezogener Code-Vervollständigung. In Eclipse gehört auch eine Outline dazu.
Xtext bildet die beschriebenen Elemente als Java-Objekte ab und kann Verweise zwischen ihnen auflösen. Dadurch kannst du im erzeugten Editor ausprobieren, ob deine Sprache so funktioniert, wie du sie entworfen hast.
Anschließend programmierst du, welcher Code aus den Angaben entstehen soll. Für eine Routingregel kann der Generator beispielsweise eine C#-Klasse schreiben. Das Eclipse-Plugin lässt sich um eigene Prüfungen oder Refactorings erweitern.
Code mit Xtend erzeugen
Für den Generator kannst du Java oder andere Sprachen auf der JVM verwenden. Xtend wurde ebenfalls mit Xtext entwickelt und bietet Funktionen, die das Erzeugen von Code erleichtern. Es ist eine allgemeine Programmiersprache, aus der Java-Code entsteht.
In mehrzeiligen Textvorlagen kannst du Werte oder Ergebnisse von Methodenaufrufen einsetzen. Xtend berücksichtigt dabei die Einrückung, sodass sich auch der erzeugte Code übersichtlich formatieren lässt.
Markus empfand das Lernen während seiner Ausbildung zunächst als anspruchsvoll. Mit Tutorials erschloss er sich die Grammatikbeschreibung; bei Xtend half ihm später, die Nähe zu Java zu erkennen. Durch die weitere Arbeit verstand er besser, wie Sprachen übersetzt werden und weshalb ihre Syntax eindeutig sein muss. Dieses Wissen konnte er auch im Studium einbringen.
Projektwahl und Ergebnisse in der Praxis
Als Markus sein Abschlussprojekt auswählte, hatte er bereits eine DSL entwickelt und kannte Xtext aus seiner täglichen Arbeit. Der damals vorgegebene Rahmen von 70 Stunden musste realistisch einzuhalten sein. Für dein eigenes Projekt empfehle ich dir deshalb ein Thema, bei dem du auf vorhandene Erfahrungen aufbauen kannst.
Die Prüfer:innen nahmen das Thema positiv auf. Auf meiner Website findest du Markus’ Projektdokumentation, die mit 100 Prozent bewertet wurde. Die entwickelte Sprache wird im Unternehmen eingesetzt.
Für die wirtschaftliche Betrachtung untersuchte Markus, wie viel Zeit typische Aufgaben beanspruchten. Als Beispiel nennt er das Nachvollziehen einer Dokumentzuweisung: Dafür waren zuvor aus seiner Erinnerung etwa sieben Minuten nötig. Mit der DSL ist die zuständige Regel direkt erkennbar.
Zusätzlich erzeugt der Generator für jede Regel C#-Unit-Tests mit passenden Dokumentdaten. Diese prüfen, ob die Regel erreichbar ist. Dabei können Fälle auffallen, in denen eine höher priorisierte Regel bereits greift.
Die DSL selbst testen
Auch die Werkzeuge rund um deine Sprache lassen sich automatisiert prüfen:
- Parser: Du gibst DSL-Text vor und prüfst, ob daraus die erwarteten Elemente entstehen.
- Codegenerator: Die erzeugten Texte lassen sich mit erwarteten Strings vergleichen.
- Typsystem: Tests prüfen, welche Kombinationen deine Sprache erlaubt.
- Editor-Erweiterungen: Auch eigene Funktionen wie Tooltips oder eine Outline können getestet werden.
Weitere Projekte und Schwierigkeiten
Zum Zeitpunkt des Gesprächs arbeitet Markus an einem Formelmanager für Versicherungsmathematik. Darin beschreibt eine Metasprache Statements mit Parametern. Diese legen fest, welcher Natural-Code entsteht, und werden anschließend in Formeln kombiniert.
Bei Xtext stieß Markus auch auf Grenzen. Eine Grammatik für Natural konnte er wegen dessen kontextsensitiver Eigenschaften mit seinem Ansatz nicht abbilden. Updates auf neue Xtext-Versionen erwiesen sich in seiner Arbeitsumgebung als aufwendig. Er legte dafür neue Projekte an und übernahm den vorhandenen Quellcode. Als mögliche Ursache nennt er Einschränkungen beim Internetzugriff über den Firmenproxy.
Erfahrungen mit Konferenzvorträgen
Auf der JavaLand hielt Markus im Newcomer-Track einen 45-minütigen Vortrag, während dessen er eine Beispiel-DSL entwickelte. Er erhielt positives Feedback, auch von Personen, die an Xtext mitgearbeitet hatten.
Ein Mentor unterstützte ihn bei der Auswahl der Inhalte. Der Newcomer-Track bietet damit einen Rahmen für den ersten Vortrag auf einer größeren Konferenz. Themen aus deinem Arbeitsalltag können für andere Entwickler:innen interessant sein. Auch Grundlagen und praktische Werkzeuge werden nachgefragt.
Für einen weiteren Vortrag beschäftigt sich Markus mit Mutation Testing. Dabei werden zunächst die vorhandenen Tests ausgeführt. Wenn sie erfolgreich sind, verändert das Werkzeug gezielt den getesteten Code, etwa einen Vergleichsoperator oder einen Rückgabewert. Bleiben die Tests nach einer solchen Mutation erfolgreich, weist das auf eine Stelle hin, die sie unzureichend prüfen.
Werkzeuge und Quellen zum Weiterlernen
Für deinen Einstieg nennt Markus folgende Quellen:
- Xtext-Dokumentation: Kurze Tutorials und ein erweitertes Tutorial führen in die Arbeit mit dem Framework ein.
- Implementing Domain-Specific Languages with Xtext and Xtend: Das Buch begleitet das Entwickeln einer Sprache und zeigt auch, wie du die jeweiligen Bestandteile mit Unit Tests prüfst.
- ANTLR: Damit erhältst du Lexer und Parser. Die übrigen Bestandteile entwickelst du selbst und kannst dadurch nachvollziehen, welche Aufgaben ein umfangreicheres Framework übernimmt.
- How to create pragmatic lightweight languages von Federico Tomassetti: Markus liest darin unter anderem über das direkte Erzeugen von JVM-Bytecode.
- CLR via C#: Das Buch beschreibt den Zusammenhang zwischen C# und der Laufzeitumgebung sowie Entscheidungen beim Entwerfen der Sprache.
Als weitere Plattformen spricht Markus JetBrains MPS und Nitra an. MPS arbeitet mit einem Projektionseditor, in dem sich beispielsweise Tabellen im Quelltext darstellen lassen. Markus hat es selbst noch nicht ausprobiert. Nitra beschreibt er zum Zeitpunkt des Interviews als ein noch in Entwicklung befindliches Werkzeug für .NET mit einer ähnlichen Ausrichtung wie Xtext.
Die Links und Buchempfehlungen zum Gespräch findest du in meinen Shownotes unter anwendungsentwicklerpodcast.de/107. Markus verweist außerdem auf seinen Blog, über den du seine Kontaktmöglichkeiten findest.
Transkription der gesamten Episode
Automatisch erzeugte Transkription der Episode
Herzlich willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker für Anwendungsentwicklung.
In dieser Episode gibt es ein Interview mit Markus Amshofe über domänenspezifische Sprachen. Viel Spaß!
Hallo und herzlich willkommen zur 107. Episode des Anwendungsentwickler-Podcasts.
Mein Name ist Stefan Macke und heute gibt es wieder ein spannendes Interview und zwar zu einem Thema, das so ein bisschen nicht allzu mainstreamig ist, und zwar domänenspezifische Sprachen.
Aber bei diesem Thema kann man ganz viel auch allgemein über Programmiersprachen lernen, von daher finde ich es völlig geeignet für diesen Podcast und ich finde es insbesondere deswegen so spannend,
weil mein ehemaliger Auszubildender, der jetzt seit zwei Jahren fertig ist und seine Prüfungen bestanden hat, nämlich genau in seinem IHK-Abschlussprojekt über domänenspezifische Sprachen etwas geschrieben hat.
Und über dieses Thema möchte ich mich heute deswegen mit ihm intensiv unterhalten und ich hoffe, für dich ist auch ganz viel spannender Inhalt dabei und es soll auch eine Motivation natürlich für alle angehenden Prüflinge da draußen sein,
auch mal ein komplexeres, ein spannendes, ein außergewöhnliches Projekt umzusetzen. Das kann sehr gut ausgehen, im wahrsten Sinne des Wortes, aber jetzt höre ich auch auf mit dem Vorgeplänkel und wir steigen direkt ein ins Interview. Viel Spaß!
Ja, hallo Markus. Ich würde sagen, wir fangen mit so einer ganz klassischen Vorstellrunde an. Also ich stelle mich nicht mehr vor, aber vielleicht magst du ja mal ein paar Sätzen erzählen, wer du so bist, was du so machst. Genau.
Ja, ich heiße Markus Amshofer, bin 26 Jahre alt, ich arbeite bei der alten Oldenburger, habe da meine Ausbildung auch vor zwei Jahren abgeschlossen. Im Moment mache ich mein duales Studium Wirtschaftsinformatik, bin hoffentlich in einem Jahr durch, also nächstes Jahr um diese Zeit hätte ich meine Bachelorarbeit dann abgegeben und beschäftige mich auf der Arbeit eigentlich rund um die Themen, worüber wir heute auch sprechen.
Also domainspezifische Sprachen entwickle ich, irgendwie Tools, um Entwickler zu unterstützen und ähnliche Sachen in die Richtung.
Und wie bist du allgemein zur IT gekommen? War das schon immer dein Traum den ganzen Tag zu programmieren oder wie hat sich das ergeben?
Ich hatte schon immer so eine kleine Affinität, also wir sind eine Informatikerfamilie, aber bei mir fing das halt so typisch mit Gaming an und ich hatte in meiner Jugend eine bestimmte Zeit lang ziemlich viel Freizeit, also war sehr lange krank geschrieben und da hat mein Vater gesagt, jetzt liegt doch nicht mal rum, sondern mach mal was und hat mir dann so ein paar Delphi-Bücher gegeben.
Und ja, das hat mir dann eigentlich sehr schnell sehr gut gefallen und dann wollte ich auch nichts anderes mehr machen.
Sehr gut, also quasi wirklich so als Queereinsteiger rein und dann jetzt auch die Ausbildung direkt angehängt und jetzt noch das Studium, also du willst das Ganze auch noch vertiefen auf jeden Fall.
Ja, sehr cool, so muss das auch sein. Und Gaming, was war das so für Games damals?
Alles mögliche. Womit das angefangen hat, weiß ich gar nicht genau, ich schätze mal so das typische Age of Empires und so, das ging dann auch in die Richtung Counter-Strike, Warcraft, war natürlich auch sehr lange, wie sich das gehört, so ein World of Warcraft-Spieler, aber davon bin ich jetzt ab, jetzt bin ich nicht mehr süchtig.
Ja, oder geheilt durch das Studium wahrscheinlich, was auch viel Arbeit macht.
Ja, das ist schon etwas länger her, ich habe auch schon vor der Ausbildung nicht mehr gespielt.
Okay, na gut. Ja, sehr gut. Wir machen aber, habe ich schon auf dem Plan, nochmal so eine Episode rund um das duale Studium und deine Ausbildung, von daher, das werden wir nochmal an anderer Stelle vertiefen.
Aber wenn du jetzt so im Alltag mit IT arbeitest und programmierst vor allem, was sind denn so da deine Programmiersprachen, die so eingesetzt werden?
Wir verwenden hauptsächlich die Java-Plattform bei der alten Oldenburger, deswegen ist eigentlich der Großteil Java, zumindest in meinem Bereich, wir haben ja auch noch diese Alt-Anwendungen in Natural, aber damit habe ich nicht so viel am Hut.
Neben Java auf der Plattform ist das dann auch noch Extend, aber dazu kommen wir ja sicherlich später noch. Und weil ich auch den Build-Server administriere, so ein bisschen Groovy, also was so mit Jenkins und Gradle einhergeht.
Ich habe auch noch ein paar kleine C-Sharp-Projekte bei der AO, aber darüber dürfen wir nicht sprechen.
Hier sind wir unter uns.
Deswegen, die werden halt noch gewartet, aber neue Entwicklungen sind eigentlich alle immer auf der Java-Plattform.
Und wenn du jetzt so verschiedene Sprachen auch schon genannt hast, hast du da irgendwie eine Lieblingssprache? Muss auch nicht unter den genannten sein, völlig frei?
Ja, meine Lieblingssprache an sich ist eigentlich C-Sharp, also damit mache ich alles im privaten Umfeld am liebsten. Ich mache auch manchmal so einen kleinen Schwenker Richtung F-Sharp, aber das ist dann halt so ein bisschen anders, als man das sonst kennt.
Aber zur Zeit auch sehr viel, jetzt so seit einem halben, dreiviertel Jahr Kotlin im privaten Umfeld, weil ich da viel wiedererkenne aus C-Sharp und einiges sogar noch besser als in C-Sharp, was dann vielleicht auch mal rüberkommt.
Aber das ist so das, was mir im Moment am meisten Spaß macht und wenn ich eine Freizeit programmiere, dann richte ich mich halt auch danach, mit welchen Sprachen ich am meisten Spaß habe oder ob ich gerade irgendwas lernen möchte oder so.
Was heißt denn überhaupt für dich Spaß beim Programmieren?
Ja, das ist eine gute Frage. Das muss irgendwie ja beim Programmieren so nervige Sachen sollten halt nicht auftreten. Was mich zum Beispiel bei Java ganz schnell nervt, sind so Sachen wie Getter, Setter oder trotz Java 8 nervt mich das immer Punkt Stream zu schreiben und sowas und die Lambdas sind ja auch so ein bisschen eingeschränkt.
Ein paar Mal bin ich schon über die Generics gestoßen, die ja aufgrund von Type Eraser hat man die Typ-Informationen nicht mehr zur Laufzeit, was ich aus C-Sharp halt so kenne. Das sind dann so Sachen, wo man immer so ein bisschen dran vorbei entwickeln muss.
Und besonders bei Kotlin gefällt mir, da ist das Funktionale halt noch ein bisschen mehr hervorgehoben und besser eingebaut noch und es sieht schöner aus, wenn man das so programmiert.
Und so Sachen wie, wenn man möchte, dass etwas null sein kann, dann muss man das explizit sagen und so. Das sind halt Nettigkeiten, die das Entwickeln einfach schöner machen. Ebenso geht es bei mir auch so ein bisschen immer um die IDEs, also ich muss mich in meiner Entwicklungsumgebung wohl fühlen. Genau.
Und hast du da auch eine Lieblingsentwicklungsumgebung? Ich hoffe Eclipse oder gibt es noch etwas anderes?
Nein, es kommt immer darauf an, womit ich, was ich gerade mache. Im Prinzip hat jede Entwicklungsumgebung, die ein Vim-Plugin hat, schon mal, kann sich schon mal angeschaut werden.
Da ist halt das Schöne, dass man dann, dass die VI-Shortcuts, die nehmen halt ganz viel von der Lernkurve ab. Also VI-Lernen an sich ist natürlich viel Lernen, aber wenn man dann egal welche IDE vor sich hat, dann kann man zumindest was Text angeht immer ganz schnell drin rumhacken, wie man es sonst auch gewohnt ist.
Und alles, was drumherum ist, das muss dann halt ziemlich gut mit der Tastatur gemacht werden können. Mir gefällt zum Beispiel bei IntelliJ und sowas wie VSCode, so Sachen wie, wenn man dann nicht mehr weiß, wie gerade der Shortcut war, dann gibt es durch eine Tastenkombination so ein kleines Fenster, da kann man dann eingeben, was man machen möchte.
Und dann steht da auch der Shortcut direkt neben. Das heißt, für den nächsten Schritt kann ich mir den merken. Und genau, selbst dann muss man die Maus nicht benutzen. Und ich glaube, Command Palette heißt das bei VSCode. Bei Sublime gibt es das auch. Da wird es, glaube ich, geklaut. Ja, sowas gefällt mir eigentlich immer ganz gut. Also womit man schnell produktiv sein kann.
Ja, dann kommen wir doch jetzt einfach mal zum eigentlichen heutigen Thema, nämlich den domänenspezifischen Sprachen. Das hast du ja gerade auch schon gesagt, dass du das auch im Dayjob quasi wirklich intensiv betreibst. Und vielleicht kannst du ja kurz mal in deinen Worten erklären, was eigentlich eine domänenspezifische Sprache ist.
Ja, und zwar ist eine domänenspezifische Sprache auch eine Programmiersprache, bzw. es kann so aussehen wie eine Programmiersprache. In der Gestaltung ist man eigentlich recht frei. Und der Hintergrund ist der, dass man sich halt etwas schaffen möchte, wo man nur eine kleine Palette an Aufgaben bzw. eine bestimmte Palette an Aufgaben lösen möchte.
Also ich nenne einfach mal ein Beispiel, damit man sich das vorstellen kann. Das bekannteste Beispiel SQL ist halt nicht so eine Programmiersprache, die man kennt, also keine normale in Anführungszeichen. Da geht es auch nur um Datenbankmanipulation lesen, also je nachdem welchen Dialekt man nimmt.
Und das kann die aber dann halt perfekt. Und wie das im Hintergrund funktioniert, das bekommt man dann eigentlich nicht mit, sondern man schreibt einfach seine SQL-Statements und das, was dahinter steht, das kümmert sich dann darum, diese auszuwerten.
Mhm. Kann man jetzt allgemein sagen, jetzt SQL als Beispiel. SQL ist ja nun keine Programmiersprache, mit der ich zum Beispiel eine Schleife oder sowas bauen kann. Das heißt, die ist ja eher deklarativ. Kann man allgemein sagen, dass DSLs sehr stark wie SQL aussehen oder können das auch echte Programmiersprachen sein mit Schleifen und ich weiß nicht was?
Das können auch echte Programmiersprachen sein. Also es ist halt immer die Frage, was brauche ich, um meine Probleme, die ich mit der DSL lösen möchte, zu lösen. Es kann durchaus sowas sein, dass man auch modellieren möchte, so Bedingungen wie if oder eine Schleife. Ich sage mal, solange das Rolo nicht unten ist, lasse ich das Licht an oder so. Das ist natürlich auch möglich.
Okay. Also höre ich so ein bisschen raus, wenn ich jetzt eine DSL entwerfe, dann sollte ich mich als erstes vielleicht mal tatsächlich um meine Domäne kümmern und überhaupt erstmal klären, was ich denn eigentlich an Funktionalität abbilden muss. Richtig?
Genau. Das ist auch sehr wichtig, weil wenn man dann, wenn man das abgebildet hat und denkt sich, ich könnte noch dies machen und ich könnte noch das machen, dann geht man halt so ein bisschen hin zu etwas, was ich sage mal zu viel kann, also mehr als man eigentlich benötigt.
Und dann steigt auch wieder die Komplexität und dann habe ich eigentlich die Vorteile, was zumindest das Schreiben der DSL bietet, so ein bisschen wieder aufgehoben, je nachdem wie komplex das wird.
Gibt es denn für die DSLs so eine bestimmte Zielgruppe? Also entwickle ich das zum Beispiel für einen Fachbereich? Jetzt wenn ich zum Beispiel sage, ich möchte so komplexe Strukturen wie Schleifen und if-Abfragen und sowas rausnehmen, ist das Ziel dann, dass zum Beispiel der Fachbereich selber damit entwickelt oder gibt es da auch DSLs für Programmierer?
Es ist beides möglich. Also ich denke, auch bei SQL könnte man das halt, eine Datenbankadmin beispielsweise, der eigentlich den ganzen Tag administriert, aber auch SQL kann, der kann ja nicht unbedingt sowas Klassisches wie C programmieren oder so oder Java. Und deswegen denke ich schon, dass das in beide Richtungen geht.
Ich muss mir aber halt von vornherein klar sein, wer meine Zielgruppe ist und am besten die auch fragen, was die eigentlich alles möchten. Wenn die sich einig sind, das kann ruhig ein bisschen komplexer sein, weil ich da ein bisschen mehr abbilden kann, ist das natürlich auch in Ordnung.
Und wenn ich jetzt tatsächlich das Ziel habe, es möglichst einfach zu machen, jetzt egal ob für Programmierer oder Fachbereich, bin ich irgendwo eingeschränkt, was zum Beispiel meine Schlüsselwörter angeht oder könnte ich zum Beispiel eine deutsche DSL schreiben, damit mein deutscher Fachbereich das gut versteht oder muss ich zum Beispiel irgendwelche Schlüsselwörter von Java übernehmen oder sowas?
Da ist man komplett frei. Also man kann auch deutsche DSLs entwickeln oder gegebenenfalls sogar ganze Sätze. Also ich könnte mir vorstellen, jetzt aus der Versicherungsbranche, dass dann jemand aus dem Fachbereich einfach in ein Textdokument schreibt, ein Vertrag hat viele Versicherte und das ist dann schon die ganze DSL.
Und was dabei herumkommt hinterher ist dann halt irgendwie eine Struktur, die heißt Vertrag und darunter gibt es sowas wie eine Liste aus Versicherten. Das ist aber dann halt schon hinter der DSL, also eine Ebene tiefer sozusagen, wo ich dann wieder ansetze, was er aber in der Umsetzung eigentlich nicht weiß und ihn ja auch gar nicht interessiert.
Also ich kann wirklich quasi genau den Sprachgebrauch, den auch mein Kunde haben will, egal ob Programmierer oder nicht, eins zu eins in eine völlig eigene Sprache gießen, ohne irgendwas berücksichtigen zu müssen.
Genau, das steckt ja auch so in dem Namen domain-specific, also für eine Domäne. Es gibt ja auch dieses domain-driven-design, da verwendet man ja auch die Namen, die eigentlich mein Kunde verwendet, damit ich mit dem auf einer Wellenlänge bin. Das kann ich da auch machen.
Ist sogar vorteilhaft, wenn ich die Wörter benutze, also die Keywords benutze, die der Kunde auch benutzt, weil dann wissen wir immer beide, worüber wir sprechen. Und vor allem, er fühlt sich sofort zu Hause. Für mich ist es ein bisschen mehr Aufwand. Ich muss natürlich lernen, was dahinter steckt, aber das muss ich sowieso, weil ich ja was damit umsetzen muss.
Das ist jetzt eine gute Überleitung. Vielleicht kannst du mal einfach ein Beispiel, dass man sich ein bisschen plastischer das vorstellen kann, was man jetzt damit umsetzen kann. Was hast du denn zum Beispiel bislang für DSLs entwickelt?
So wie es jetzt modern ist, scannen wir natürlich alles fleißig ein. Und da wir aber viele Mitarbeiter haben, muss halt irgendwie entschieden werden, welcher Mitarbeiter bekommt was. Und dafür gibt es halt Regeln, die sind vorher in einem .NET-Programm einfach reinkodiert worden.
Und weil die Masse an Regeln einfach so viel wurde und unübersichtlich wurde, habe ich mir das als Abschlussprojekt genommen für die IHK und habe darauf eine DSL entwickelt. Und darin findet man dann auch so Schlüsselwörter wieder wie Regel, also als Routingregel oder Zuweisung. Ist auch ein Domainbegriff in dem Sinne, weil eine Zuweisung an einen Mitarbeiter für ein Dokument und ähnliches.
Und ganz konkret, die DSL, die du jetzt erwähnt hast, womit hast du die erwähnt? Ist das jetzt irgendwas mit .NET oder was steckt da jetzt für ein Framework oder irgendwas dahinter?
Also es ist quasi so eine Art Abstraktion über das, was vorher per Hand kodiert wurde. Das wird jetzt mit wenigen fachbereichsspezifischen Begriffen irgendwie dargestellt und es wird aber quasi der gleiche Code wie vorher generiert, vielleicht irgendwie noch ein bisschen anders.
Aber das heißt, der Entwickler der Regel muss eigentlich nicht mehr programmieren können, sondern durchaus relativ deklarativ. In diesem Beispiel kann er seine Sachen da definieren.
Also einerseits ist es komplex, wenn ich viele Regeln habe. Andererseits ist es komplex, wenn eine Regel viele Bedingungen hat oder in einer Bedingung eigentlich so drei Regeln stecken wegen oder Verbindungen und sowas.
Und bei der DSL, das war dann auch der Wunsch des Fachbereichs, war es dann so, eine Regel beschreibt immer nur eine Regel und es gibt kein oder. Also ich kann nicht sagen, diese Regel trifft zu, wenn der Vorname mit A anfängt oder mit B anfängt, sondern in der DSL müssen daraus dann zwei Regeln gemacht werden.
Das diente dazu, dass das halt weniger komplex ist und das besser nachverfolgbar ist, welche Regeln jetzt zugetroffen haben. Weil es kann ja durchaus mal die Rückfrage geben, warum habe ich jetzt dieses Dokument bekommen und nicht mein Kollege oder so. Und dann kann man das halt schnell nachgucken anhand der Namen der Regeln.
Heißt also auch, ich kann ja den Sprachumfang so einschränken, dass man halt nichts mehr machen kann, was man mit einer normalen Sprache so tun könnte. Also von hinten durch die Brust ins Auge irgendwie. Sondern ich muss halt genau dieser Vorgabe folgen und das macht dann anscheinend den Code sogar ein bisschen lesbarer am Ende.
Genau. Ich kann halt dafür sorgen, dass dadurch, dass ich halt vorgebe, was in der Sprache möglich ist, kann ich den Leuten auch helfen, sich nicht in den Fuß zu schießen.
Ja, genau. Sehr gut. Ja, das fände ich immer wichtig. Da sagt man ja auch immer C++, da ging ganz viel, was man besser nicht so machen sollte. Und Java und andere Sprachen setzen dann halt darauf auf, aber schalten genau das ab, was eigentlich so vielen Programmierern Probleme macht. Also das hört sich ja schon mal ganz gut an. Und du hast jetzt gesagt, du entwickelst die DSLs mit X-Text. Wie geht man denn überhaupt grundsätzlich da vor, wenn man so eine DSL jetzt entwickeln soll?
Da habe ich verschiedene Vorgehensweisen ausprobiert. Die allererste DSL, die ich gemacht habe, war nicht das Abschlussprojekt, sondern vorher noch etwas. Und da war so eigentlich das Ausgangsformat schon vorgeschrieben. In dem Fall war das XML.
Bei dem Abschlussprojekt habe ich es aber ein bisschen einfacher machen können, beziehungsweise das stellt sich jetzt im Nachhinein als einfacher raus. Wenn man sich vorstellt, diese Regeln, die im C-Sharp Code waren, die muss ich ja auch irgendwie einmal erfassen alle, damit ich weiß, womit ich es überhaupt zu tun habe und was ich generieren muss an C-Sharp Code.
Also geht man hin und guckt sich alle Regeln in C-Sharp an und muss die in irgendeiner Form aufschreiben. Und da habe ich das dann einfach so gemacht, sogar mit dem Kunden zusammen, dass wir uns hingesetzt haben, haben uns die Regeln angeschaut und haben die sofort in einer geordneten textuellen Form irgendwie aufgeschrieben, um uns schon dabei zu überlegen, wie soll die Sprache eigentlich hinterher aussehen.
Sonst wäre es ja angedacht, war erst, dass wir das einfach in Excel schreiben und dann schreiben hier, das ist und und oder und dann kommt das bei raus oder so. Aber so konnten wir das dann halt eigentlich schon, hatten wir schon eine fertige Sprache, nur keinen Motor drunter, der dann damit arbeitet sozusagen.
Also, kann man sich das jetzt ganz blöd so vorstellen? Bei einem normalen Programm, was sich entwickelt, muss ich mir halt überlegen, was sollen die
Funktionalitäten sein und dann
schneide ich das zum Beispiel so klein, dass ich am Ende sage, ich habe jetzt hier eine Klasse, da eine Klasse und in deinem Fall wäre
es jetzt so etwas wie, ich habe halt keine Klasse, sondern ich habe halt ein
Sprachelement, also zum Beispiel irgendwie ein Schlüsselwort oder so, was am Ende dabei rauskommt, oder?
Genau.
Spannend. Okay, das hört sich natürlich erst mal, wenn man das noch nie gemacht hat, super kompliziert an, so seine eigene
Programmiersprache zu bauen. Muss man da jetzt irgendwie sich auch noch irgendwie mit viel Theorie im Hintergrund
beschäftigen, oder ist das tatsächlich vergleichbar mit, ich programmiere jetzt hier mal ein Programm, nur dass es halt zufällig eine Programmiersprache ist?
Also, bei
xText ist es tatsächlich so gewesen, dass es,
dass die Einstiegshürde ziemlich gering war. Also, die haben gute
Tutorials in der Dokumentation und das Einzige, was da dann erstmal im ersten Schritt neu ist, also man muss halt als erstes
die Grammatik der Sprache
definieren und da muss man das halt in so einer Bakusnauer-Form, nennt sich das, machen.
Sieht im ersten Moment erst mal
anders aus, als das, was man gewohnt ist. Wenn man reguläre Ausdrücke kennt, dann
kennt man das vielleicht doch ein bisschen. Da beschreibt man halt, ja, die Form der Grammatik.
Beispielsweise,
wenn ich eine Grammatik für die deutsche Sprache entwickeln würde, dann würde ich halt
eine Grammatikregel haben für einen Satz, der dann immer mit einem Satzzeichen endet. Ein Punkt, ein
Fragezeichen oder ein Ausrufezeichen.
Sollte vielleicht ein Verb enthalten und
erste Buchstabe groß und ähnliches. Also wirklich, wie man sich die Grammatik in einer normalen Sprache, sage ich mal, Englisch-Deutsch
vorstellt oder in der Schule gelernt hat, so definiert man das dort auch, nur halt auf einer technischen Ebene.
Und hast du irgendwie mal
grob eine Hausnummer, wie umfangreich so eine Grammatik wird? Also vielleicht für eine der DSLs, die du gebaut hast, sind das, ich weiß es
nicht, seitenweise Code oder ist das übersichtlich? Wie kann man sich das vorstellen?
Ich
muss jetzt vermuten, aber
geschätzt
sind das so 50 bis 70 Zeilen. Vielleicht noch mit Leerzeilen dazwischen oder vielleicht 100. Also es kommt darauf an, auf die DSL.
Aber dieses Abschlussprojekt, das waren wirklich
40, 50 Zeilen an Grammatikregeln und das war es dann schon.
Das hört sich ja erstmal nicht ganz so viel an. Das heißt, ich bin dann irgendwie nach einer Stunde mit der Grammatik fertig und dann ist
meine DSL komplett oder was muss ich danach dann machen?
Wenn ich die Grammatik habe, dann
habe ich halt erstmal nur die Grammatik. In Xtext ist das dann so, dass ich mir daraus ein
Pasa und Lexa und alles generieren lassen kann aus dieser Grammatik und
ebenfalls wird direkt Sprachintegration
generiert. Also
ein Eclipse Plugin beispielsweise. Ich kann in meiner DSL dann später in Eclipse entwickeln oder
in Visual Studio Code. Dafür wird auch ein Language Server
generiert und ähnliches. Also ich bekomme, wenn ich so ein Framework wie Xtext benutze, extrem viel geschenkt.
Und wo man da dann eigentlich am Ende, also nach dem Generieren anhand der Grammatik, wo man da dann nur noch einsteigen muss, um erstmal
seine DSL im ersten Schritt fertig zu haben, ist dann die Code-Generierung.
Also so wie man sich das vorstellen kann, ist, wenn ich Java programmiere, dann wird daraus ja auch irgendwie Bytecode-Generierung
Also eigentlich ist es immer ein Übersetzen von einer Sprache in die andere.
Und an der Stelle kann ich dann auch einsteigen.
Heißt, in diesen Code-Generatoren kann ich sagen, wenn ich jetzt in meiner DSL auf eine Regel treffe, also eine Routing-Regel,
dann mache ich daraus
Public Class Name der Routing-Regel und so weiter für C-Sharp. Und das ist dann letztendlich
Strings aneinanderhängen und in eine Datei schreiben.
Okay. Das heißt also, wenn ich das Rittverstand habe, wenn ich die Grammatik fertig habe, drücke ich irgendwo auf den Knopf
und dann kriege ich ein lauffähiges Eclipse, in dem auch Syntax-Highlighting, Code-Vervollständigung und sowas einfach schon funktioniert.
Genau. In Grundzügen ist alles da. Also eigentlich auch mehr als Grundzüge. Es gibt Syntax-Highlighting, wie du schon sagtest, Code-Vervollständigung.
In Eclipse auch eine Outline, wie man das von Java vielleicht kennt.
Die Code-Vervollständigung ist auch intelligent. Also die macht nicht nur so eine Text-Vervollständigung, sondern weiß auch,
okay, an dieser Stelle wird jetzt eine Variable erwartet.
Also schlage ich mal nur die Variablen vor, nur die Sachen vor, die auch eine Variable sind und vielleicht auch dort sichtbar sind.
Also wie so ein Scope quasi. Und das wird alles einfach mitgebracht. Das funktioniert dann schon.
Das ist natürlich ziemlich geil. Also wenn ich das nicht verstehe, ich sage jetzt einfach mal 50 Zeilen Grammatik,
dann habe ich quasi einen lauffähigen, komplett mich unterstützenden Editor.
Nur, dass wenn ich jetzt zum Beispiel meine DSL da drinne schreibe und das abspeichere oder so,
dass halt danach einfach noch nichts passiert, weil halt noch so ein Transformator fehlt.
Aber die, ich sage mal, die Idee, die ich mir vorgestellt habe, ist,
die ist eigentlich jetzt schon fertig. Und jetzt muss ich mich noch dahin setzen und programmieren,
was passiert, wenn jetzt der Speichern-Button gedrückt wird.
Also ob jetzt irgendwie, ich weiß nicht, eine andere Promisprache daraus generiert werden soll oder wie auch immer.
Genau, das bekommt man alles geschenkt.
Was noch so dazwischen passiert, wenn man in der DSL dann programmiert,
ist, dass man dann noch so eine Variable schreibt.
Was noch dazwischen passiert, wenn man in der DSL dann programmiert,
sind halt auch so Sachen, also nicht nur, dass er einem daraus Java-Objekte macht,
beispielsweise eine Routing-Regel oder eine Bedingung,
sondern dass der diese halt auch miteinander verbinden kann.
Also wenn ich in der DSL von einem Element auf ein anderes referenzieren möchte,
dann funktioniert das auch schon alles so.
So mitgeneriert von X-Text, dass das alles funktioniert.
Und in dem Editor kann ich direkt loslegen, alles ausprobieren,
ob das auch so aussieht, wie ich mir das vorstelle.
Und wenn das dann so ist, dann habe ich ja eigentlich schon das Frontend fertig,
dann kann ich mich um das Backend kümmern.
Krass. Ja, das hört sich erstmal irgendwie ziemlich cool an.
Und diese Transformation, sage ich mal, aus der DSL, die mir dann vielleicht irgendwo reingegeben wird,
in das, was es dann nachher am Ende ausgeben soll,
also beispielsweise C-Sharp, Java, was auch immer,
das entwickelt man dann mit Java oder wie wird das programmiert?
Das kann man mit Java entwickeln.
Das kann man theoretisch mit allen Sprachen entwickeln,
die halt auf der Java-Plattform laufen.
Allerdings haben die Leute von X-Text dafür auch eine Sprache entwickelt,
mit X-Text selber, die das dann halt vereinfachen soll.
Die nennt sich X-Tent.
Das ist übrigens, auch wenn sie mit X-Text gebaut ist,
ist es eher eine allgemeingültige Programmiersprache,
also keine domainspezifische.
Damit kann man alles machen, was man mit Java auch machen kann.
Hat aber den Fokus darauf, dass es halt gerade bei so Code-Generierung
und String-Manipulation einfach viele Features hat.
Also beispielsweise String-Interpolation, wo ich in dem String dann sagen kann,
ich stelle jetzt mal die Methode auf und das, was da rauskommt,
steckt an die Stelle von diesem String.
Und auch, was eigentlich noch am coolsten ist,
also String-Interpolation kennt man ja vielleicht aus anderen Sprachen,
aber bei X-Tent ist das sogar whitespace-aware, sage ich mal.
Der guckt, wenn ich das von links einrücke,
also wenn ich mehrzeiligen String mache und ich das von links einrücke,
dann schneidet der das, was über ist, eigentlich ab.
Also ich kann so einen geraden Verlauf von einem Text machen
und dazwischen was einrücken und habe das nicht so wild durcheinander,
wenn ich mehrzeilige Strings mache.
Also das brauche ich jetzt zum Beispiel, wenn ich den Code,
den ich aus der DSL generieren möchte,
wenn der auch vernünftig formatiert sein soll zum Beispiel.
Genau, wenn ich eine Klasse plus Implementation in C-Sharp generieren möchte,
dann möchte ich ja nicht schreiben,
public class irgendwas, geschweifte Klammer auf,
plus backslash n und dann geht es weiter mit geschweifte Klammer,
plus backslash n und so weiter.
Also die String-Konkatenation, die man so kennt in Java,
das wäre dann halt nicht mehr übersichtlich.
Sondern man muss sich das so vorstellen,
in X-Tent sieht man wirklich, auch in der IDE gehighlighted,
den Code, den man da hat.
Man kann da meinetwegen die 30-Zeilen-Klassendefinitionen reinschreiben,
einfach als Text.
Und zwischendurch kann man dann sagen,
an dieser Stelle soll jetzt irgendwie ein Wert aus einer Variablen auftauchen
oder aus einer Methodenaufrufe oder ähnliches.
Und das ist jetzt ja, was sagst du, eine eigene Programmiersprache,
die man da benutzt.
Also X-Tent basiert anscheinend auf Java,
aber ist ja schon doch ein bisschen anders anscheinend.
Zusätzlich muss ich jetzt noch diese Bacchus-Nauer-Form lernen,
sag ich mal.
Ist das irgendwie eine ziemlich hohe Einstiegshürde
oder wie schwer ist dir das gefallen?
Also mit einer neuen Programmiersprache,
eine eigene Programmiersprache zu bauen,
das hört sich erst mal so kompliziert an.
Wie war das für dich?
Die Lernkurve war schon sehr steil.
Ist vielleicht auch daraus geschuldet,
dass ich das halt in der Ausbildung gemacht habe
und sowieso noch so ein bisschen Programmieren lernen musste.
Die Bacchus-Nauer-Form ist eigentlich recht einfach,
wenn man sich mal so ein paar Tutorials anguckt.
Also die wird auch nicht nur in X-Text verwendet,
sondern generell, wenn es um Sprachen geht,
findet man die immer wieder
und die kann man durch Tutorials halt sehr gut lernen.
Das X-Tent, das war schon für mich ein bisschen schwieriger,
weil ich nicht so wusste, welche Sachen man wie machen muss.
Aber jetzt so im Nachhinein betrachtet,
ist es eigentlich genauso wie Java.
Also ich habe den Fokus beim Lernen da so ein bisschen falsch gesetzt bei X-Tent.
Es sieht schon sehr ähnlich aus wie Java
und daraus wird auch Java und nicht direkt Bytecode.
Und ist eigentlich die Hürde nicht so stark, würde ich mal sagen.
Okay, also man merkt jetzt auch schon, wenn du es erzählst,
einige Fachbegriffe, vielleicht parser, lexer und sowas erwähnt.
Das heißt, du hast dich jetzt aber schon auch in den letzten Jahren,
Monaten ein bisschen tiefer eingearbeitet,
richtig? Also du bist nicht mehr auf dem Wissensstand wie am Anfang,
sondern hast da schon auch einiges wahrscheinlich über das Design
von Programmiersprachen an sich auch nebenbei so gelernt, richtig?
Genau, das ist aber eigentlich daraus geschuldet,
dass mir das so viel Spaß gemacht hat mit den domainspezifischen Sprachen.
Also eigentlich musste ich mich überhaupt nicht darum kümmern,
was ein parser oder lexer ist oder so.
Klar, diese Grammatik dann halt, aber sonst eigentlich überhaupt nicht.
Und weil mir das aber so viel Spaß gemacht hat
und ich da noch so ein bisschen mehr machen wollte,
habe ich mich dann halt in die Thematik eingelesen.
Und da ist dann das Schöne, dass man durch so eine kleine Einstiegshürde
wie xText eigentlich viele Sachen, wenn man etwas liest in einem Buch,
viele Sachen wiedererkennt, wo man dann denkt,
aha, so machen die das also, was ich gar nicht lernen musste.
Aber so machen die das dann halt, dann kann man das direkt verknüpfen.
Und es ist schon cool, das zu lernen.
Also mir macht das Spaß.
Und dass ich das lerne, ist eigentlich dem geschuldet,
dass das so einfach war und mir einfach Spaß gemacht hat,
eine Programmiersprache zu entwickeln.
Ja, das ist natürlich auch cool.
Man sagt hier, die entwickeln wir mit der Sprache,
die ich selbst geschrieben habe.
Das ist natürlich eine coole Nummer.
Hast du denn andersherum irgendwie vielleicht dadurch,
dass du so Programmiersprachen und den Aufbau irgendwie,
sag ich mal, dir genauer angeschaut hast,
vielleicht auch irgendwas mitgenommen,
was du für deine ganz normale Programmiertätigkeit
irgendwie anwenden kannst?
Also entwickelst du jetzt zum Beispiel irgendwie anders,
weil du weißt, wie es im Hintergrund funktioniert,
oder ist das eher nicht so?
Doch, das kann man so sagen,
weil man kann viele Konzepte in Programmiersprachen
dann einfacher verstehen.
Also wenn man sich fragt beispielsweise,
warum muss denn hier jetzt noch eine Klammer hin oder so,
dann kann man das mit dem Hintergrundwissen
sich halt schon herleiten,
damit das halt eindeutig ist und sowas.
Und bei mir hat es einfach irgendwann Klick gemacht,
dieses Ganze in einer Sprache entwickeln
und dann wird das übersetzt und so,
weil man die ganze Form halt einmal durchgeschaut hat.
Hinzu kommt ja noch, dass man beispielsweise für Xtext
das Eclipse-Plugin einfach erweitern kann,
um Refactorings und Ähnliches und Codevalidatoren,
also Warnungen und Compiler-Warnungen,
Compiler-Fehler und sowas.
Und auf einmal hat man das dann halt alles so verstanden.
Und der besondere Pluspunkt war dann,
im Studium kam das Modul Grundlagen der Programmiersprachen,
wo es genau um sowas ging.
Parser, Lexar, Compiler, Grammatik,
auch Bacchus-Nauer-Formen und sowas.
Und das wusste ich dann halt alles einfach schon.
Und das war ein cooles Erlebnis.
Ja, das glaube ich.
Vor allem, weil man dann vielleicht sogar
ein bisschen mehr über das Thema weiß als der Dozent,
der wahrscheinlich noch keine eigene Programmiersprache entwickelt hat.
Genau, das ist dann so Buch gegen Ausprobieren.
Ja, krass.
Okay, ja, also du bist quasi das lebende Beispiel dafür,
dass Azubis auch schon selber
ihre eigenen Programmiersprachen schreiben können,
was ich natürlich super cool finde.
Wie kam es überhaupt dazu,
dass du als Abschlussprojekt eine DSL entwickelst?
Ja, beim Abschlussprojekt, wie geht man da vor?
Man geht durch die Firma und fragt die Leute,
habt ihr ein Projekt, was ich als Abschlussprojekt machen könnte?
Weil man hat ja diese Restriktion, 70 Stunden und alles.
Und das muss halt dann schon realistisch sein
und zu schaffen sein.
Und ich habe dann halt die Leute gefragt,
habe Sachen gesammelt.
Und dadurch, dass wir dann halt,
also diese Routing-Sache war auch mit auf dem Plan,
nur nicht unbedingt schon als DSL,
sondern einfach das so ein bisschen vereinfachen.
Also neu entwickeln.
Und dann haben wir uns gedacht,
wir haben ja schon eine DSL im Einsatz.
Und das hat ja super gut funktioniert
mit dem Code generieren und so.
Da haben wir uns überlegt,
ob man das da nicht auch einfach machen könnte.
Und weil das sowieso das war,
womit ich mich tagtäglich beschäftige,
hat sich das natürlich sehr gut angeboten,
das auch als Abschlussprojekt zu machen.
Okay, also das ist auch so ein Tipp,
den ich ja hier immer gebe,
nichts für das Abschlussprojekt machen,
was man vorher noch nie gemacht hat.
Also du warst sowieso schon im Thema drin
und kanntest dich auch mit dem Framework schon aus, richtig?
Genau.
Aber was hat denn der Prüfungsausschuss
zu deinem Thema gesagt?
Weil das ist ja bestimmt irgendwie ein Projekt,
was man nicht so alle Tage sieht,
dass da ein Prüfling ankommt
und seine eigene Sprache entwickelt.
Fanden die das gut oder nicht so?
Ja, die haben sich gefreut,
mal was anderes zu sehen.
Ich war der Erste mit so einem Projekt,
zumindest in meinem Prüfungsausschuss.
Und ich denke zumindest,
dass das für den Prüfungsausschuss
halt auch ein ziemlich spannendes Thema ist,
sowas mal zu sehen.
Einfach, weil da halt neue Sachen sind.
Okay, also ist gut ausgegangen, auf jeden Fall.
Wie man auch auf der Website sieht,
das wurde ja wirklich sehr gut bewertet.
Also für alle, die das jetzt erst verstehen,
Markus ist derjenige,
der auch eine mit 100% bewertete Beispiel-Doku
auf der Website hat.
Also unbedingt mal angucken,
wenn man noch mehr
über domainspezifische Sprachen lernen möchte.
Wirklich eine tolle Geschichte.
Und es ist halt auch was,
was wirklich in der Firma eingesetzt wird.
Also eine richtig gute Nummer.
Aber da würde ich jetzt nochmal einmal nachfragen.
Also wie würdest du das jetzt einschätzen?
Hat sich jetzt der Aufwand für diese DSL tatsächlich gelohnt?
Also ist das jetzt in der Praxis
auch wirklich ein Mehrwert,
dass man diese DSL einsetzen kann?
Oder sagt man jetzt vielleicht rückblickend,
ach, hätte ich auch so programmieren können?
Das ist bei dem Abschlussprojekt auf jeden Fall so gewesen.
Ich musste ja auch für die IHK-Prüfung halt so Sachen
wie den Break-Even-Point berechnen,
wann sich mein Projekt denn rechnet.
Und dann haben wir uns halt hingesetzt und geguckt,
wie lange hat das gedauert,
vorher eine Anforderung umzusetzen.
Ich sage jetzt mal herauszusuchen,
warum jemand etwas bekommen hat.
Das hat, ich sage jetzt mal aus dem Kopf,
vorher sieben Minuten gedauert,
weil man halt den C-Sharp-Code
Zeile für Zeile durchgeht und sich überlegt,
okay, das war gegeben, das war gegeben,
dann gehe ich aus dem If wieder raus
und dann muss ich da und dann in die Methode und so.
Und durch die DSL ist das halt,
es steht sowieso schon da, welche Regel das war.
Also null Minuten, wenn man so möchte.
Und andere Sachen, die vorher nicht möglich waren,
wurden durch die DSL ermöglicht.
Noch ein großer Mehrwert war,
vorher konnte man das nicht so wirklich Unit testen,
weil man ja auch nicht wusste,
was hat man eigentlich so an Regeln.
Also man kann sich das wirklich vorstellen,
wie viele Methoden mit vielen Ifs.
Und da steht halt nicht im Kommentar dran,
das ist jetzt diese Regel,
weil man kommt ja auch zu der Stelle erst hin,
wenn vorher in der aufrufenden Methode
irgendwelche Ifs durchlaufen sind und sowas.
Und was wir dann gemacht haben ist,
wir haben uns einfach neben den C-Sharp Klassen
auch C-Sharp Unit Tests generiert für jede Regel,
die dann einfach das Dokument, was erwartet wird,
so füllen, wie die Regel das erfüllen würde.
Und dann könnte man halt sehen,
durch alle Unit Tests,
ob jede Regel überhaupt ansprechbar ist.
Also ob die nicht vorher ausgehebelt wird,
weil eine Regel, die darüber priorisiert ist,
eine Bedingung weniger hat,
aber sonst die gleichen.
Das ist ein super Stichwort.
Kann man eigentlich auch das ganze Zeug,
was man da selber programmiert,
um die DSL herzustellen,
kann man das auch Unit testen?
Das geht sehr gut.
Man kann die Grammatik in dem Sinne Unit testen,
dass man, also die Grammatik selber nicht,
aber halt das, was aus der Grammatik an Parser
und so generiert wird,
indem man einfach guckt,
ob ich den Text, den ich da reinschreibe,
ob ich, dass ich erwarte,
dass da bestimmte Elemente halt drin enthalten sind
und umgesetzt werden.
Der Code Generator,
mit dem ich dann den C-Sharp-Code
beispielsweise generiere,
kann ich auch sehr gut testen,
weil das sind nichts anderes als Methoden,
die Strings zurückliefern.
Also kann ich einfach einen Stringvergleich machen.
Wenn ich sowas wie ein Typsystem entwickeln muss,
kann ich das natürlich auch super testen,
weil ich erwarte,
dass Int und Double addieren kann,
aber nicht Int und String oder so,
wenn ich das so vorgebe.
Also eigentlich kann man alles darum herum sehr gut testen.
Sogar die Sachen,
die man in dem Eclipse-Plugin programmiert.
Irgendwie eine Outline
oder wenn man mit einer Maus darüber geht,
dass dann da auch noch mehr Informationen
in dem Tooltip stehen und so.
Cool, ja.
Ja, das ist mir persönlich immer sehr wichtig,
wenn man irgendwie ein Framework oder sowas benutzt,
dass man trotzdem auch immer
eine automatische Testbarkeit hat.
Ja, wie du schon sagst,
so Stringvergleiche,
das ist ja perfekt für Unit Tests.
Sehr gut. Was ist denn eigentlich aktuell dein DSL-Projekt? Hast du noch irgendwie was, wo du
gerade was entwickelst oder machst du inzwischen schon wieder was ganz anderes? Im Moment entwickle
ich einen Formelmanager, nennt sich das. Und zwar ist das so, dass die Versicherungsmathematik bei
uns für die Tarife, die war halt mehr oder weniger natural programmiert. Also da war schon so ein
Frontend, was das so ein bisschen von dem Code abstrahiert. Und das war aber alles noch auf dem
Terminal sozusagen. Also wirklich 80 Zeichen, 80 mal 24. Da musste man halt wie vor 30 Jahren dann
Formeln entwickeln. Und da haben wir uns dann gedacht, das könnte man ja mal, daraus könnte
man auch eine eigene DSL machen. Das ist so jetzt mehr oder weniger so eine Meta-Sprache, wo ich
Statements entwickle. Also das kann man sich vorstellen wie eine Methode, wo ich Parameter
reingebe. Diese Statements geben dann vor, was daraus für natural Code generiert wird. Und in
den eigentlichen Formeln benutze ich dann Statements miteinander. Also das ist eigentlich an sich schon
wie eine Programmiersprache, nur man kann damit halt nur diese Versicherungsmathematik machen.
Okay, cool. Das heißt jetzt zusätzlich zu einer Programmiersprache kommt auch noch irgendein
Versicherungsmathematischer Kram dazu. Also es wird nicht einfacher, wie ich höre. Genau.
Gibt es denn auch irgendwas so im Bereich der DSL-Entwicklung, was dir irgendwie total auf die
Nerven geht? Oder ist das Framework wirklich so gut, dass du sagst, Mensch, kann ich super
mitarbeiten? Oder gibt es da auch irgendwelche, weiß nicht, Sachen, die dich einfach bei der
täglichen Arbeit damit irgendwie nerven? Ja, so wie es bei umfangreichen Frameworks ist,
gibt es halt auch so ein paar Stolpersteine. Bei der Grammatik ist es zum Beispiel so,
dass ich nicht unbedingt alles abbilden kann, was ich möchte. Wobei das halt auch Sonderformen sind.
Ich hatte mal versucht, für natural zum Beispiel eine Grammatik zu schreiben. Ist aber nicht
möglich gewesen, weil das kontextsensitiv ist. Und ja, es gibt halt so ein paar Sachen, wo man
drüber stolpert. Was bei so einem riesen Framework für mich immer schwierig war,
ist das Updaten. Also zum Beispiel einfach mal eine Sprache auf die nächste X-Text-Version
hochziehen. Hat sich bei mir noch nie für einfach dargestellt. Ist vielleicht dem geschuldet,
dass wir so viel nicht so ans Internet angebunden sind in der Firma. Also sprich Proxy,
aus Sicherheitsgründen, dass da vielleicht nicht alles runtergeladen werden konnte. Aber das
Migrieren auf eine neue Version hieß eigentlich immer, ich mache ein neues Projekt und kopiere
die Sourcen rüber. Weil irgendwie hochziehen, lieber nicht ausprobieren.
Aber ich denke mal, es gibt irgendwie nichts, was total perfekt ist. Und klar,
bei so einem umfangreichen Framework und dann auch wahrscheinlich Abhängigkeiten zu Eclipse.
Und das ist ja auch ein Monster. Es muss ja irgendwie was auch sein, was ein bisschen
hakt. Hast du noch irgendeinen Punkt zu DSLs, über den du gerne reden würdest?
Oder haben wir so alles abgegrast, was wichtig ist zum Thema?
Ich denke, wir haben noch alles abgegrast.
Sehr gut. Das ist sehr schön. Dann kommen wir jetzt nahtlos zum nächsten Thema. Und zwar,
da du dich so gut mit den DSLs auskennst und inzwischen wirklich schon mehrere geschrieben
hast, hast du auch darüber einen Vortrag gehalten. Und zwar auf der Java Land dieses Jahr. Willst du
da mal kurz was erzählen, was du da so erzählt hast und was vielleicht so ein Feedback war,
oder wie das angekommen ist?
Ja, ich hatte meinen ersten großen Vortrag auf einer großen Konferenz, also Java Land. Ich weiß
jetzt, es waren, glaube ich, über 1000 Besucher da. Jetzt auf der Java Land, nicht bei meinem Vortrag.
Und ich war halt schon letztes Jahr auf der Java Land und da gibt es so einen Newcomer Track,
wo man halt auch als Anfänger einfach mal die Chance hat, einen Vortrag zu machen. Und da habe
ich mir gedacht, möchte ich einfach mal ausprobieren. Und ja, ich musste dann halt 45
Minuten über DSLs sprechen. Und da habe ich eigentlich so die ganze Schiene von, ich habe mir
ein Beispiel überlegt für eine DSL und dann die ganze Schiene von, was ist eine DSL, was unterscheidet
die von einer normalen Programmiersprache, also was wir auch durchgenommen haben eben. Und dann habe
ich quasi über den Vortrag hinweg eine DSL entwickelt. Und ja, die Resonanz war sehr gut. Es
waren in dem 60-Personen-Raum, ich glaube so zwischen 80 und 90 Personen. Also da standen
sogar welche, weil die meinen Vortrag sehen wollten. Das war sehr cool. Und ja, da waren
auch tatsächlich sogar Personen drin, die X-Tags selber entwickelt haben damals, also das Framework
selber entwickelt haben. Von denen habe ich auch nur positive Resonanz bekommen. Und das hat dann
die ganze Aufregung vorher wieder gut gemacht.
Ja, das glaube ich. Also würdest du sagen, hat sich gelohnt, die Zeit zu investieren und vielleicht sogar noch eine eigene DSL nur für einen Vortrag zu bauen. Das heißt, du hast am Ende auch selber was davon gehabt, ja?
Ja, auf jeden Fall. Das hat sehr viel Spaß gemacht. Ich würde es auch auf jeden Fall wieder tun.
Sehr schön. Und dieser Newcomer-Track, das funktioniert ja so, dass so Leute, die noch nie bei einer großen Konferenz präsentiert haben, auch so einen Mentor zur Seite gestellt bekommen. Wie ist das bei dir gelaufen? Wurdest du da irgendwie betreut, richtig? Oder hast du irgendwie mal so eine Probepräsentation gemacht? Oder wie kann man sich das vorstellen?
Ich habe auch einen Mentor bekommen. Da war ich sogar sehr verblüfft. Mein Mentor war der CEO einer Firma, einer von den zwei Firmen, die ganz viele X-Tags-Contributor haben und da auch Consulting und so machen. Also da war ich schon das erste Mal so ein bisschen nervös.
Und da ich aber auch schon vorher viele Vorträge gemacht habe, habe ich mit ihm eigentlich nur abgestimmt, was man denn am besten in so einem Vortrag macht, weil ich war halt diese 15 bis 20 Minuten Vorträge gewohnt und konnte mir gar nicht vorstellen, wie viel Stoff ich denn jetzt brauche, um ganze 45 Minuten zu füllen.
Und ich habe ihm dann gesagt, was ich so vorhabe an DSL und welche Themen ich abdecken möchte. Da hat er mir dann noch Tipps gegeben aus seiner Erfahrung, was ich dann auf jeden Fall noch mit reinbringen muss, weil die Leute, die noch nie was davon gehört haben, das unbedingt vorher wissen müssen und so. Und das hat ganz gut funktioniert. Ich habe aber mit meinem Mentor da keine Probepräsentation oder so gemacht, sondern bin dann ins kalte Wasser gesprungen.
Aber so von der Idee her ist es so, dass man, ich habe auch jemanden kennengelernt auf der Java Land, der hat sich mit dem Mentor dann wirklich getroffen und präsentiert und so.
Ja, übrigens, ich war in dem Vortrag auch dabei, hat sehr gut funktioniert, kann ich nur bestätigen. Das ist gut. Was wäre denn so deine Empfehlung? Also du bist jetzt noch nicht so lange aus der Ausbildung raus, aber ist das auch was für Leute, die gerade frisch eingestiegen sind oder muss man erst mal fünf Jahre gearbeitet haben, um dann irgendwie sich auf die Bühne zu trauen oder wie würdest du das so bewerten?
Ich bewerte das positiv. Also ich kann es nur weiterempfehlen. Man überlegt sich vermutlich, ob man selbst überhaupt ein Thema hat, was man vortragen kann. Aber das Publikum sind ja Entwickler und man hat bestimmt irgendwas in seinem Alltag, muss jetzt kein cooles Framework sein, aber irgendwas, was vielleicht für andere Entwickler auch interessant ist.
Und solche Vorträge sind auch immer sehr gut gesehen. Also ich gehe gerne in Vorträge, die meine Produktivität erhöhen sollen oder irgendwelche Tools dann vorschlagen zum Beispiel. Das ist einfach, also man muss nicht so das mega Hype-Thema mit ganz vielen Buzzwords im Titel haben und sich überlegen, nur um einen Vortrag auf einer Konferenz zu halten.
Ja, das stimmt. Ich habe auch auf der Java Land noch mit einem von den Organisatoren gesprochen und er meinte auch, dass bei vielen Konferenzen einfach viel zu wenig so Grundlagenthemen angeboten werden, denn es sind ja nicht alle Entwickler da draußen auf einem total hohen Niveau, die nur die neuesten Sachen lernen wollen, sondern auch so Klassiker, sage ich mal wie Unit Testing, TDD oder halt eben sowas wie DSLs so als Einführung.
Das wollen auch viele Leute da draußen haben, weil sie halt einfach gar nicht so tief in der Materie sind. Also von daher Aufruf in Richtung aller Hörer. Traut euch und tragt auch mal was vor, auch wenn es vielleicht nicht so das super aktuellste Thema ist.
Ja, sehr gut. Also kann ich nur unterstützen den Aufruf. Dann würde ich zum Abschluss vielleicht nochmal einmal fragen, wenn ich jetzt wirklich in DSLs eintauchen will und vielleicht sogar mit X-Tags. Ich habe noch gar nicht gefragt, gibt es auch noch andere Plattformen, mit denen man DSLs bauen kann oder?
Ja, grundsätzlich gibt es noch MPS von JetBrains. Das ist allerdings, habe ich selber noch nicht ausprobiert, aber was man so liest an Erfahrungen, ist halt die Lernkurve viel höher.
Weil da beispielsweise entwickelt man nicht eine textuelle Sprache, sondern das ist irgendwie so ein Projektionseditor, der das dann direkt mappt und so. Das ist halt so ein bisschen abgehobener. Aber da kann man so coole Sachen machen wie einfach eine Tabelle im Source Code für eine Entscheidungstabelle zum Beispiel.
Dann gibt es auch von JetBrains, ich weiß gar nicht wie offiziell das ist, das läuft aber unter deren Flagge. Auf deren Webseite ist es aber nicht oder noch nicht. Das nennt sich Nitra, Nitra, Nitra, weiß ich nicht.
Ist eigentlich genau das gleiche wie X-Tags, nur für das .NET Framework, dann mit Plugin für Visual Studio Integration, also auch Grammatik, Bacchus-Nauer-Form und man bekommt alles geschenkt. Aber so wie ich das bisher verstanden habe, ist es noch in der Entwicklung oder so eine Studie oder so, dass die sich das noch nicht groß auf die Fahne schreiben.
Ja, das ist ja schon mal cool, wenn man beide großen Plattformen, also JVM und .NET mit sowas abdecken könnte. Das ist ja schon mal cool. Also es gibt auf jeden Fall genug Möglichkeiten. Aber was ich jetzt eigentlich fragen wollte war, wenn ich jetzt mit DSLs einsteigen will oder vielleicht sogar konkret mit X-Tags, hast du irgendeine Empfehlung bezüglich Literatur, um da einzusteigen?
Ja, für X-Tags gibt es das nette Buch Implementing Domain-Specific Languages with X-Text und X-Tent. Da geht es eigentlich genau darum, also das Buch ist so aufgebaut, ich möchte eine Programmiersprache entwickeln. Ein Beispiel da drin ist glaube ich so ein Mini-Java, also sogar eine richtige Programmiersprache.
Und alles was da drin ist, Code Generierung, Code Vervollständigung und so, wird auch immer direkt gezeigt, wie man das Unit testen kann. Also das ist echt ein super Buch, um von vorne bis hinten so eine Sprache zu entwickeln.
Wenn man einfach mal reinschnüffeln möchte, auf X-Tags.org findet man die Dokumentation, da sind so 15 Minuten Tutorials und ich glaube das heißt 15 Minuten Tutorial Extended, wo man dann so ein bisschen mehr noch lernt. Das ist zum Einsteigen und einfach um mal zu sehen, wie das aussieht, ist das super.
Wenn man so ein bisschen Bare-Metal möchte, sage ich mal, also da gibt es dann sowas wie Antler, A-N-T-L-E-R, geschrieben. Da bekommt man den Parser und den Lexer, aber man muss halt alles andere selber machen.
Das ist so, da muss man noch ganz viel implementieren, um eigentlich wirklich eine DSL dann zu haben. Ist aber mit Sicherheit auch sehr gut, um mal zu lernen, um zu gucken, was wird mir eigentlich durch so ein Framework alles abgenommen.
Okay, ja da haben wir ja mehr als genug. Also ich kann es nur bestätigen, als jemand, der halt in der Firma arbeitet, wo die DSLs eingesetzt werden, die haben sich wirklich gelohnt und Kollegen arbeiten ja auch jetzt wirklich täglich damit und das mag sich für einen Einsteiger erstmal schwierig anhören, seine eigene Sprache zu entwickeln, aber der Benefit ist definitiv da und wir sehen es ja auch täglich bei uns, dass auch die Anforderungen wachsen.
Also wenn man erstmal auf den Geschmack gekommen ist und sieht, was da alles geht, dann kommen auch wirklich die Anforderungen sofort danach. Hier, das will ich noch und hier noch und so. Also absolut cooles Thema auf jeden Fall.
Da wir gerade bei Büchern sind, also ich persönlich bin ein absoluter Freund davon, dass man auch in Zeiten des Digitalen noch mit Büchern lernt und ich mache ja auch immer so einen riesen Buchclub mit den Azubis. Hast du noch irgendein anderes Buch, kann zu DSLs sein, aber zu irgendeinem Thema in letzter Zeit mal gelesen rund um die IT oder hast du irgendeine coole Onlinequelle, die du weiterempfehlen kannst?
Im Moment lese ich auch ein Buch zu Programmiersprachen, das ist halt voll mein Thema. Das nennt sich How to create pragmatic lightweight languages von Federico Tomasetti.
Da ist es auch so Bare Metal, also mit Antler und dann aber halt auch so coole Themen, mit denen ich mich bis jetzt noch nicht beschäftigt habe, wie generiere ich aus meiner Sprache direkt JVM Bytecode und so. Also das sind so Sachen, mit denen ich mich noch nicht beschäftigt habe, auch mit Bytecoden so generell und das wollte ich auch unbedingt mal lernen, das wäre jetzt so der nächste Schritt und das lese ich im Moment und das kann ich auf jeden Fall auch weiterempfehlen.
Krass, das kann man ja quasi in der JVM-Sprache einfach bereitstellen und nichts anderes machen. Ja, ich weiß nicht, Closure und was es dann noch so gibt auf der JVM auch, da kommt Bytecode raus und fertig, richtig?
Genau, wir haben ja noch nicht genug Sprachen.
Ja, auf jeden Fall. Jetzt wo es ja auch mit Fregel quasi Haskell auf der JVM gibt, da ist alles möglich.
Was man mit X-Tags übrigens auch machen kann oder mit jedem anderen Framework ist natürlich den nächsten JavaScript Transpiler schreiben.
Stimmt, davon gibt es auch erst 37. Ja, cool. Und letzte Frage, hast du noch so ein All-Time-Favorite-Book vor IT oder so? Also es gibt ja so coole Sachen wie, ich weiß nicht, Pragmatic Programmer oder so irgendwas .NET oder Java, ganz egal, aber irgendein Buch, wo du sagst, Mensch, das hat mich richtig weitergebracht, das kann ich jedem Programmierer, egal was er macht, irgendwie weiterempfehlen.
So ein super, alles ist, das beste Buch habe ich eigentlich nicht. Allerdings, was mir sehr gut gefallen hat zu lesen war CLR, also CLR via C-Sharp, einfach weil das auch diesen Zusammenhang halt schon erklärt hat von, in dem Fall C-Sharp und die Runtime darunter und viele Designentscheidungen der Sprache.
Also das habe ich noch gelesen, bevor ich Sprachen entwickelt habe, aber jetzt merkt man glaube ich auch so eine Tendenz dahin.
Das ist offensichtlich, ja.
Fand ich halt super spannend, wie sowas alles zusammenhängt, weil das ist so ein Tool, was dann, also die Sprache ist so ein Tool, was ich weiß nicht wie viele Millionen Leute benutzen, um ihre Arbeit durchzufühlen und was da alles hinter steckt, ist echt interessant zu lesen. Also das ist ein Buch, was auf jeden Fall vom Schreiben her und so auch sehr gut zu lesen war.
Mhm, krass. Ja, das finde ich super. Ich habe das nochmal angefangen zu lesen, aber ich habe es nicht geschafft. Aber nicht, weil es nicht gut zu lesen war, kann ich dir nur zustimmen, aber ich hatte noch irgendwas anderes, ist schon ein bisschen länger her. Aber okay, finde ich gut, super Empfehlung.
Ja, also von meiner Seite aus wären wir durch. Hast du noch irgendein Thema, was wir noch vergessen haben, wo wir unbedingt noch drüber sprechen sollen oder sind wir durch?
Ne, von meiner Seite gibt es eigentlich nichts. Es sei denn, du möchtest kurz über die Serum sprechen.
Ja, rein zufällig hast du dafür ja auch noch einen Vortrag eingereicht. Richtig, worum soll es da denn gehen?
Genau, diesmal nicht über dokumentspezifische Sprachen. Das habe ich letztes Jahr auf der Serum schon gemacht und ich glaube zumindest meinen Kollegen hängen die Vorträge darüber so mittlerweile auch zum Hals raus, weil denen muss ich das ja dann immer vorführen, um die Vorträge zu üben für die IHK und so.
Dieses Jahr habe ich einen Vortrag über Mutation Testing. Das ist eigentlich daraus entstanden, dass ich letztes Jahr auf der Java Lent ein Vortrag darüber gesehen habe und mich das einfach irgendwie von den Socken gehauen hat, dass das ziemlich cool ist.
Geht da natürlich dann auch wieder so in die Richtung Tools, aber hat mir so gut gefallen, da möchte ich jetzt selber auch einen Vortrag darüber halten, sodass ich mich da auch näher mit einarbeiten muss und auch die Technik dahinter dann wieder verstehe.
Ja, das hat ja aber auch im weitesten Sinne wieder was mit Sprachen zu tun, denn Mutation Testing, also für die, die es nicht kennen, da wird halt quasi der Code, der unter Test steht, so manipuliert, dass man Tests identifizieren kann, die eigentlich, oder anders, dass man Code identifizieren kann, der trotz Unit Tests eigentlich gar nicht getestet wird. Richtig erklärt?
Genau, was das Framework an sich dann macht, ist, das führt einmal alle Tests aus, guckt, ob die alle grün sind, weil sonst funktioniert das nicht und dann nimmt das sich jeden Test vor und verändert einfach wild Code.
Also wild ist natürlich nach einer bestimmten Struktur, aber macht zum Beispiel in dem Code, den ich teste, aus einem kleiner einen größer oder aus Return Variable macht der Return null oder schmeißt einfach mal eine Exception oder nimmt irgendwelche Methodenaufrufe raus oder so, das sind die so genannten Mutationen, also diese Veränderungen und wenn nach einer Mutation kein Test fehlschlägt, dann ist das halt ein fehlgeschlagener Mutationstest.
Weil ich möchte abdecken, dass alle meine Sachen, die ich programmiert habe, durch Tests auch abgedeckt werden und dadurch kriege ich tote Tests, also die eigentlich gar nichts testen und auch, was auch nett ist, so mehr oder weniger Regressionstests, also wenn dann mein Kollege hingeht und mal den Code anpackt und was ändert, dann kann ich mir sicher sein, dann werden Tests fehlschlagen, dann kann er in den Test gucken und hoffentlich daraus erkennen, warum das denn so programmiert wurde und so.
Und ja, ist eine super spannende Sache, ich werde mich da mal tiefer reinarbeiten und dann auf der Serum einen Vortrag halten.
Haha, sehr gut, da freue ich mich schon drauf.
Cool, ja, wenn jetzt die Leute da draußen sagen, Mensch, das hört sich super spannend an und das Buch allein reicht mir nicht, ich will auf jeden Fall nochmal mit dem Markus drüber, was auch immer, schreiben oder den irgendwie anders kontaktieren, wie findet man dich denn im Internet vielleicht?
Ja, ich habe einen Blog am suw.org, der ist, so wie ein Blog sein sollte, halt schon lange nicht mehr weitergeführt, steht auf der To-Do-List, aber, also ich habe viele Themen, worüber ich bloggen möchte, aber es ist halt durch Studium und sowas, sind die Prioritäten ein bisschen anders, aber da stehen dann auch andere Kontaktmöglichkeiten wie GitHub und so und eine E-Mail-Adresse, falls man mich mal kontaktieren möchte, genau.
Okay, klasse. Ja, den Link zur Website packen wir natürlich auf jeden Fall in die Shownotes, keine Frage und ja, ich kann nur alle da draußen aufrufen, guckt euch das Thema DSLs mal an, super spannend und wie man hier offensichtlich im Interview gehört hat, lernt man auch richtig, richtig viel über Programmiersprachen an sich und das, ja, das erstaunt mich immer wieder, dass du da richtig krass im Thema auf jeden Fall bist, finde ich richtig cool.
Ja, dann würde ich sagen, von mir aus oder von uns aus war es das dann, wir haben alles besprochen, dann sage ich vielen Dank, dass du dir die Zeit genommen hast und uns was über dein offensichtliches Herzensthema erzählt hast, war eine spannende Geschichte mit vielen coolen Inhalten und ja, vielen Dank auf jeden Fall.
Gerne.
Ja, das war mein Interview mit Markus. Ich hoffe, es war genauso spannend für dich wie für mich. Ich fand es sehr interessant, sehr viele Dinge drin, die man vielleicht auch als normaler Programmierer gar nicht so mitbekommt, denn ja, ganz ehrlich, wann setzt man sich schon mal mit Programmiersprachen in dem Sinne so weit auseinander, dass man sich anschaut, wie sie vielleicht im Hintergrund funktionieren?
Und ich finde, das ist auf jeden Fall ein sehr interessantes Thema, denn letztlich, ja, das sind ja die Werkzeuge, mit denen wir eigentlich jeden Tag arbeiten und da kann man ja eigentlich gar nicht genug drüber wissen.
Von daher, schau dir doch mal xText vielleicht an als wirklich sehr einfaches Framework zum Einstieg und aber auch sehr mächtiges Framework, mit dem man wirklich in kurzer Zeit ganz komplexe eigene Sprachen umsetzen kann.
Wirklich ein tolles Werkzeug.
Das wär's für heute. Die Shownotes mit allen Links und auch Buchempfehlungen und alles, worüber wir gesprochen haben, findest du, wie immer, unter anwendungsentwicklerpodcast.de slash 107 für die heutige 107. Episode.
Schau doch mal vorbei und schreib uns gerne einen Kommentar. Auch Markus freut sich sicherlich über Feedback.
Und damit sag ich für heute vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss!
Untertitel im Auftrag des ZDF für funk, 2017












Neueste Kommentare