DOCSLIB.ORG

Example-Based Live Programming for Everyone Building Language-Agnostic Tools for Live Programming with LSP and Graalvm

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Example-Based Live Programming for Everyone Building Language-Agnostic Tools for Live Programming with LSP and Graalvm Example-Based Live Programming for Everyone Building Language-Agnostic Tools for Live Programming with LSP and GraalVM Fabio Niephaus Patrick Rein Jakob Edding Hasso Plattner Institute Hasso Plattner Institute Hasso Plattner Institute University of Potsdam University of Potsdam University of Potsdam Potsdam, Germany Potsdam, Germany Potsdam, Germany [email protected] [email protected] [email protected] Jonas Hering Bastian König Kolya Opahle Hasso Plattner Institute Hasso Plattner Institute Hasso Plattner Institute University of Potsdam University of Potsdam University of Potsdam Potsdam, Germany Potsdam, Germany Potsdam, Germany [email protected] [email protected] [email protected] Nico Scordialo Robert Hirschfeld Hasso Plattner Institute Hasso Plattner Institute University of Potsdam University of Potsdam Potsdam, Germany Potsdam, Germany [email protected] [email protected] Abstract from programming environments. Further, we demonstrate Our community has explored various approaches to improve how our approach enables the use of elp in the context of the programming experience. Although many of them, such polyglot programming. We illustrate the consequences of as Example-Based Live Programming (elp), have shown to our approach by discussing its advantages and limitations be effective, they are still not widespread in conventional and by comparing the features of our system to other elp programming environments. A reason for that is the effort systems. Moreover, we give an outlook of how tools that rely required to provide sophisticated tools that rely on run-time on run-time information could be built in the future. This information. To target multiple language ecosystems, it is in turn might motivate future tool builders and researchers often necessary to implement the same concepts, but for dif- to consider implementing more tools in a language-agnostic ferent languages and runtimes. Two emerging technologies way from the start to make them available to a broader audi- present an opportunity to reduce this effort significantly: the ence. Language Server Protocol (lsp) and language implementa- tion frameworks such as GraalVM’s Truffle. In this paper, we CCS Concepts: • Software and its engineering ! Inte- show how an elp system can be built in a language-agnostic grated and visual development environments; Software way by leveraging these two technologies. Based on our maintenance tools; Runtime environments. approach, we implemented the Babylonian Programming system, an elp system that has previously only been imple- mented for exploratory ecosystems. Our system, on the other Keywords: Live Programming, Exploratory Programming, hand, brings elp for all languages supported by the GraalVM Language Server Protocol, GraalVM, Truffle, Visual Studio to Visual Studio Code (VS Code). Moreover, we outline what Code a language-agnostic infrastructure needs to provide and how the lsp could be extended to support elp also independently ACM Reference Format: Permission to make digital or hard copies of part or all of this work for Fabio Niephaus, Patrick Rein, Jakob Edding, Jonas Hering, Bas- personal or classroom use is granted without fee provided that copies are tian König, Kolya Opahle, Nico Scordialo, and Robert Hirschfeld. not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for third- 2020. Example-Based Live Programming for Everyone: Building party components of this work must be honored. For all other uses, contact Language-Agnostic Tools for Live Programming with LSP and the owner/author(s). GraalVM. In Proceedings of the 2020 ACM SIGPLAN International Onward! ’20, November 18–20, 2020, Virtual, USA Symposium on New Ideas, New Paradigms, and Reflections on Pro- © 2020 Copyright held by the owner/author(s). gramming and Software (Onward! ’20), November 18–20, 2020, Virtual, ACM ISBN 978-1-4503-8178-9/20/11. USA. ACM, New York, NY, USA, 17 pages. https://doi.org/10.1145/ https://doi.org/10.1145/3426428.3426919 3426428.3426919 1 Onward! ’20, November 18–20, 2020, Virtual, USA F. Niephaus, P. Rein, J. Edding, J. Hering, B. König, K. Opahle, N. Scordialo, and R. Hirschfeld 1 Introduction is to allow programmers to use the best language, library, Our community has created various approaches to improve framework, or tool for the job and thus fosters software reuse. the programming experience through Exploratory and Live On the other hand, this also means that they have to deal Programming [26], in particular through tools making use with additional cognitive overhead, for example distinguish- of run-time information such as Whyline or Example-Based ing between different language semantics. An elp system Live Programming (elp)[1, 13]. Nevertheless, many of these can help programmers to better understand such differences tools are not widespread, in particular not in conventional when building polyglot applications. programming environments. This is often not the result of a In this paper, we show how a new infrastructure can pro- conceptual limitation, as many of these tools do not depend vide a complex programming tool with a live feedback loop on specific programming languages, programming environ- for multiple languages. In particular, we describe and evalu- ments, or execution environments. We argue that part of ate how an elp system can be built in a language-agnostic the problem is the effort required to provide a tool for dif- way on top of the lsp and the Truffle instrumentation frame- ferent ecosystems, as this means re-implementing the user work. On the one hand, our approach makes elp usable uni- interface (ui) of the tool in the corresponding programming formly across languages and development environments. On environments and the necessary instrumentation in the cor- the other hand, it also enables elp for polyglot programming, responding execution environments. While some adapta- where programmers not only have to deal with cognitive tions for specific environments will always be required, the challenges of one, but many languages at the same time. To core mechanisms of a tool may not differ much between demonstrate our approach, we implement the Babylonian implementations and could be reused. Programming system [23, 25], an elp system that has previ- Two recent trends provide an opportunity that may enable ously only been implemented for exploratory ecosystems, tool builders to support various environments and languages, on top of Truffle’s lsp implementation and the its extension while only implementing the core mechanisms of their tools for Visual Studio Code (VS Code). once: the Language Server Protocol (lsp) and the Truffle instrumentation framework. The lsp decouples Integrated Contributions: Development Environments (ides) from concrete program- ming languages, so that programmers are free to choose • An approach for extending the Language Server Pro- what kind of ide they use for writing code in a specific lan- tocol with a live feedback loop to support elp systems, guage [18]. The Truffle instrumentation framework [30], on • A language-agnostic implementation strategy for a the other hand, enables language-agnostic implementations Babylonian Programming system, and of program instrumentation infrastructures. This framework • A discussion of to what extent elp can be provided in is part of the Truffle language implementation framework a language-agnostic and environment-agnostic way, used to implement all languages for the GraalVM [33]. More based on a prototypical implementation of said ap- importantly, Truffle already provides an lsp server based on proach and strategy. its instrumentation framework [28]. An example for sophisticated tool support that may be In the remainder of this paper, we give a short introduction implemented based on these technologies is elp. elp nar- to elp and provide an overview of current implementation rows the gap between static source code and the dynamic strategies to illustrate how these result in specialized imple- behavior of a program. While programmers write code, an mentations in Section 2. In Section 3, we introduce lsp and elp system uses user-provided examples to invoke annotated the Truffle instrumentation framework. Based on this, we functions, and to provide fine-grained, live feedback on the present our general approach for a language-agnostic elp im- resulting program behavior. Currently, most existing imple- plementation in Section 4. In Section 5, we describe technical mentations of elp systems are based on highly specialized details of the implementation. To illustrate the consequences programming systems and adapted execution environments. of our approach, we demonstrate the achieved programming For widespread adoption, however, elp needs to be available experience with two walkthroughs in Section 6 and provide in conventional, general-purpose ides and should work with a discussion of the feasibility of providing elp in a language- unmodified execution environments. agnostic and environment-agnostic way in Section 7. Finally, As a result of implementing tools in a language-agnostic we discuss related work in Section 8 and state our conclu- way, programmers can always use their preferred set of tools sions in Section 9. to develop in different languages. This makes the program- ming experience more consistent [20]. Moreover, such tools 2 Example-Based Live Programming: can
Load more

Recommended publications
  • Skill Language Server
    Institute of Software Technology University of Stuttgart Universitätsstraße 38 D–70569 Stuttgart Bachelorarbeit SKilL Language Server Johannes Schäufele Course of Study: Informatik Examiner: Prof. Dr. Erhard Plödereder Supervisor: Dipl.-Inf. Felix Krause, Dr. Timm Felden Commenced: April 9, 2018 Completed: October 9, 2018 Abstract Language analysis features offered by integrated development environments (IDEs) can ease and accelerate the task of writing code, but are often not available for domain-specific languages. The Language Server Protocol (LSP) aims to solve this problem by allowing language servers that support these features for a certain programming language to be used portably in a number of IDEs. A language server for Serialization Killer Language (SKilL) was implemented that supports a multitude of language features including automatic formatting, completion suggestions, and display of references and documentation associated with symbols. This thesis presents how the language server was implemented and discusses associated challenges that arose due to the nature of the SKilL and LSP specification. 3 Kurzfassung Sprachunterstützungen von IDEs können Programmierern ihre Arbeit deutlich erleichtern, jedoch werden diese oft nicht für domänenspezifische Sprachen unterstützt. Das LSP erlaubt Unterstützun- gen für eine Sprache durch einen Language Server zu implementieren, der anschließend in einer Vielzahl an IDEs nutzbar ist. Es wurde ein Language Server für SKilL implementiert, mit dem unter anderem Code automatisch formatiert, Vervollständigungen vorgeschlagen sowie Verweise und Dokumentation angezeigt werden kann. In dieser Ausarbeitung wird das Vorgehen und dabei aufgekommene Herausforderungen durch die SKilL und LSP Spezifikation diskutiert. 4 Contents 1 Introduction 7 1.1 Motivation ...................................... 7 1.2 Outline ....................................... 7 2 The Language Server Protocol 9 2.1 Overview .....................................
    [Show full text]
  • An LSP Infrastructure to Build EMF Language Servers for Web-Deployable Model Editors⋆
    An LSP infrastructure to build EMF language servers for Web-deployable model editors? Roberto Rodriguez-Echeverria1, Javier Luis Canovas´ Izquierdo2, Manuel Wimmer3, and Jordi Cabot4 1 Quercus SEG, Universidad de Extremadura, Caceres,´ Spain [email protected] 2 UOC, Barcelona, Spain [email protected] 3 CDL-MINT, TU Wien, Vienna, Austria [email protected] 4 ICREA – UOC, Barcelona, Spain [email protected] Abstract. 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 graph- ical 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 in- stances. 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 introduce a novel LSP infrastructure to simplify the de- velopment 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. More concretely, in this work, we present the architecture of our LSP infrastructure, based on LSP4J, to build EMF-based graphical language servers. Keywords: Domain-Specific Languages, Language Server Protocol, Modeling Editors 1 Introduction In the last years, there is an increasing interest to move the modeling editing support to the Web (e.g., Eclipse Che5 or Theia6), which gives new opportunities, but at the same time, opens new risks and challenges.
    [Show full text]
  • Language-Independent Development Environment Support for Dynamic Runtimes
    Language-Independent Development Environment Support for Dynamic Runtimes Daniel Stolpe Tim Felgentreff Christian Humer Hasso Plattner Institute Oracle Labs Oracle Labs University of Potsdam Potsdam, Germany Zurich, Switzerland Potsdam, Germany [email protected] [email protected] [email protected] potsdam.de Fabio Niephaus Robert Hirschfeld Hasso Plattner Institute Hasso Plattner Institute University of Potsdam University of Potsdam Potsdam, Germany Potsdam, Germany [email protected] [email protected] Abstract CCS Concepts • Software and its engineering → In- There are many factors for the success of a new programming tegrated and visual development environments; Soft- language implementation. Existing language implementa- ware maintenance tools. tion frameworks such as Truffle or RPython have focused Keywords Language Server Protocol, Truffle, Graal on run-time performance and security, or on providing a ACM Reference Format: comprehensive set of libraries. Daniel Stolpe, Tim Felgentreff, Christian Humer, Fabio Niephaus, The tools that language users need to be productive are and Robert Hirschfeld. 2019. Language-Independent Development also an important factor for the adoption of a programming Environment Support for Dynamic Runtimes. In Proceedings of language. The aforementioned frameworks, however, pro- the 15th ACM SIGPLAN International Symposium on Dynamic Lan- vide limited support for creating comprehensive develop- guages (DLS ’19), October 20, 2019, Athens, Greece. ACM, New York, ment tools. This is an impediment to language adoption that NY, USA, 11 pages. https://doi.org/10.1145/3359619.3359746 can be as serious as performance issues or lack of libraries. Both Truffle and RPython already provide run-time tools 1 Introduction such as for debugging, profiling, or coverage in a language- As use-cases evolve, so do programming languages to deal independent manner, but neither support static development with the rising complexity of modern software systems.
    [Show full text]
  • Language Server Protocol for Extendj
    Language Server Protocol for ExtendJ Fredrik Siemund Daniel Tovesson D15, Lund University, Sweden C15, Lund University, Sweden [email protected] [email protected] Abstract ExtendJ extension outputs the errors in JSON format instead Microsoft’s Language Server Protocol (LSP) has been im- of a sequence of strings. Finally, the IDEs were configured plemented with ExtendJ in two widely popular Integrated to make use of the language server created. This improved Development Environments (IDE), Eclipse and Sublime Text. the process of developing in Java by providing the developer LSP is a way of supplying high level support — such as with better feedback in the editor. The work was evaluated code completion, hover tooltips, jump-to-definition and find- by demonstrating the validation features implemented in references — for a programming language in a wide variety the language server. The language server was tested with of editors. ExtendJ is an extensible compiler for Java, speci- Eclipse and Sublime Text, which both worked well. fied using reference attribute grammars. Because of thetime limit of the project, only error checking was implemented. As 2 Background the user writes Java code, the IDEs will highlight erroneous 2.1 Language Server Protocol code and thereby simplify the process of finding errors. On LSP is used to provide syntax highlighting and/or validation the client side, this was done by configuring two extensions, for a specific language. As mentioned8 in[ ], you need a client one for each IDE. On the server side, a language server was and a server. The client, in this case an IDE, sends notifica- created that compiles the file with ExtendJ every time itis tions to the server whenever some predefined events happen, changed by the user to search for compilation errors.
    [Show full text]
  • Toward a Multi-Language and Multi-Environment Framework for Live Programming
    Toward a Multi-Language and Multi-Environment Framework for Live Programming Hidehiko Masuhara Shusuke Takahashi Yusuke Izawa Youyou Cong [email protected],ftakahashi,[email protected],[email protected] Tokyo Institute of Technology Abstract other words, live programming still needs to be expanded While applications of live programming are expanding to wider ranges of domains in the following respects. to more practical and professional domains, most live ∙ Most LPEs support a single programming language, programming environments (LPEs) are still developed sometimes a newly designed language (e.g., [5, 6]). for a single target language with an original code editor. Constructing LPEs for the real programmer's fa- We propose an implementation framework for developing vorite languages requires a considerable amount of LPEs so that we can minimize efforts on implementing effort. an LPE for a different target language and an existing ∙ Most LPEs are developed as their own program- code editor/IDE. Our idea is to use a meta-JIT lan- ming environments. Bringing the LP features to guage implementation framework (e.g., Graal/Truffle the real programmer's favorite programming en- and RPython) and LSP to separate core live program- vironments is not easy especially by considering ming implementations from language-specific and edi- the number of different programming environments tor/IDE specific implementations. This paper takes the used in practice. Kanon live programming environment as a concrete ex- The reasons that make LPEs remain in specific languages ample and discusses how we can design the framework and environments are that LPEs require tight integration to accommodate the features of Kanon.
    [Show full text]
  • Language Server Protocol Sublime
    Language Server Protocol Sublime Earthquaked and troubled Bryn parachuted his barmaids rules hitch sinistrorsely. Anorectal Reinhold immolates apathetically. Biographic and adorned Javier never swears blindingly when Garv disdain his pederasts. The console in danger in data structures used java, small server protocol Within a language server on sublime text is running in sublime, although that can not attempt to your browser only span for me please tell clients. The server protocol for servers for other things would like? Sublime Text code editor. Wait for language server protocol client side. You can do this in two ways. Ibm again implemented in near future. Represents reasons for signature information would be run on sublime project is deprecated property filled shown at least four other languages for everyone for. The document highlight event is duplicate from the client to the server to retain a document highlights for instance given text document position. This protocol has no, language server protocol sublime, sublime looks great to a lot of that these languages are only have choices will be inserted is focused on spec and etc. This is sublime text document symbols within this symbol containing details about language server protocol sublime text edits are complex systems that automatically generating getters and close to improve npm or an advantage from? The full target range of this link. Is there anyone currently working on support for this? What are these white circles in Nevada? For more info about the coronavirus, it propagate a nice looking theme that agrees with my eyes. JSON encoded payload following RPC specification.
    [Show full text]
  • A Language Server and IDE Plugin for Cpachecker
    Institute of Informatics Ludwig-Maximilians-Universit¨atM¨unchen A Language Server and IDE Plugin for CPAchecker Bachelor Thesis Adrian Leimeister Supervisor Prof. Dr. Dirk Beyer Mentor Thomas Lemberger Submission Date March 30th 2020 Declaration of Authorship I hereby confirm that I have written the accompanying thesis by myself, without contributions from any sources other than those cited in the text. Eidesstattliche Erkl¨arung Hiermit versichere ich, dass ich die vorliegende Arbeit selbst¨andigver- fasst habe und keine anderen als die angegebenen Quellen und Hilfsmittel verwendet habe. Ort, Datum Unterschrift 1 Abstract Formal verification of software is an useful addition to testing when trying to eliminate unwanted behavior and errors. Multiple approaches for formal verification exist, such as model checking or program analysis, for which a multitude of different tools exist. CPAchecker is a tool that makes it possible to combine advantages of both model checking and program analysis, and can be extended to include new verification ideas. With modern powerful, feature rich In- tegrated Development Environments (IDEs), most development tools are easy to integrated into a development workflow, but most verifi- cation tools are only available as commandline tools or via web inter- faces. The solution proposed is an implementation of formal verification into IDEs with the help of the Language Server Protocol (LSP). This is realized by implementing the interfacing with CPAchecker as a LSP server, with accompanying plug-in for an IDE, for which Eclipse CDT for C/C++ Developers was chosen. The implementation is based on the Microsoft LSP, which means it can be used to implement the func- tionality for other IDEs with less effort.
    [Show full text]
  • Moving Model Driven Engineering from Eclipse to Web Technologies
    Moving Model Driven Engineering from Eclipse to Web Technologies Sören Domrös Master’s Thesis November 15, 2018 Prof. Dr. Reinhard von Hanxleden Real-Time and Embedded Systems Group Department of Computer Science Kiel University Advised by Alexander Schulz-Rosengarten Selbstständigkeitserklärung Hiermit erkläre ich, dass ich die vorliegende Arbeit selbstständig verfasst und keine anderen als die angegebenen Quellen und Hilfsmittel verwendet habe. Kiel, iii Abstract Eclipse is a popular IDE for model-driven-development. It is a current trend to move IDEs to the web. Web technologies enable to use flexible frameworks for UI development. Moreover, they enable container-based development. An IDE can be used in the web with nothing more than a browser with zero configuration and setup time. Web IDEs need separation between business logic and UI, which is not facilitated by Eclipse. The academic KIELER project is an Eclipse-based IDE for model-driven engineering of SCCharts and other synchronous languages. KIELER can only run as a desktop application and still uses a SWT-based UI. A migration to web technologies seems promising and provides new opportunities for Human Computer Interaction (HCI). Web technologies enable to design applications, which run in the web or locally as an Electron app. In this thesis the Theia framework is used to migrate KIELER from Eclipse to a client server archi- tecture called KEITH using the Language Server Protocol (LSP). The already existing implementation of KIELER is reused to generate a language server backend using Xtext. The LSP and Xtext allow to support KIELER and KEITH development at the same time.
    [Show full text]
  • Visual Studio Code
    Eclipse Demo Camp, Zürich 2018 Tools in Action Visual Studio Code Martin Aeschlimann Senior Software Engineer Microsoft Visual Studio Code https://code.visualstudio.com/ A lightweight, fast, extensible editor Runs on MacOS, Linux and Windows Free and open source: https://github.com/Microsoft/vscode Since 2015 new release every month A strong community of more than 1M dedicated users (>10d/month). Marketplace with >6’600 extensions Editors IDEs keyboard centric project systems lightweight/fast integrated build file/folders code understanding many languages debug VS Code templates, wizards designers keyboard centric ALM integration lightweight/fast file/folders many languages code understanding debug More than an editor Integrates • Debugging • Source Control Management • Terminal Not an IDE No wizards No built-in project system No built-in build system Multi Language Offer first class support for an ever-increasing array of languages Rich language support, built-in or through extensions: JavaScript, TypeScript, C#, C++, CSS, F#, Go, HTML, Java, JSON, LESS, Markdown, PHP, Powershell, Python, SCSS Over 1500 language extensions in the Marketplace. Degrees of Language Support Syntax highlighting Brackets, Indentation Rules, Comment Rules, Snippets Document symbol, Color decorators, Formatting, Syntax validation Hovers, Code assist, Code actions, Semantic validation Find references, Code lens, Rename, Workspace symbols Debugger Integration The Matrix Problem for Language Providers Java Rust TS C++ JSON Java Rust TS C++ JSON VS Code VS Code
    [Show full text]
  • Automated Refactoring of Rust Programs
    Automated Refactoring of Rust Programs Algorithms and implementations of Extract Method and Box Field Per Ove Ringdal Thesis submitted for the degree of Master in Informatics: programming and systems architecture 60 credits Department of Informatics Faculty of mathematics and natural sciences UNIVERSITY OF OSLO Spring 2020 Automated Refactoring of Rust Programs Algorithms and implementations of Extract Method and Box Field Per Ove Ringdal c 2020 Per Ove Ringdal Automated Refactoring of Rust Programs http://www.duo.uio.no/ Printed: Reprosentralen, University of Oslo Abstract Refactoring is the practice of changing code without altering its behavior. Rust is a language with an ownership model where lifetimes are statically resolved and it has macro support. In this thesis we develop algorithms and implementations for the Extract Method and Box Field refactorings for Rust. Automated refactoring tools are often not correct. Here we compose the refactorings by smaller micro refactorings which can easily be understood independently. We ran the implementation on open source projects, identified problems with lifetimes, and handled it correctly. v vi Contents 1 Introduction 1 2 Background 5 2.1 Compiler theory for refactoring . .5 2.2 The Rust programming language . .6 2.2.1 Structs . .6 2.2.2 Functions . .6 2.2.3 Types . .6 2.2.4 Ownership and borrowing . .7 2.2.5 Packages, Crates and Modules . .8 2.2.6 Cargo . .8 2.2.7 Declarative Macros . .9 2.2.8 Procedural Macros . .9 2.3 Refactoring support for Rust . 10 2.3.1 Rust language server . 10 2.3.2 Clippy . 11 2.3.3 Rustfmt .
    [Show full text]
  • The Specification Language Server Protocol
    The Specification Language Server Protocol: A Proposal for Standardised LSP Extensions Jonas Kjær Rask Frederik Palludan Madsen Nick Battle DIGIT, Aarhus University, Department of Electrical and Computer Engineering, Independent Finlandsgade 22, 8200 Aarhus N, Denmark [email protected] [email protected] [email protected] Hugo Daniel Macedo Peter Gorm Larsen DIGIT, Aarhus University, Department of Electrical and Computer Engineering, Finlandsgade 22, 8200 Aarhus N, Denmark [email protected] [email protected] The Language Server Protocol (LSP) changed the field of Integrated Development Environments (IDEs), as it decouples core (programming) language features functionality from editor smarts, thus lowering the effort required to extend an IDE to support a language. The concept is a success and has been adopted by several programming languages and beyond. This is shown by the emergence of several LSP implementations for the many programming and specification languages (languages with a focus on modelling, reasoning, or proofs). However, for such languages LSP has been ad-hocly extended with the additional functionalities that are typically not found for programming languages and thus not supported in LSP. This foils the original LSP decoupling goal, because the move towards a new IDE requires yet another re-implementation of the ad-hoc LSP extension. In this paper we contribute with a conservative extension of LSP providing a first proposal towards a standard protocol decoupling the support of specification languages from the IDE. We hope our research attracts the larger community and motivates the need of a joint task-force leading to a standardised LSP extension serving the particular needs of specification languages.
    [Show full text]
  • The Impact of the Language Server Protocol on Textual Domain-Specific Languages
    Decoupling Language and Editor - The Impact of the Language Server Protocol on Textual Domain-Specific Languages Hendrik Bunder¨ itemis AG, Bonn, Germany Keywords: Textual Domain-Specific Languages, Model-Driven Development, Language Server Protocol, Case Study. Abstract: Model-Driven Software Development using Domain-Specific Languages (DSL) has been widely adopted throughout research and industry. The language workbenches required to efficiently build Domain-Specific Languages and the associated editor support are often deeply integrated into a specific Integrated Development Environment (IDE). Thereby, the chosen Domain-Specific Language workbench predicts the IDE required to use the DSL. Yet, this IDE might not be the best choice for further implementing, testing, and debugging the generated code. A case study was conducted to analyze how the Language Server Protocol could be utilized to decouple the DSL implementation from a specific editor integrated into an IDE. First, the Language Server Protocol capabilities are exemplified by building editor support for an Entity-DSL that is integrated into two different IDEs. Second, a SWOT analysis is carried out to identify strengths and weaknesses as well as oppor- tunities and threats for Domain-Specific Languages utilizing the Language Server Protocol. The case study’s results indicate that the Language Server Protocol enables efficient multi-editor integration. Further, the results of the SWOT analysis imply potential benefits for cross-functional teams specifying a shared domain model. 1 INTRODUCTION liJ (JetBrains, 2018) or Eclipse (Vogel and Beaton, 2013). While the deep integration enables semi- Model-Driven software development focuses on the automatic, efficient creation of language editors, it abstract, formal description of domain models, that also causes a tool lock-in by interweaving the DSL declaratively describe real-world concepts.
    [Show full text]