Publications
- O. Leßenich and S. Sobernig, “Usefulness and usability of heuristic walkthroughs for evaluating domain-specific developer tools in industry: Evidence from four field simulations,” Inf. Softw. Technol., vol. 160, p. 107220, 2023.
@article{DBLP:journals/infsof/LessenichS23, author = {Le{\ss}enich, Olaf and Sobernig, Stefan}, title = {Usefulness and usability of heuristic walkthroughs for evaluating domain-specific developer tools in industry: Evidence from four field simulations}, journal = {Inf. Softw. Technol.}, volume = {160}, pages = {107220}, year = {2023}, url = {https://doi.org/10.1016/j.infsof.2023.107220}, doi = {10.1016/J.INFSOF.2023.107220}, timestamp = {Tue, 12 Sep 2023 07:58:00 +0200}, biburl = {https://dblp.org/rec/journals/infsof/LessenichS23.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} }The usage of domain-specific languages (DSLs) is an approach to reduce complexity in software development by expert developers for selected application domains. To support expert developers, a DSL is often combined with a tailored, domain-specific developer tool, offering similar functionality as general-purpose programming environments (IDEs like Eclipse for Java) while integrating with a domain-specific toolchain (e.g., code or documentation generators, simulators). General-purpose development environments have been successfully evaluated for the programmer experience (PX) and for anomalies using heuristic walkthroughs as a mixed review technique combining cognitive walkthroughs and a heuristic evaluation. In this paper, we report on the usefulness and acceptance of heuristic walkthroughs as an PX evaluation technique applied to domain-specific languages and IDEs in an industry context. Heuristic walkthroughs are used in four interventions (field simulations) to assess the programming experience and usability of domain-specific, Eclipse-based IDEs in a concrete industry setting. Data on the usefulness and acceptance (perceived satisfaction) of the walkthroughs themselves are collected and analysed. Our studies show that, in practice, the instrument of walkthroughs is useful for revealing practically relevant PX anomalies, while maintaining acceptance by practitioners participating in the walkthroughs. The documented variant of heuristic walkthroughs is eligible to become adopted for future field studies in academic research and for evaluation projects in industry, in support of developing domain-specific developer tooling in an evidence-driven manner.
- S. Sobernig and O. Leßenich, “v1e: A Kernel for Domain-specific Textual Variability Modelling
Languages,” in VaMoS’21: 15th International Working Conference on Variability Modelling
of Software-Intensive Systems, Virtual Event / Krems, Austria, February
9-11, 2021, 2021, pp. 4:1–4:7.
@inproceedings{DBLP:conf/vamos/SobernigL21, author = {Sobernig, Stefan and Le{\ss}enich, Olaf}, editor = {Gr{\"{u}}nbacher, Paul and Seidl, Christoph and Dhungana, Deepak and Lovasz{-}Bukvova, Helena}, title = {v1e: {A} Kernel for Domain-specific Textual Variability Modelling Languages}, booktitle = {VaMoS'21: 15th International Working Conference on Variability Modelling of Software-Intensive Systems, Virtual Event / Krems, Austria, February 9-11, 2021}, pages = {4:1--4:7}, publisher = {{ACM}}, year = {2021}, url = {https://doi.org/10.1145/3442391.3442396}, doi = {10.1145/3442391.3442396}, timestamp = {Fri, 12 Feb 2021 10:43:42 +0100}, biburl = {https://dblp.org/rec/conf/vamos/SobernigL21.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} }v1e is a language kernel for textual variability modelling built on top of the language-development system DjDSL. As a language kernel, v1e provides a minimal but extensible set of abstractions to implement language families for textual variability modelling. v1e provides for a small and versatile abstract syntax to encode variability models using multiplicity constraints and canonical semantics. v1e offers built-in analysis support via BDDs, such as configuration validation. A derived language becomes realised as a collection of extensions dependent on the language kernel. We showcase the design and implementation of a v1e-based implementation of TVL. We conclude the paper by pointing out current limitations (e.g., representing attributed variability models) and future directions (e.g., analysis support beyond BDD).
- B. K. Aichernig and C. Burghard, “Giving a Model-Based Testing Language a Formal Semantics via Partial
MAX-SAT,” in Testing Software and Systems - 32nd IFIP WG 6.1 International
Conference, ICTSS 2020, Naples, Italy, December 9-11, 2020, Proceedings, 2020, vol. 12543, pp. 35–51.
@inproceedings{DBLP:conf/pts/AichernigB20, author = {Aichernig, Bernhard K. and Burghard, Christian}, editor = {Casola, Valentina and Benedictis, Alessandra De and Rak, Massimiliano}, title = {Giving a Model-Based Testing Language a Formal Semantics via Partial {MAX-SAT}}, booktitle = {Testing Software and Systems - 32nd {IFIP} {WG} 6.1 International Conference, {ICTSS} 2020, Naples, Italy, December 9-11, 2020, Proceedings}, series = {Lecture Notes in Computer Science}, volume = {12543}, pages = {35--51}, publisher = {Springer}, year = {2020}, url = {https://doi.org/10.1007/978-3-030-64881-7\_3}, doi = {10.1007/978-3-030-64881-7\_3}, timestamp = {Thu, 17 Dec 2020 18:29:51 +0100}, biburl = {https://dblp.org/rec/conf/pts/AichernigB20.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} }Domain-specific Languages (DSLs) are widely used in model-based testing to make the benefits of modeling available to test engineers while avoiding the problem of excessive learning effort. Complex DSLs benefit from a formal definition of their semantics for model processing as well as consistency checking. A formal semantics can be established by mapping the model domain to a well-known formalism. In this paper, we present an industrial use case which includes a mapping from domain-specific models to Moore Machines, based on a Partial MAX-SAT problem, encoding a predicative semantics for the model-to-model mapping. We show how Partial MAX-SAT solves the frame problem for a non-trivial DSL in which the non-effect on variables cannot be determined statically. We evaluated the performance of our model-transformation algorithm based on models from our industrial use case.
- C. Burghard and L. Berardinelli, “Visualizing Multi-dimensional State Spaces Using Selective Abstraction,” in 46th Euromicro Conference on Software Engineering and Advanced Applications,
SEAA 2020, 2020, pp. 141–149.
@inproceedings{DBLP:conf/euromicro/burghard20, author = {Burghard, Christian and Berardinelli, Luca}, title = {Visualizing Multi-dimensional State Spaces Using Selective Abstraction}, booktitle = {46th Euromicro Conference on Software Engineering and Advanced Applications, {SEAA} 2020}, pages = {141--149}, publisher = {{IEEE}}, year = {2020} }Domain-specific languages (DSLs) are popular for many reasons, such as increasing productivity for developers and improving communication with domain experts. Both textual and graphical DSLs are viable solutions with complementary pros and cons: while graphical DSLs shorten the learning curve and facilitate documentation and communication, textual DSLs aim at higher productivity thanks to more efficient editor functionalities. This paper presents the industrial experience on the adoption of a hybrid approach combining an existing textual DSL with a readonly graphical state machine representation (visualization), equipped with a selective abstraction functionality that offers user-specific, highly configurable views on states and transitions. Our approach is the result of an evolutionary process to improve the modelling experience, relying on frequent user feedback. We argue that a well-tailored visualization is a suitable way to shorten the learning curve and ease the adoption of model-driven approaches in industrial settings.
- S. Sobernig, “Tailor Made: Situational Method Engineering for Empirical SE Research,” in Software Engineering 2020, Fachtagung des GI-Fachbereichs Softwaretechnik,
24.-28. Februar 2020, Innsbruck, Austria, 2020, vol. P-300, pp. 155–156.
@inproceedings{DBLP:conf/se/Sobernig20, author = {Sobernig, Stefan}, editor = {Felderer, Michael and Hasselbring, Wilhelm and Rabiser, Rick and Jung, Reiner}, title = {Tailor Made: Situational Method Engineering for Empirical {SE} Research}, booktitle = {Software Engineering 2020, Fachtagung des GI-Fachbereichs Softwaretechnik, 24.-28. Februar 2020, Innsbruck, Austria}, series = {{LNI}}, volume = {{P-300}}, pages = {155--156}, publisher = {Gesellschaft f{\"{u}}r Informatik e.V.}, year = {2020}, url = {https://doi.org/10.18420/SE2020\_48}, doi = {10.18420/SE2020\_48}, timestamp = {Thu, 06 Feb 2020 13:42:01 +0100}, biburl = {https://dblp.org/rec/conf/se/Sobernig20.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} } - S. Sobernig, “Chain of builders: a pattern of variable syntax processing for internal
DSLs,” in Proceedings of the 24th European Conference on Pattern Languages of
Programs, EuroPLoP 2019, Irsee, Germany, July 3-7, 2019, 2019, pp. 29:1–29:11.
@inproceedings{DBLP:conf/europlop/Sobernig19, author = {Sobernig, Stefan}, editor = {Sousa, Tiago Boldt}, title = {Chain of builders: a pattern of variable syntax processing for internal DSLs}, booktitle = {Proceedings of the 24th European Conference on Pattern Languages of Programs, EuroPLoP 2019, Irsee, Germany, July 3-7, 2019}, pages = {29:1--29:11}, publisher = {{ACM}}, year = {2019}, url = {https://doi.org/10.1145/3361149.3361179}, doi = {10.1145/3361149.3361179}, timestamp = {Mon, 09 Dec 2019 14:02:07 +0100}, biburl = {https://dblp.org/rec/conf/europlop/Sobernig19.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} }chain of builders is a language-implementation pattern at the centre of realising variable textual syntaxes for internal domain-specific languages (DSL). An internal DSL is built on top of a general-purpose software language (GPL; Java) and uses the GPL infrastructure for processing and for enacting DSL scripts. A DSL is said to be variable when it allows for deriving a family of DSL variants (a.k.a. a language-product line), varying at the levels of abstract syntax, concrete syntax, semantics, and execution (e.g., interpretation or generation). chain of builders combines the chain of responsibility and expression builder patterns. With this, the paper adds to known pattern languages for DSL development (e.g., Fowler’s). Its known use has been in development systems for internal DSLs such as DjDSL, but also applies to applications processing mixed syntaxes (XML and JSON).
Open Source
Eclipse GLSP
“GLSP is an extensible open source framework to build custom diagram editors in the web/cloud. These editors can be deployed stand-alone or integrated into a web-based IDE such as Eclipse Theia or VS Code. GLSP defines a language server protocol (LSP) for diagrams and integrates well with your existing tool chain and business logic.”
In HybridDLUX we are using Eclipse GLSP for implementing domain-specific, interactive diagram editors ranging from interactive visualization of inferred statemachines from textually specified rules to editable statemachine editors that are connected to proprietary data sources. These editors are integrated in a traditional Eclipse IDE but are also available in a cloud IDE based on Eclipse Theia.
Eclipse Theia
“Eclipse Theia is an extensible platform to develop multi-language Cloud & Desktop IDEs with state-of-the-art web technologies.”
HybridDLUX is all about flexibly mixing textual and graphical languages to provide the most benefits for domain engineers. This flexibility doesn’t end at the model representation, but also includes the IDE platform with which domain engineers interact with those model representations – in a rich-client application based on Eclipse or in a browser with a cloud IDE, such as Eclipse Theia.
Background
- S. Sobernig, B. Hoisl, and M. Strembeck, “Extracting reusable design decisions for UML-based domain-specific languages: A multi-method study,” Journal of Systems and Software, vol. 113, pp. 140–172, 2016.
@article{DBLP:journals/jss/SobernigHS16, author = {Sobernig, Stefan and Hoisl, Bernhard and Strembeck, Mark}, title = {Extracting reusable design decisions for UML-based domain-specific languages: {A} multi-method study}, journal = {Journal of Systems and Software}, volume = {113}, pages = {140--172}, year = {2016}, url = {https://doi.org/10.1016/j.jss.2015.11.037}, doi = {10.1016/j.jss.2015.11.037}, timestamp = {Wed, 14 Jun 2017 20:34:57 +0200}, biburl = {https://dblp.org/rec/bib/journals/jss/SobernigHS16}, bibsource = {dblp computer science bibliography, https://dblp.org} }When developing domain-specific modeling languages (DSMLs), software engineers have to make a number of important design decisions on the DSML itself, or on the software-development process that is applied to develop the DSML. Thus, making well-informed design decisions is a critical factor in developing DSMLs. To support this decision-making process, the model-driven development community has started to collect established design practices in terms of patterns, guidelines, story-telling, and procedural models. However, most of these documentation practices do not capture the details necessary to reuse the rationale behind these decisions in other DSML projects. In this paper, we report on a three-year research effort to compile and to empirically validate a catalog of structured decision descriptions (decision records) for UML-based DSMLs. This catalog is based on design decisions extracted from 90 DSML projects. These projects were identified—among others—via an extensive systematic literature review (SLR) for the years 2005–2012. Based on more than 8,000 candidate publications, we finally selected 84 publications for extracting design-decision data. The extracted data were evaluated quantitatively using a frequent-item-set analysis to obtain characteristic combinations of design decisions and qualitatively to document recurring documentation issues for UML-based DSMLs. We revised the collected decision records based on this evidence and made the decision-record catalog for developing UML-based DSMLs publicly available. Furthermore, our study offers insights into UML usage (e.g. diagram types) and into the adoption of UML extension techniques (e.g. metamodel extensions, profiles).
- S. Sobernig, S. Apel, S. S. Kolesnikov, and N. Siegmund, “Quantifying structural attributes of system decompositions in 28 feature-oriented software product lines - An exploratory study,” Empirical Software Engineering, vol. 21, no. 4, pp. 1670–1705, 2016.
@article{DBLP:journals/ese/SobernigAKS16, author = {Sobernig, Stefan and Apel, Sven and Kolesnikov, Sergiy S. and Siegmund, Norbert}, title = {Quantifying structural attributes of system decompositions in 28 feature-oriented software product lines - An exploratory study}, journal = {Empirical Software Engineering}, volume = {21}, number = {4}, pages = {1670--1705}, year = {2016}, url = {https://doi.org/10.1007/s10664-014-9336-6}, doi = {10.1007/s10664-014-9336-6}, timestamp = {Sun, 28 May 2017 13:22:43 +0200}, biburl = {https://dblp.org/rec/bib/journals/ese/SobernigAKS16}, bibsource = {dblp computer science bibliography, https://dblp.org} }A key idea of feature orientation is to decompose a software product line along the features it provides. Feature decomposition is orthogonal to object-oriented decomposition—it crosscuts the underlying package and class structure. It has been argued often that feature decomposition improves system structure by reducing coupling and by increasing cohesion. However, recent empirical findings suggest that this is not necessarily the case. In this exploratory, observational study, we investigate the decompositions of 28 feature-oriented software product lines into classes, features, and feature-specific class fragments. The product lines under investigation are implemented using the feature-oriented programming language Fuji. In particular, we quantify and compare the internal attributes import coupling and cohesion of the different product-line decompositions in a systematic, reproducible manner. For this purpose, we adopt three established software measures (e.g., coupling between units, CBU; internal-ratio unit dependency, IUD) as well as standard concentration statistics (e.g., Gini coefficient). In our study, we found that feature decomposition can be associated with higher levels of structural coupling in a product line than a decomposition into classes. Although coupling can be concentrated in very few features in most feature decompositions, there are not necessarily hot-spot features in all product lines. Interestingly, feature cohesion is not necessarily higher than class cohesion, whereas features are more equal in serving dependencies internally than classes of a product line. Our empirical study raises critical questions about alleged advantages of feature decomposition. At the same time, we demonstrate how our measurement approach of coupling and cohesion has potential to support static and dynamic analyses of software product lines (i.e., type checking and feature-interaction detection) by facilitating product sampling.
- B. Hoisl, S. Sobernig, and M. Strembeck, “Modeling and enforcing secure object flows in process-driven SOAs: an integrated model-driven approach,” Software and System Modeling, vol. 13, no. 2, pp. 513–548, 2014.
@article{DBLP:journals/sosym/HoislSS14, author = {Hoisl, Bernhard and Sobernig, Stefan and Strembeck, Mark}, title = {Modeling and enforcing secure object flows in process-driven SOAs: an integrated model-driven approach}, journal = {Software and System Modeling}, volume = {13}, number = {2}, pages = {513--548}, year = {2014}, url = {https://doi.org/10.1007/s10270-012-0263-y}, doi = {10.1007/s10270-012-0263-y}, timestamp = {Fri, 26 May 2017 22:52:21 +0200}, biburl = {https://dblp.org/rec/bib/journals/sosym/HoislSS14}, bibsource = {dblp computer science bibliography, https://dblp.org} }In this paper, we present an integrated model-driven approach for the specification and the enforcement of secure object flows in process-driven service-oriented architectures (SOA). In this context, a secure object flow ensures the confidentiality and the integrity of important objects (such as business contracts or electronic patient records) that are passed between different participants in SOA-based business processes. We specify a formal and generic metamodel for secure object flows that can be used to extend arbitrary process modeling languages. To demonstrate our approach, we present a UML extension for secure object flows. Moreover, we describe how platform-independent models are mapped to platform-specific software artifacts via automated model transformations. In addition, we give a detailed description of how we integrated our approach with the Eclipse modeling tools.
- P. Langer et al., “A posteriori operation detection in evolving software models,” Journal of Systems and Software, vol. 86, no. 2, pp. 551–566, 2013.
@article{DBLP:journals/jss/LangerWBHSWK13, author = {Langer, Philip and Wimmer, Manuel and Brosch, Petra and Herrmannsd{\"{o}}rfer, Markus and Seidl, Martina and Wieland, Konrad and Kappel, Gerti}, title = {A posteriori operation detection in evolving software models}, journal = {Journal of Systems and Software}, volume = {86}, number = {2}, pages = {551--566}, year = {2013}, url = {https://doi.org/10.1016/j.jss.2012.09.037}, doi = {10.1016/j.jss.2012.09.037}, timestamp = {Wed, 14 Nov 2018 10:34:07 +0100}, biburl = {https://dblp.org/rec/bib/journals/jss/LangerWBHSWK13}, bibsource = {dblp computer science bibliography, https://dblp.org} }As every software artifact, also software models are subject to continuous evolution. The operations applied between two successive versions of a model are crucial for understanding its evolution. Generic approaches for detecting operations a posteriori identify atomic operations, but neglect composite operations, such as refactorings, which leads to cluttered difference reports. To tackle this limitation, we present an orthogonal extension of existing atomic operation detection approaches for detecting also composite operations. Our approach searches for occurrences of composite operations within a set of detected atomic operations in a post-processing manner. One major benefit is the reuse of specifications available for executing composite operations also for detecting applications of them. We evaluate the accuracy of the approach in a real-world case study and investigate the scalability of our implementation in an experiment.
- P. Langer, K. Wieland, M. Wimmer, and J. Cabot, “EMF Profiles: A Lightweight Extension Approach for EMF Models,” Journal of Object Technology, vol. 11, no. 1, pp. 1–29, 2012.
@article{DBLP:journals/jot/LangerWWC12, author = {Langer, Philip and Wieland, Konrad and Wimmer, Manuel and Cabot, Jordi}, title = {{EMF} Profiles: {A} Lightweight Extension Approach for {EMF} Models}, journal = {Journal of Object Technology}, volume = {11}, number = {1}, pages = {1--29}, year = {2012}, url = {https://doi.org/10.5381/jot.2012.11.1.a8}, doi = {10.5381/jot.2012.11.1.a8}, timestamp = {Tue, 06 Jun 2017 22:27:11 +0200}, biburl = {https://dblp.org/rec/bib/journals/jot/LangerWWC12}, bibsource = {dblp computer science bibliography, https://dblp.org} }Domain-Specific Modeling Languages (DSMLs) are getting more and more attention as a key element of Model Driven Engineering. As any other software artifact, DSMLs should continuously evolve to adapt to the changing needs of the domain they represent. Unfortunately, right now evolution of DSMLs is a costly process that requires changing the DSML metamodel and re-creating the complete modeling environment. In this paper we advocate for the use of EMF Profiles, an adaptation of the UML Profile concept to DSMLs. Profiles have been a key enabler for the success of UML by providing a lightweight language-inherent extension mechanism which is expressive enough to cover an important subset of extension scenarios. We believe a similar concept for DSMLs would provide a valuable extension mechanism which has been so far neglected by current metamodeling tools. Apart from direct metamodel profiles, we also propose reusable profile definition mechanisms whereby profiles are defined independently of any DSML and, later on, coupled with all DSMLs that can benefit from these profiles. Our approach has been implemented in a prototype integrated in the EMF environment.
- E. Bousse, D. Leroy, B. Combemale, M. Wimmer, and B. Baudry, “Omniscient debugging for executable DSLs,” Journal of Systems and Software, vol. 137, pp. 261–288, 2018.
@article{BOUSSE2018261, title = {Omniscient debugging for executable DSLs}, journal = {Journal of Systems and Software}, volume = {137}, pages = {261 - 288}, year = {2018}, issn = {0164-1212}, doi = {https://doi.org/10.1016/j.jss.2017.11.025}, url = {http://www.sciencedirect.com/science/article/pii/S0164121217302765}, author = {Bousse, Erwan and Leroy, Dorian and Combemale, Benoit and Wimmer, Manuel and Baudry, Benoit}, keywords = {Software Language Engineering, Domain-Specific Languages, Executable DSL, Omniscient debugging, Execution trace} }Omniscient debugging is a promising technique that relies on execution traces to enable free traversal of the states reached by a model (or program) during an execution. While a few General-Purpose Languages (GPLs) already have support for omniscient debugging, developing such a complex tool for any executable Domain Specific Language (DSL) remains a challenging and error prone task. A generic solution must: support a wide range of executable DSLs independently of the metaprogramming approaches used for implementing their semantics; be efficient for good responsiveness. Our contribution relies on a generic omniscient debugger supported by efficient generic trace management facilities. To support a wide range of executable DSLs, the debugger provides a common set of debugging facilities, and is based on a pattern to define runtime services independently of metaprogramming approaches. Results show that our debugger can be used with various executable DSLs implemented with different metaprogramming approaches. As compared to a solution that copies the model at each step, it is on average sixtimes more efficient in memory, and at least 2.2 faster when exploring past execution states, while only slowing down the execution 1.6 times on average.
- T. Mayerhofer, M. Wimmer, L. Berardinelli, and R. Drath, “A model-driven engineering workbench for caex supporting language customization and evolution,” IEEE Transactions on Industrial Informatics, vol. 14, no. 6, pp. 2770–2779, 2017.
@article{mayerhofer2017model, title = {A model-driven engineering workbench for caex supporting language customization and evolution}, author = {Mayerhofer, Tanja and Wimmer, Manuel and Berardinelli, Luca and Drath, Rainer}, journal = {IEEE Transactions on Industrial Informatics}, volume = {14}, number = {6}, pages = {2770--2779}, year = {2017}, publisher = {IEEE}, url = {https://ieeexplore.ieee.org/document/8239624}, keywords = {computer aided engineering;data visualisation;document handling;electronic data interchange;factory automation;formal specification;open systems;production engineering computing;software engineering;XML;CAEX supporting language customization;Computer Aided Engineering Exchange;Model-Driven Engineering Workbench;language engineering challenges;data exchange;production system automation domain;AutomationML;AML;CAEX documents visualizations;MDE;core representation language;usage rules;Libraries;Data models;Standards;Tools;Metamodeling;Analytical models;AutomationML (AML);computer aided engineering exchange (CAEX);language customization;language evolution;metamodeling;model-driven engineering} }Computer Aided Engineering Exchange (CAEX) is one of the most promising standards when it comes to data exchange between engineering tools in the production system automation domain. This is also reflected by the current emergence of AutomationML (AML), which uses CAEX as its core representation language. However, with the increasing use of CAEX, important language engineering challenges arise. One of these challenges is the customization of CAEX for its usage in superior standards, such as AML, which requires the precise specification of the language including the formalization and validation of additional usage rules. Another highly topical challenge is the ongoing evolution of CAEX as has recently happened with the transition from version 2.15 to version 3.0. Further challenges include the provisioning of editing facilities and visualizations of CAEX documents such that they can be inspected and modified by engineers, and the development of transformations from and to CAEX such that different engineering artifacts can be exchanged via CAEX. In this paper, we take a language engineering point of view and present a model-driven engineering (MDE) workbench for CAEX that allows to address these and other challenges. In particular, we present how CAEX can be formulated in a model-based framework, which allows the application of MDE techniques, such as model validation, migration, editing, visualization, and transformation techniques, to solve a diverse set of language engineering challenges experienced for CAEX. We give an overview of the developed workbench and illustrate its benefits with a focus on customizing CAEX for AML and evolving CAEX documents from version 2.15 to 3.0.
- R. Rodriguez-Echeverria, J. L. C. Izquierdo, M. Wimmer, and J. Cabot, “Towards a Language Server Protocol Infrastructure for Graphical Modeling,” in Proceedings of the 21th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, 2018, pp. 370–380.
@inproceedings{rodriguez2018towards, title = {Towards a Language Server Protocol Infrastructure for Graphical Modeling}, author = {Rodriguez-Echeverria, Roberto and Izquierdo, Javier Luis C{\'a}novas and Wimmer, Manuel and Cabot, Jordi}, booktitle = {Proceedings of the 21th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems}, pages = {370--380}, year = {2018}, organization = {ACM}, url = {https://dl.acm.org/citation.cfm?id=3239383} }The development of modern IDEs is still a challenging and time-consuming task, which requires implementing the support for language-specific features such as syntax highlighting or validation. When the IDE targets a graphical language, its development becomes even more complex due to the rendering and manipulation of the graphical notation symbols. To simplify the development of IDEs, the Language Server Protocol (LSP) proposes a decoupled approach based on language-agnostic clients and language-specific servers. LSP clients communicate changes to LSP servers, which validate and store language instances. However, LSP only addresses textual languages (i.e., character as atomic unit) and neglects the support for graphical ones (i.e., nodes/edges as atomic units). In this paper, we present our vision to decouple graphical language IDEs discussing the alternatives for integrating LSP’s ideas in their development. Moreover, we propose a novel LSP infrastructure to simplify the development of new graphical modeling tools, in which Web technologies may be used for editor front-ends while leveraging existing modeling frameworks to build language servers.