diff --git a/2024/program.html b/2024/program.html index b05d084..3e29d1f 100644 --- a/2024/program.html +++ b/2024/program.html @@ -2,7 +2,7 @@ - Langdev 2024 - Program + Langdev 2024 — Program

Program

-

Preliminary Schedule

- - - +

Draft Schedule

+
Thursday, October 17
+ + - + + + + + + + - + + - - + + + + - + - - + + + + - - + + + + - - + + + + - + - + + + + - - - - + + + + - - + + + + - - + + + + - + - + + + + - - + + + + - + - - + - - + + + + + + + + + + + + + + + + + + + -
Thursday, October 17
8:30RegistrationRegistration
Track 1. Salon de GradosTrack 2. Room A2.12
9:00 Welcome
9:30 - OPENNING KEYNOTE
- Model Based Software Engineering in Space Missions + OPENNING KEYNOTE
+ Model Based Software Engineering in Space Missions 		Marcel Verhoef, PhD. - ESAMarcel Verhoef — ESA
10:00Slot 2to be announced + + Transitioning to MBSE in Space Projects at GMV: Insights, + Challenges and Lessons Learned + Elena Alaña — GMV + + Mutation testing for Domain-Specific Languages: the case of + task-oriented chatbots + + Pablo Gómez-Abajo — UAM
10:30Coffee breakCoffee break
11:00Slot 3to be announced + + Application of modeling techniques for on-board satellite + applications + + Óscar R. Polo & Pablo Parra — UAH + Langium + AI: Building AI Applications for DSLs + Benjamin Wilson — Typefox
11:30Slot 4to be announced + Feature Models with dimensions in Space Missions + Pedro J. Molina — Metadev + + Legacy Code Transformation with AI: Translating PL/I to Kotlin + Using Seq2Seq Transformers + + Gian Cunningham — Heirloom Computing
12:00Slot 5to be announced + + A SysML-based Framework for Analyzing Security and Safety + Properties Applied on an Aerospace Data Link Uplink Feed System + + Deni Raco — RWTH Aachen + An ANTLR-based Hardware Description Language (HDL) to elevate + the abstraction level in hardware design + Luca de Santis — Micron Technology Italia
12:30Lunch + Towards Iterative and Low-code DSL Development + Benoit Combemale — U. of Rennes + + Idea Flowing Language — a graphical domain specific + language for web games + Sebastian Blume — U. of Desden
14:00Slot 6to be announced
13:00Lunch
14:30Slot 7to be announced + Cinco Cloud — Live Metamodeling of Graphical DSLs + Daniel S. Mitwalli & Daniel Busch + + PolyDebug: An Extensible and Language-Agnostic Architecture for + Polyglot Debugging + Benoit Combemale — U. of Rennes
15:00Slot 8to be announced + Building AI-based assistants for DSLs with ModelMate + Jesús Sánchez — U. of Murcia + + Jabuti CE: A Tool for Specifying Smart Contracts in the Domain + of Enterprise Application Integration + Mailson T. Borges — Unijui U.
15:30Coffee break + Enriching Models with Extra-Functional Information + Sebastian Stüber — RWTH Aachen + + Open Science principles in software product lines: The case of + the UVL ecosystem + David Romero — U. of Seville
16:00Slot 9to be announced + Introducing Rustemo: A LR/GLR Parser Generator for Rust + Igor Dejanović — U. of Novi Sad + + Improving the Observability & Security of Kubernetes with + MDE + + + Javier Centeno & Pedro J. Molina — Metadev +
16:30Slot 10to be announcedCoffee break
17:00Slot 11to be announced + Introducing Typir for Type Checking in the Web + Johannes Meier — TypefoxBuilding applications with spreadsheetsJesús Sánchez — U. of Murcia
17:30 + Common modeling mistakes and the necessity of declarative + modeling + Wim Bast — Modeling Value GrouparKItect graphical DSL workbenchAndrei Samokish — Knowdelge Inside
18:00 + Language Engineering for Language Migrations + Federico Tomassetti — Strumenta + + + +
- +
@@ -150,20 +289,37 @@

Preliminary Schedule

+ + + + - - + + - - + + - - + + @@ -171,65 +327,104 @@

Preliminary Schedule

- - + + - - + + - - + + - + - + + - - - - + + + - - + + - - + + - + - + + - - + + - + - - + - + + + + + + + + + + +
Friday, October 18
8:30 Registration
Track 1. Salon de Grados
9:00Slot 1to be announced + The Arazzo Specification: Unlocking Value for Humans and + Machines + Frank Kilcommins — Smartbear
9:30Slot 2to be announced + Collaborative Modeling capabilities in Orca with CRDTs + Pedro J. Molina — Metadev
10:00Slot 3to be announced + GenFPL: DSL-embeddable functional programming languages + Meinte Boersma — DSL Consulting
10:30
11:00Slot 4to be announcedLionWeb: Status Update + Jos Warmer — Open Modeling & Nico Stotz — F1re +
11:30Slot 5to be announcedLionWeb and Kolasu: an integration storyAlessio Stalla — Strumenta
12:00Slot 6to be announcedImplementing LionWeb in RascalUlyana Tikhonova — F1re
12:30Lunch + A Case Study: Execution of LionWeb nodes in Truffle Language + Framework + Erkan Diken — F1re
14:00Slot 7to be announced
13:00Lunch
14:30Slot 8to be announced + Bringing Notebook Experiences to modern IDEs + Mark Sujew — Typefox
15:00Slot 9to be announced + Seamless Interpreter Integration for Compositional Modeling + Languages + + Nico Jansen & Bernhard Rumpe — RWTH Aachen +
15:30Coffee break + Empowering Language Reuse with Low-Code Language Composition + Jérôme Pfeiffer — U. of Stuttgart
16:00Slot 10to be announced + + Augmenting graphical modeling workbenches with semantic-aware + interactive features + Théo Giraudet — Obeo
16:30Slot 11to be announcedCoffee break
17:00Closing + Current Developments in Tooling and Editor Support in textX + Milan Sovic — U. of Novi Sad
17:30A build tool for modular MPS projectsArjan Oortgiese — Belastingdienst
18:00Closing session
- +
- + -
Saturday, October 19Saturday, October 19
+

Session Details

+
+
+
+ Model Based Software Engineering in Space Missions +
+
+ Marcel Verhoef — European Space Agency +
+
TBD
+
+
+
+ + Transitioning to MBSE in Space Projects at GMV: Insights, + Challenges and Lessons Learned +
+
+ Elena Alaña Salazar & Sergi Company Aguilar — GMV +
+
+

+ Model-Based Systems Engineering (MBSE) has significantly + impacted the space industry, being the European Space Agency + (ESA) a key actor of the adoption of these technologies. MBSE is + a practice digitalising systems engineering, and the goal is to + apply it in all phases of a project, ranging from Phase 0 / + pre-Phase A (concept development) to Phase F (closeout). The + transitioning from a traditional approach to MBSE presents + several challenges, specially for big corporations trying to + change their well-established procedures. +

+

+ GMV's practical case is studied in this presentation, looking + back at the goals set when MBSE was initially incorporated, + where the company is at the current time, and what are the + future prospects. A timeline outlining key activities performed + in the past and next steps in the near future is provided. + Moreover, an overview of current projects where MBSE is at the + centre is presented, engaging discussion on the challenges + specific to the application of MBSE in space projects involving + large teams. Topics including requirements management, document + generation automation and reusability between projects are put + on the spotlight of the discussion. +

+
+
+
+
+ + Application of modeling techniques for on-board satellite + applications +
+
+ Óscar R. Polo & Pablo Parra — Universidad de Alcalá de + Henares +
+
+

+ The development of on-board satellite software faces numerous + challenges and demanding deadlines due to the complexity and + critical nature of space missions. Validation and verification + (V&V) are crucial to the development process, as they + provide evidence for non-functional requirements and ensure + compliance with quality standards such as the European Space + Agency's ECSS-E-40. Another major challenge is the use of + various configured deployment platforms and the need for + adaptation to hardware evolutions during the engineering + process. +

+

+ The Space Research Group of the University of Alcalá has + successfully participated in multiple space missions, such as + the development of the on-board software for the instrument + control unit of the Energetic Particle Detector of Solar Orbiter + and the INTA's Nanosat missions. To carry out these activities, + we have used an approach that incorporates solutions based on + domain-specific languages and component-based software + engineering, which have significantly streamlined the + development process, enhancing efficiency and ensuring that our + developments are compliant with established standards. +

+

+ In this presentation, we will share case studies of our + model-based approach, which include the integration of tools for + the verification of temporal constraints and configuration + management, automatic code generation, and the integration of + low-code tools for validation tests. +

+
+
+
+
+ Feature Models with dimensions in Space Missions +
+
Pedro J. Molina — Metadev
+
+

+ Feature Models are powerful abstractions used to decompose in + components, configure Space Missions and double check + constraints are enforced in design & validation time. +

+

+ In this talk we will describe our vision to trace requirements + to Feature Models enhanced with physical dimensions + (constraints). And how each component or feature can be used as + the source abstraction to derive the SW concepts for embarked + components and, at the same time, the virtual representation on + a Digital Twin for the Ground Segment, that can be used both for + simulation and for operation & real telemetry in mission + time. +

+

+ This approach provides a cohesive way to introduce models as the + key driver of a Space Mission with impact in design, prototype, + validation, embarked components and ground segments for tracking + and operation. +

+
+
+
+
+ + A SysML-based Framework for Analyzing Security and Safety + Properties Applied on an Aerospace Data Link Uplink Feed + System +
+
Deni Raco — RWTH Aachen University
+
+

The MontiBelle Framework consists in:

+
    +
  1. a SysMLv2 profile and a parser,
    2. +
  2. + using the mathematical formalism FOCUS as semantical backend + for distributed systems, which provides compositionality of + refinement, +
    3. +
  3. + a modular development methodology based on the + SPES-methodology, +
    4. +
  4. an encoding of FOCUS in the theorem prover Isabelle,
    5. +
  5. + a code Generator from SysMLv2 into the FOCUS encodings in + Isabelle, generating speficitations and proofs, +
    6. +
  6. + a formal IDE, enabling modeling, navigation, visualization, + interactions with the formal backend, and highly automated + formal verification. +
    7. +
+

+ Demo Outline: An aerospace case study about a data link upload + feed system used e.g. for the communication between a satellite + and a ground station is formally developed and accompanied by + verification. During the decomposition and refinement steps, 26 + formal properties were proven by the MontiBelle tool. The formal + IDE, SysML v2 the Isabelle specifications and the refinement + proofs are featured in the Demo. +

+
+
+
+
+ Towards Iterative and Low-code DSL Development +
+
+ Benoit Combemale — University of Rennes, IRISA & ESIR +
+
+

+ Identifying the best abstractions to integrate into a + Domain-Specific Language (DSL) is typically a continuous and + iterative process. In practice, it is often the result of usage + of a more generic DSL and the identification over time of + recurring patterns to be abstracted and integrated in a more + specific DSL. While collaboration between domain experts and + language engineers is essential to initiate the development of a + DSL and its associated tools, in many contexts it is impractical + to keep the language engineers continuously involved for ongoing + iterations. Therefore, it becomes crucial for domain experts to + be able to independently and incrementally refine their DSL and + its tooling. However, current Software Language Engineering + (SLE) tools and methods (e.g., language workbenches) demand + extensive expertise in language engineering, which domain + experts often lack. +

+

+ In this talk, we present a novel approach enabling domain + experts to iteratively specialise their own DSLs and associated + tooling. Our approach integrates several techniques, including + language slicing for immediate and opportunistic reuse, as well + as the promotion of language constructs into the metalanguage to + facilitate the definition of new constructs. We demonstrate the + relevance of our approach through a case study in the security + domain, that we use to identify and to discuss the challenges + associated with achieving this vision. +

+
+
+
+
+ + Cinco Cloud — Live Metamodeling of Graphical DSLs + +
+
+ Daniel S. Mitwalli, Daniel Busch, Alexander Bainczyk, Marco + Krumrey, & Jonas Schürmann +
+
+

+ Cinco Cloud introduces a holistic web-based environment that + enables language engineers to metamodel graphical + domain-specific languages and domain experts to use these + languages within corresponding integrated modeling environments. + We now present the advanced approach of live metamodeling, which + seamlessly blends the transition between language engineering + and the use of a graphical DSL within a single environment. +

+

+ Changes to the metamodel of a graphical DSL are immediately + reflected in the graphical editor of the language being used, + including the syntax and semantics of a language. The + presentation illustrates the functionality of live metamodeling + within Cinco Cloud with a concrete application example. +

+
+
+
+
+ + Building AI-based assistants for DSLs with ModelMate + +
+
Jesús Sánchez — University of Murcia
+
+

+ The availability of AI features to enhance developer + productivity is now the norm in programming IDEs. However, DSL + environments cannot keep the pace and by default do not have + such smart editing facilities. A key reason for this is that the + scope of a DSL is typically small, which means that it is + expected to have available only few training examples, but also + that the amount of time available to develop an AI assistant is + also limited. +

+

+ This talk presents ModelMate, a system to build AI assistants + for DSLs based on fine-tuning pre-trained language models. In + this talk we will discuss which editing and assistance tasks are + supported by ModelMate, the steps involved in building an + assistant for a specific DSL depending on whether it is textual + or graphical and how ModelMate works in practice. We will also + perform a short demonstration with some examples of assistants + that we have built (e.g., for Emfatic and Xtext) and report some + performance figures. ModelMate is available at + Github: models-lab/model-mate. +

+
+
+
+
+ + Enriching Models with Extra-Functional Information + +
+
+ Sebastian Stüber — RWTH Aachen University +
+
+

+ We explore systematic techniques to enrich models with + additional information while preserving their standard and + functionality. This opens up possibilities for new + functionalities, such as sophisticated analysis and generator + configurations. Employing a systematic approach, our methods are + universally applicable, regardless of the specific modeling + language. Three approaches will be compared: +

+
    +
  1. Stereotypes to add information within the model,
    2. +
  2. + Tagging, as a generic approach to add information in separate + file, and +
    3. +
  3. + use-case specific language, which references the original + model. We will evaluate and compare the approaches from both + the domain-expert and the tool-developer point of view. +
    4. +
+ +

+ Multiple examples demonstrate the applicability of the + approaches. These examples consist of an effect-analysis for + component and connector models, adding sustainability + information to models, and a fine-grained code-generator + configuration. The demonstrations will use the MontiCore + language workbench. +

+
+
+
+
+ + Introducing Rustemo: A LR/GLR Parser Generator for Rust + +
+
+ Igor Dejanović — University of Novi Sad +
+
+

+ In this talk, we introduce + Rustemo, + a new open-source and free parser generator for Rust that + supports deterministic LR (with various flavors of LALR) and + generalized LR based on the Right-Nulled GLR algorithm (RNGLR). +

+

+ Rustemo features a clean separation between its core components: + lexers, parsers, and builders. Lexers break an input sequence + into tokens. Parsers perform syntax analysis on the tokens + recognized by the lexer, while builders are responsible for + producing the final output. By selecting or writing an + appropriate lexer, different inputs can be parsed. Additionally, + by choosing or writing an appropriate builder, one can obtain an + auto-generated and manually tuned abstract syntax tree, a + concrete syntax tree, or another structure at the end of the + parsing process. For the default builder, AST types and actions + are deduced from the grammar, allowing users to change them + while preserving the modifications in subsequent round-trip + generations. +

+

+ Although still a relatively young project, Rustemo implements a + notable set of features[1], is fully + documented, + and has good test coverage. +

+

+ Following a short introduction, the typical workflow for using + Rustemo will be demonstrated through a live demo of building a + parser for a simple language. The code and instructions for the + demo will be available on the project site and Git repository. +

+
+
+
+
+ Introducing Typir for Type Checking in the Web +
+
Johannes Meier — Typefox
+
+

+ Type systems are crucial parts of developing languages. Among + others, types systems are needed for checking static semantics + like validating assignability, resolving cross-references to + type-dependent targets like overloaded functions, and generating + source code for statically typed languages like translating DSLs + to TypeScript. +

+

+ Developing type systems for languages faces several recurring + challenges, including similar kinds of types like primitives, + classes, and functions, recursive type definitions, performance + optimizations, and providing meaningful error messages for users + of the language. +

+

+ Due to the rise of software running in the web including + programming languages and DSLs, Typir is introduced as the new + open-source framework for type checking in the web. Implemented + in TypeScript, Typir supports textual languages developed in the + web stack, and can be applied to other model sources as well. + Typir is designed to be more pragmatic than formal, e.g. no rule + engine is used, but provides solutions for recurring type + checking challenges. +

+

+ After motivating challenges when developing type systems from + scratch, this talk shows the design of Typir and applies Typir + to concrete example languages. This presentation aims to discuss + with the language engineering community needs for web-based type + checking, to collect early feedback and to identify additional + integration scenarios for Typir. +

+
+
+
+
+ Language Engineering for Language Migrations +
+
Federico Tomassetti — Strumenta
+
+

+ Migrating from one programming language to another is a complex, + expensive, and valuable challenge. Techniques from the Language + Engineering community can address this issue. +

+

+ We present the current version of our solution, drawing on our + experience with large-scale migrations across various domains. +

+

+ We will discuss the numerous challenges we have encountered and + those that lie ahead, including performing symbol resolution at + scale, identifying code clones, eliminating dead code, and + recognizing recurring patterns with the intent of supporting + idiomatic translations. Finally, we will demonstrate how LionWeb + has enabled us to develop a multi-platform solution for + operating on models. +

+
+
+
+
+ Common modeling mistakes and the necessity of declarative + modeling +
+
Wim Bast — Modeling Value Group
+
+

+ The author will speak about his observations in his extensive + journey of realizing DSLs in different domains. He will share + his thoughts about common mistakes made in modeling of, and + thinking about the domain. Most notably the pitfalls of + imperative or procedural thinking. He will address the notions + of 'minimal complexity' and 'avoiding over-specification'. From + there he will argue the necessity of complete declarative + modeling. At the end he will address the requirements for + declarative modeling languages and some open challenges. + Positive and negative examples will be shown and demonstrated. A + dialogue with the audience is welcome during the presentation. +

+
+
+
+
+ Mutation testing for Domain-Specific Languages: the case of + task-oriented chatbots +
+
+ Pablo Gómez-Abajo — Universidad Autónoma de Madrid +
+
+

+ Mutation testing is a well-known technique for assessing the + quality of software test suites. It involves introducing + artificial faults into the source code, which generates a set of + source variations called mutants. Next, we can apply the test + suites to such mutants to account for how many of these mutants + are detected, i.e., how many of them are killed. This measure + yields a metric of the quality of the test suites called + mutation score. +

+

+ Creating ad-hoc mutation testing tools from scratch is costly + and error-prone, making difficult its application to + Domain-Specific Languages (DSLs). To alleviate such + inconveniences, the Miso group built a domain-agnostic tool to + engineer language-specific mutation testing tools called + Wodel-Test. Using Wodel-Test, we have successfully generated + mutation testing tools for both DSLs and general-purpose + languages like finite automata, Java, ATL, and task-oriented + chatbots. +

+

+ In this presentation, we will showcase Wodel-Test for chatbots. + The latter are defined using a DSL called Conga, which can + generate code for chatbot platforms like Dialogflow and Rasa. We + will demonstrate all steps in developing the testing solution + and its use in analysing chatbots and their test suites. +

+
+
+
+
+ Langium + AI: Building AI Applications for DSLs +
+
Benjamin Wilson — Typefox
+
+

+ Delivering AI applications that understand custom DSLs is a + challenge. Even state-of-the-art models have trouble recognizing + and generating syntax for novel DSLs. Good prompting, retrieval + augmented generation, and fine-tuning can help to correct this, + but it's a time-intensive task, and you may not get the results + you want in the end. For Langium-based DSLs, we've had the same + problem, and so we would like to present Langium-AI as a + solution. +

+

+ Langium-AI is a proposed extension to the Langium engineering + framework to support developing AI applications for DSLs in + parallel with your DSL itself. We'll demonstrate how this + approach works by deeply integrating the design process with the + existing Langium workflow, resulting in consistent & testable + results throughout the development process. We'll also walk + through a concrete example of such an AI application being + developed for a fresh DSL. +

+
+
+
+
+ + Legacy Code Transformation with AI: Translating PL/I to Kotlin + Using Seq2Seq Transformers +
+
Gian Cunningham — Heirloom Computing
+
+

+ In my talk, I will explore the application of language + engineering by showcasing an + article + I have written based off of the following + Strumenta article, where I develop a sequence-to-sequence (Seq2Seq) Transformer + model with PyTorch to translate and transpile legacy PL/I code + into modern Kotlin. +

+

+ This notebook involved constructing a custom Transformer model + that uses advanced techniques, facilitating effective + sequence-to-sequence tasks like language translation. A dataset + is prepared by tokenizing ( the process of converting text into + smaller units called tokens, which can be words, subwords, or + characters, for easier analysis and processing) PL/I and Kotlin + code, building vocabularies, and creating training and test + splits. The training process then employed various techniques to + optimize model performance. The translation process was enhanced + by integrating ANTLR4 for parsing PL/I code and using Jinja2 for + code generation, ensuring a smooth transition from legacy to + modern codebases. +

+

+ The results demonstrate the practical applicability of AI in + language engineering, showcasing how neural networks can + transform outdated code into contemporary solutions. +

+
+
+ +
+
+ + Idea Flowing Language — a graphical domain specific + language for web games + +
+
+ Sebastian Blume — University of Desden +
+
+

+ Game experts are not necessarily programmers. Game experts are + able to design games. The problem is that there are mostly + designing languages which are only simulating games. Languages + for developing games are not just requiring programming skills + but they do not support design processes. +

+

+ The solution is Idea Flowing Language. IFL is a graphical domain + specific language which allows designing and developing games at + the same time. In other terms said when the expert designs a + game by a model of IFL it is not needed to design a controller + or a view for it at once; even without having this it is already + possible to just test and play the game at the model. Because of + this capsulation possibility for the game logic and the game + layout MVC can be fulfilled in the context of domain specific + languages. +

+

+ Basically, this all can be fulfilled since IFL is a mash between + petri nets in a high level, behavior trees and Harel state + machines. Idea flowing language is currently designed for little + games like dice games. In the future apps with a lot of + interaction should be possible. By a lot of data processing and + instances vector engines could be applied. +

+
+
+
+
+ + PolyDebug: An Extensible and Language-Agnostic Architecture for + Polyglot Debugging + +
+
+ Benoit Combemale — University of Rennes, IRISA & ESIR +
+
+

+ As software grows increasingly complex, the number and diversity + of concerns to be addressed also rises. To answer this diversity + of concerns, developers may end up using multiple, possibly + domain-specific, languages in a single software project, a + practice known as polyglot programming. This practice has gained + momentum with the rise of execution platforms capable of + supporting polyglot systems (e.g., GraalVM, possibly with + Truffle for DSLs). However, despite this momentum, there is a + notable lack of design-time support for developers working on + polyglot programs, such as in debugging facilities. +

+

+ This talk addresses this gap by introducing a novel debugger + architecture that is language-agnostic yet leverages existing + language-specific debuggers. The proposed architecture is + dynamically extensible to accommodate the evolving combination + of languages used in polyglot software development. It utilizes + the Debug Adapter Protocol (DAP) to integrate and coordinate + existing debuggers within a debugging session. The effectiveness + of this approach is demoed with a prototype, PolyDebug, and its + application to use cases involving C, JavaScript, and Python. +

+

This session includes a prototype & demo.

+
+
+
+
+ + Jabuti CE: A Tool for Specifying Smart Contracts in the Domain + of Enterprise Application Integration + +
+
+ Mailson Teles-Borges, Eldair F. Dornelles, Sandro Sawicki, + Fabricia Roos-Frantz, Rafael Z. Frantz — Unijui University, + Jose Bocanegra — Universidad de los Andes, Antonia M. + Reina-Quintero - University of Seville, & Carlos + Molina-Jimenez — University of Cambridge +
+
+

+ Some decentralised applications (such as blockchains) take + advantage of the services that smart contracts provide. + Currently, each blockchain platform is tightly coupled to a + particular contract language; for example, Ethereum supports + Serpent and Solidity, while Hyperledger prefers Go. +

+

+ To ease contract reuse, contracts can be specified in + platform-independent languages and automatically translated into + the languages of the target platforms. With this approach, the + task is reduced to the specification of the contract in the + language statements. This can be tedious and error-prone unless + the language is accompanied by supportive tools. +

+

+ We present Jabuti CE, a model-driven tool that assists users of + Jabuti DSL in specifying platform-independent contracts for + Enterprise Application Integration. We have implemented Jabuti + CE as an extension for Visual Studio Code. +

+
+
+
+
+ + Open Science principles in software product lines: The case of + the UVL ecosystem + +
+
+ David Romero, José Ángel Galindo, Bhushan Megha, José Miguel + Horcas, & David F. Benavides — University of Seville +
+
+

+ Feature models are essential for modelling variabilities in + software product lines, which often reside in private or + dispersed repositories. The Universal Variability Language (UVL) + addresses this issue by standardising the serialisation of + feature models and promoting community-driven sharing. +

+

+ Open science aims to make scientific research and data + accessible to all. Its principles are based on transparency, + accessibility and collaboration. This approach can be applied to + the software product line community using a specific set of + tools: +

+
    +
  1. uvlhub to share datasets of feature models,
    2. +
  2. + flamapy to enrich and extract metrics from these models, and +
    3. +
  3. + FM Fact Label to visualise features from feature model data. +
    4. +
+

+ We identify the missing characteristics that feature modelling + practitioners need in current open science tools. +

+

+ Through hands-on sessions, participants will gain practical + experience in using uvlhub to host datasets, flamapy to analyse + them, and FM Fact Label to visualise them. This will not only + demonstrate the integration of these tools into their research + workflows but also show how their work can align with open + science principles. +

+
+
+
+
+ + Improving the Observability & Security of Kubernetes with + MDE + +
+
+ Javier Centeno & Pedro J. Molina — Metadev +
+
+

+ The Enterprise computing is moving steadily to containers and + using orchestration tools with different flavors of the same + ground: Kubernetes. +

+

+ Kubernetes is capable of managing many machines (physical or + virtual) to deploy containers in a distributed manner in a way + we can provide high-availability, flexible load balancing, and + fast provisioning. Mid and large-sized enterprises run hundreds + of containers inside such Kubernetes clusters. Therefore the + need for Observability and Security checking the graph of nodes, + applications, services, instances & dependencies is a real need + at scale. +

+

+ Traditional tools in the Kubernetes landscape are governed by + textual tools: YAML. There is space for building better + graphical tools to represent and visualize the current state of + a cluster (linked with real-time telemetry) showing + dependencies, failing components, security risk, etc. The model + discovery process makes a reverse engineering task to discover + services, pods, containers, networks and its topology. At the + model level a visualization is provided (Digital Twin) as a + virtual representation of the physical assets to be observed + & monitored. +

+
+
+
+
+ Building applications with spreadsheets +
+
Jesús Sánchez — Universiy of Murcia
+
+

+ Spreadsheets are the most widely used programming system, + notably used by non-technical users who are not familiar with + general purpose languages (GPLs). From the point of view of the + “programming experience”, the main characteristic of a + spreadsheet is that the user writes formulas (i.e., business + logic) which directly manipulates values, in contrast to the use + of abstract expressions in GPLs. In this respect, some low-code + platforms (e.g., AppSheets) have attempted to use the idea of + spreadsheets to facilitate its adoption by end-users, but they + do not fully exploit the flexibility of spreadsheets. In this + context, we are developing a type of low code platform designed + around the spreadsheet metaphor, based on direct manipulation of + concrete values, plus an application building environment based + on live programming techniques. +

+

+ The goal of this platform is to enable end-users construct + simple applications, tailored to their needs by simply using + well-known concepts from spreadsheets. In this talk we will + present the goals of the project, named LowSheets, some + motivating examples, the architecture of the platform and + showcase the platform though a demo. +

+
+
+
+
+ arKItect graphical DSL workbench +
+
+ Andrei Samokish & Samuel Boutin — Knowdelge Inside +
+
+

+ arKItect workbench, edited by Knowledge Inside, has a consistent + track record of customer applications in automotive, railways + signaling, energy spatial, finance, and construction domains, + e.g. Hitachi rail STS has been using it for SADT modeling as + support to safety analysis of SIL4 systems since 2013 or Renault + electrical vehicle MBSE started to be modeled in arKItect in + 2011. +

+

+ arKItect key features that make it unique on the market are: +

+
    +
  • + Simplified and much more intuitive metamodel, w.r.t Eclipse + EMF/GMF metamodel or similar Object-Oriented workbenches. +
    • +
  • + Interpreted; your changes in the data model are available + immediately without compiling. +
    • +
  • low-code.
    • +
  • + Intuitive because just need the concept of sets to understand + a data model. +
    • +
  • Usable by non-developers.
    • +
  • Fully scriptable in Python.
    • +
  • Multi-user and collaborative.
    • +
  • + Generative views. A change anywhere is replicated + automatically in every viewpoint where it is filtered. +
    • +
  • + 2D views, providing the potential of including 2D/3D design in + combination with functional modeling. +
    • +
  • Support for big models (100 000 objects).
    • +
  • Import / Export capabilities through Python.
    • +
  • + Providing advanced features for user administration and + configuration management, including Options, Variants, and + Phases. +
    • +
+

+ A demo will be delivered building a data model and a model from + scratch showing most of the features. +

+
+
+
+
+ An ANTLR-based Hardware Description Language (HDL) to elevate + the abstraction level in hardware design +
+
+ Luca de Santis — Micron Technology Italia +
+
+

+ Today's digital hardware systems are a blend of heterogeneous + subsystems, including general-purpose processors, customized + processors, complex state-machines and dedicated hardware + accelerators. This complexity challenges the description, + synthesis, and programming of these architectures, highlighting + the need for increased levels of abstraction. The current trend + involves integrating higher-level software concepts into + hardware design, which can be uncomfortable for hardware + engineers. +

+

+ This proposal suggests a language that aims to elevate the + abstraction level in digital system representation while + preserving critical aspects of hardware engineering, such as + synchronization, communication, customized programming, and + optimization for power, area, and speed. It introduces a + hardware description language based on domain-specific language + methodology (ANTLR), demonstrating how hardware and software + domains can coexist by creating appropriate syntactical + structures aligned with the underlying hardware model. +

+
+
+
+
+ The Arazzo Specification: Unlocking Value for Humans and + Machines +
+
Frank Kilcommins — Smartbear
+
+

+ Introducing the Arazzo Specification which enables the ability + to define and document workflows, a series of API calls, that + when woven together accomplish a specific business objective. + The new specification was developed under the OpenAPI + Initiative, and complements current specifications, including + OpenAPI and AsyncAPI. +

+

+ Arazzo provides a deterministic recipe for using APIs and + enables code generation tooling for a given API based on + use-cases. Additionally, Arazzo improves regulatory checks and + bridges gaps where use-case flows span multiple API + descriptions. The new specification provides a sufficient level + of predictable determinism to AI models, allowing them to offer + a natural language abstraction on top of the business use cases, + while in parallel giving interoperability benefits to the actual + API providers. The result is more value, with less vendor + lock-in, and consistent API offerings for both humans and the + new wave of AI consumers. +

+

+ In general, there's enormous potential to enhance the developer + experience (DX) and API documentation by enabling graphical + rendering of API workflows. The specification also improves + human understanding of how to consume API endpoints to achieve a + specific goal. Arazzo descriptions can stay up-to-date and be + assertable against the underlying APIs. This reduces the need + for out-of-band documentation sharing, reduces the time and + effort required to implement complex workflows, and automates + testing and other repetitive tasks. +

+

+ Overall, the Arazzo Specification improves the capability of API + specifications to tell the story of the API in a manner that + improves interoperability across industries. +

+
+
+
+
+ Collaborative Modeling capabilities in Orca with CRDTs +
+
+ Matthew Weidner, Javier Centeno, & Pedro J. Molina — + Metadev +
+
+

+ Concurrent Collaboration is a feature gaining momentum for SaaS + tools. Tools like Google Suite, Office 365 or Figma have + popularized it in the last few years. Remote work has been a key + driver for the adoption of Concurrent Collaboration. On the + other hand, CRDTs (Conflict-Free Replicated Data Types) are a + powerful abstraction able to allow concurrent and offline + editing and simpler reconciliation (deferred merges at a later + time). +

+ +

+ In this session, we will present how we enhanced + Orca (a no-code tool for + container orchestration) and + Daga (a diagramming + library for models) to support Concurrent Collaboration using + CRDTs in the modeling tool. The strategies followed, + considerations about usability, pros & cons and lessons + learned will be shared. +

+
+
+
+
+ GenFPL: DSL-embeddable functional programming languages +
+
Meinte Boersma — DSL Consulting
+
+

+ Many DSLs end up having expressions, ranging from relatively + simple logic and/or arithmetic, to more intricate, query-like + collection and object traversals. More often than not, such a + “funclarative” expression sublanguage is built from scratch — + which is fun but also costly. +

+

+ GenFPL is a new tool to generate a ready-to-run Functional + Programming-style Language (FPL) to easily embed in existing + DSLs — provided they can be defined using LionWeb. It's inspired + by KernelF for JetBrains MPS, while aiming to be portable and as + technology-independent as possible. It does so by generating a + coherent family of extensible languages from a simple + configuration. +

+

+ In this talk, Meinte will demonstrate how GenFPL is used to + implement a FPL and integrate it in an existing DSL. He will + also touch on implementing and running an interpreter in + TypeScript, defining a concrete syntax using Freon, integrating + on the type (system)-level, and introducing a standard library. + Finally, the author will discuss some design trade-offs around + (not) providing functional abstractions. +

+
+
+
+
+ LionWeb: Status Update +
+
+ Jos Warmer — Open Modeling & Nico Stotz — F1re +
+
+

+ At last year's LangDev we introduced + LionWeb: Language Interfaces on the Web. Since then LionWeb has + developed quite a lot. We expect to release a new version 2024.1 + including a number of new features. The existing parts of the + specification have been sharpened, but most importantly this + LionWeb release includes the first part of the server protocol. + This part is the "bulk" protocol, as it focuses on retrieving + and storing (sub)trees of nodes. This protocol is not defined + simply as dumb storage for model trees, but also defines + validation requirements to ensure that the model tree always + remains correct in relation to the LionWeb specification. As + always, we don't just write specifications, but also implement + them in parallel. To validate the bulk specification we + therefore developed a lionweb-repository, acting as a reference + implementation of the bulk protocol. Also new are several + implementations in more programming languages and test suites to + ensure that different implementations conform to the + specification. +

+

+ At this moment we are working on the next aspect of the server: + the "delta" protocol. This will enable software components to + subscribe to model changes in the server and allow sending and + receiving changes to nodes. We will end with naming several + development projects using LionWeb in real life. +

+

+ You can follow the work on + github. +

+

+
+
+
+
+ LionWeb and Kolasu: an integration story +
+
Alessio Stalla — Strumenta
+
+

+ LionWeb is an open effort for language-oriented modeling tools + on the web, including specifications, reference implementations + in multiple languages, and accompanying software. Kolasu is + Strumenta's Kotlin/JVM library for defining, traversing, + translating, exporting ASTs (abstract syntax trees) and more. + It’s part of our family of libraries for different platforms + supporting our StarLasu methodology for building + language-oriented tools. We present our motivations, the design + decisions we took, the lessons that we learned and the + challenges we faced extending Kolasu with support for LionWeb, + and using it to persist and retrieve models in the LionWeb Model + Repository. +

+
+
+
+
+ Implementing LionWeb in Rascal +
+
Ulyana Tikhonova — F1re
+
+

+ The LionWeb initiative was started two years ago, to facilitate + the interoperability between various language engineering tools + and to allow for the reuse of language engineering and modeling + tools. In this talk, we'll demonstrate our implementation of the + LionWeb protocol in Rascal. Rascal is a meta-programming + language that is used for the implementation of textual DSLs and + for more generic use cases of syntax-based analysis and + transformation of programming code. +

+

+ Comparing to the tools already integrated with LionWeb, Rascal + belongs to the traditional grammarware space. In Rascal a DSL is + defined in the form of a concrete syntax grammar. Native to + LionWeb models are represented as abstract syntax trees and new + types are defined using algebraic data types. Furthermore, + Rascal doesn't support traditional OO concepts: there are no + objects, only immutable values; no user defined sub-typing + (inheritance); all models are pure trees, without explicit + cross-referencing between their nodes. +

+

+ We will demonstrate how we close this expressiveness gap and + implement LionWeb constructs in Rascal, allowing for importing + LionWeb languages (M2) and models (M1) in Rascal. This work is + inspired by and partially reproduces the work from 2017 by Tijs + van der Storm on the conversion between Ecore and Rascal. +

+
+
+
+
+ + A Case Study: Execution of LionWeb nodes in Truffle Language + Framework +
+
Erkan Diken — F1re
+
+

+ The current implementation of + LionWeb specification enables + the exchange of models between different technologies and + programming languages. In this talk, we will present a case + study of converting LionWeb representable models into Truffle + intermediate representation (AST) and eventually executing the + models in + Truffle Language Framework. +

+

+ Truffle is a language implementation framework that enables + custom language implementations in Java. When compiled by + GraalVM, languages + implemented in Truffle are translated into efficient machine + code. Enabled by this technology stack, specific instances of a + class can be optimized in order to generate efficient machine + code, using a technique called partial evaluation. Moreover, + GraalVM provides a framework for creating language-agnostic + tools like debuggers and profilers. +

+

+ In the context of this work, we are able to execute the models + outside a language workbench (e.g. MPS) in order to benefit from + the high-performance execution framework and language-agnostic + tools. +

+

+ This work prioritizes the usage of the existing implementations + of LionWeb libraries and tools. A demo of the work, consisting + of the following steps, will also be presented to the audience: +

+
    +
  • + Exporting MPS nodes (language and instance models) to LionWeb + nodes +
    • +
  • + Importing LionWeb nodes and converting them into Truffle nodes +
    • +
  • Compiling the Truffle nodes and executing in GraalVM.
    • +
+
+
+
+
+ Bringing Notebook Experiences to modern IDEs +
+
Mark Sujew — Typefox
+
+

+ With the increasing popularity of Jupyter Notebooks, + contemporary IDEs, most notably VS Code, have started natively + supporting a new interaction model for programming: Instead of + files consisting purely of code, we can deliver documentation, + images, renderings and data analysis within a single file. This + support goes beyond just rendering and editing notebooks, but + brings the full feature set, including kernel execution - to + your IDE. +

+ +

+ In this talk, we'll present how we implemented a native notebook + experience in the Eclipse Theia IDE framework. We'll take a look + at an architectural overview and some interesting implementation + details. Finally a short demo shows the feature in action. +

+
+
+
+
+ + Seamless Interpreter Integration for Compositional Modeling + Languages +
+
+ Nico Jansen & Bernhard Rumpe — RWTH Aachen University +
+
+

+ In software language engineering, interpreters enable the direct + execution of program code or models, providing instant feedback + at system runtime. As reuse is key in developing sophisticated + modeling languages, their generated and hand-written artifacts + must be seamlessly integrated. This challenge also applies when + combining partial interpreters of different language components + into a composed infrastructure. +

+

+ While there are solutions tailored for specific technical + spaces, there is still a research gap for generally building and + incorporating partial interpreters into the context of larger + languages. In this talk, we present the architectural design for + integrating model interpreters of compositional languages. The + concept is based on an extended visitor pattern for + compositional data structures and is demonstrated in the context + of the MontiCore language workbench. +

+

+ Ultimately, we present how an automatically integrable + interpreter infrastructure can be generated, requiring minimal + manual implementation effort. The talk will be accompanied by a + tutorial in which we compose interpreters of different + languages, further integrate them with dedicated runtime + artifacts, and seamlessly deploy them in the context of a + model-driven low-code platform for web applications. +

+
+
+
+
+ + Empowering Language Reuse with Low-Code Language Composition + +
+
+ Jérôme Pfeiffer & Andreas Wortmann — Institute for + Control Engineering of Machine Tools and Manufacturing Units + (ISW), University of Stuttgart +
+
+

+ Low-code platforms have gained popularity for accelerating + complex software engineering tasks through visual interfaces and + pre-built components. Software language engineering, + specifically language composition, is a complex task that + requires expertise in the technological spaces of language + engineering, their integration in workbenches, and in the + composition mechanisms. To reduce this complexity, we introduce + a low-code platform based on a method for (almost) black-box + language composition of external DSLs using language components + that encompass textual syntax and translational realization of + semantics. The platform enables language engineers to derive new + languages from existing languages by systematically composing + them through a language family. By selecting features within the + platform's language family, language engineers can create + tailored languages that cater to specific application domains. + Through this research, we aim to contribute to the advancement + of low-code language development and empower language engineers + with a powerful tool to create and reuse languages in a more + intuitive and efficient manner. In the demo accompanying our + talk, we will guide the audience through the platform by: +

+
    +
  1. importing a language as a component into the platform,
    2. +
  2. + building up a language family by reusing existing language + components, and +
    3. +
  3. + derive a language variant by configuring a language family. +
    4. +
+
+
+
+
+ + Augmenting graphical modeling workbenches with semantic-aware + interactive features +
+
Théo Giraudet — Obeo
+
+

+ Domain-Specific Modeling Languages (DSMLs) usually come with a + dedicated integrated environment called a modeling workbench. In + the context of graphical DSMLs, such environments provide + modelers with dedicated interactive features that help them + perform navigation and editing tasks. Many of these features are + generic and can be used by graphical DSMLs without any + specialization (e.g. a physical zoom). Others require + specializations in accordance with the involved DSML. For + instance, a semantic zoom requires specifying which elements of + the model must be graphically modified at the different zoom + levels. However, current language workbenches do not propose + facilities to help language designers in developing such + semantic-aware features for their graphical modeling + environments. So language designers must develop these features + by hand, which is a complex and time-consuming task. +

+

+ In this talk, I will present you a novel approach we propose to + help language designer in this task. In addition to the existing + DSMLs concerns such as the syntaxes, we propose to capture the + interactive features of the targeted modeling workbench in the + form of DSML pragmatics. We will finish with a demo of this new + approach implemented as a prototype in Sirius Web, a language + workbench for graphical DSMLs. +

+
+
+
+
+ + Current Developments in Tooling and Editor Support in textX + +
+
+ Milan Sovic, Daniel Elero, & Igor Dejanovic — University + of Novi Sad +
+
+

+ textX is a + meta-language for building Domain-Specific Languages in Python. + Inspired by Xtext, it leverages Python's dynamic nature to + provide a more lightweight approach to building DSLs and + parsers. +

+

+ In this talk, after a brief introduction to textX, we will focus + on recent developments in tooling and editor support. The new + textX playground + will be presented, allowing users to interactively create + grammars and experiment with programs/models. Additionally, we + will showcase developments in support for the Language Server + Protocol and VS Code integration for textX languages. +

+

+ The presentation of new features will be conducted through a + live demo of building a small DSL for drone navigation. The code + and instructions for the demo will be available on the project + site and Git repository. +

+
+
+
+
+ A build tool for modular MPS projects +
+
Arjan Oortgiese — Belastingdienst
+
+

+ In this talk, I want to demonstrate a tool for building and + managing dependencies for JetBrains MPS projects and invite the + community to contribute to this project. +

+

+ MPS is great for developing languages and extensions for + languages written by other MPS developers. Extending a language + not in the same repository becomes more complicated when the + other language is under active development. Due to this, we + observe that projects often are developed in one repository. + These monolithic-like style MPS plugins make reusing parts of + the project harder for the community. +

+

The challenges that this tool aims to overcome are:

+
    +
  1. + New developers who want to build our extension language need + the language we are extending to be installed in MPS to build + successfully. MPS can help when the language is in the MPS + plugin marketplace. If the language is not in the marketplace + or the build job is a CI/CD pipeline, the developer must + ensure that the language is installed in MPS. +
    2. +
  2. Solving transitive dependencies.
    3. +
  3. + The new EU Digital Markets Act (DMA) requires a project to + supply a Software Bill of Materials (SBOM) that lists all the + used components by the software. +
    4. +
+
+
+
+

Questions

Generally. talks will be arranged in blocks of 25 minutes and 5 - minutes for Q&A. + minutes for Q&A.

- To allow a more accessible Q&A sessions, we will be using + To allow a more accessible Q&A sessions, we will be using Proxyhands.

diff --git a/2024/speakers.html b/2024/speakers.html index 11a070d..dec5950 100644 --- a/2024/speakers.html +++ b/2024/speakers.html @@ -19,32 +19,51 @@ - diff --git a/assets/2024/github-icon.svg b/assets/2024/github-icon.svg new file mode 100644 index 0000000..7f64085 --- /dev/null +++ b/assets/2024/github-icon.svg @@ -0,0 +1,4 @@ + + + \ No newline at end of file diff --git a/assets/2024/home-icon.svg b/assets/2024/home-icon.svg new file mode 100644 index 0000000..0cb7367 --- /dev/null +++ b/assets/2024/home-icon.svg @@ -0,0 +1,11 @@ + + + + + + + + + + \ No newline at end of file diff --git a/assets/2024/seville.css b/assets/2024/seville.css index 452038b..596d8f6 100644 --- a/assets/2024/seville.css +++ b/assets/2024/seville.css @@ -566,17 +566,41 @@ table.schedule { border-collapse: collapse; display: table; width: 100%; + margin-bottom: 5rem; } table.tr.social { margin-top: 20px; } -table.schedule td:nth-child(1) { +table.schedule.day1 td:nth-child(1) { text-align: right; width: 50px; } +table.schedule.day1 tr.tl td:nth-child(1) { + text-align: left; +} + +table.schedule.day1 td:nth-child(2) { + width: 30%; +} + +table.schedule.day1 td:nth-child(3) { + width: 15%; +} +table.schedule.day1 td:nth-child(4) { + width: 30%; +} + +table.schedule.day1 td:nth-child(5) { + width: 15%; +} + +table.schedule td:nth-child(1) { + text-align: right; + width: 50px; +} table.schedule td:nth-child(2) { width: 60%; } @@ -594,7 +618,7 @@ td { } table.schedule td.low { - color: #7e8b9e; + color: #a0abb9; } table.schedule th.day { @@ -613,7 +637,7 @@ table.schedule tr.day td { } table.schedule tr.break { - background-color: #2d303d; + background-color: #555864; } table.schedule tr.social { background-color: #2d303d; @@ -624,6 +648,21 @@ table.schedule tr.break td:nth-child(2) { text-align: center; } +.empty { + background-color: #424a56; +} +.track { + font-weight: bold; + background-color: #7e8b9e; +} +.lunch { + height: 9rem; +} +.social td { + height: 12rem; + background-color: #424a56; +} + table.inscription { border-spacing: 0px; text-align: center; @@ -670,3 +709,34 @@ ol.inscription { margin-left: 3rem; margin-bottom: 3rem; } + +.session-details { + margin-top: 3rem; +} + +.session-details .session { + margin-bottom: 2rem; +} +.session-details .session .title { + font-weight: 500; +} +.session-details .title a { + color: var(--accent-color); +} +.session-details .session .author { + font-style: italic; +} +.session-details .session .abstract { + margin-top: 0.8rem; + margin-bottom: 4rem; + padding-left: 2rem; +} +.session-details .session p { + margin-block-start: 0.7rem; +} +.session-details .session ol { + padding-left: 3rem; +} +.session { + border-bottom: 2px solid #7e8b9e; +} diff --git a/assets/2024/speakers/bcombemale.jpg b/assets/2024/speakers/bcombemale.jpg new file mode 100644 index 0000000..46f0da2 Binary files /dev/null and b/assets/2024/speakers/bcombemale.jpg differ diff --git a/assets/2024/speakers/draco.png b/assets/2024/speakers/draco.png new file mode 100644 index 0000000..9a72466 Binary files /dev/null and b/assets/2024/speakers/draco.png differ diff --git a/assets/2024/speakers/ftomassetti.jpg b/assets/2024/speakers/ftomassetti.jpg new file mode 100644 index 0000000..0656c41 Binary files /dev/null and b/assets/2024/speakers/ftomassetti.jpg differ diff --git a/assets/2024/speakers/pgomez.png b/assets/2024/speakers/pgomez.png new file mode 100644 index 0000000..0d3df65 Binary files /dev/null and b/assets/2024/speakers/pgomez.png differ diff --git a/assets/2024/speakers/pjmolina.jpg b/assets/2024/speakers/pjmolina.jpg new file mode 100644 index 0000000..c870378 Binary files /dev/null and b/assets/2024/speakers/pjmolina.jpg differ diff --git a/assets/2024/speakers/tgiraudet.png b/assets/2024/speakers/tgiraudet.png new file mode 100644 index 0000000..f5ec507 Binary files /dev/null and b/assets/2024/speakers/tgiraudet.png differ diff --git a/assets/2024/speakers/utikhonova.jpg b/assets/2024/speakers/utikhonova.jpg new file mode 100644 index 0000000..289bfa9 Binary files /dev/null and b/assets/2024/speakers/utikhonova.jpg differ diff --git a/index.html b/index.html index 9736a32..8ce85c4 100644 --- a/index.html +++ b/index.html @@ -51,6 +51,9 @@

#langdev2024

Aerospace Edition
Inscription is now open
+
+ Program published +
LangDev Conference
Seville, 17-19 October 2024.

diff --git a/langdev2024.html b/langdev2024.html index 9736a32..8ce85c4 100644 --- a/langdev2024.html +++ b/langdev2024.html @@ -51,6 +51,9 @@

#langdev2024

Aerospace Edition
Inscription is now open
+
+ Program published +
LangDev Conference
Seville, 17-19 October 2024.

Tuesday, November 14