A messaging based IDE Bachelorarbeit zur Erlangung des Grades eines Bachelor of Science im Studiengang Informatik vorgelegt von Thies Möhlenhof Erstgutachter: Prof. Dr. Ralf Lämmel Institut für Informatik Zweitgutachter: Msc. Marcel Heinz Institut für Informatik Koblenz, im September 2016 Erklärung Hiermit bestätige ich, dass die vorliegende Arbeit von mir selbständig ver- fasst wurde und ich keine anderen als die angegebenen Hilfsmittel – ins- besondere keine im Quellenverzeichnis nicht benannten Internet–Quellen – benutzt habe und die Arbeit von mir vorher nicht in einem anderen Prü- fungsverfahren eingereicht wurde. Die eingereichte schriftliche Fassung entspricht der auf dem elektronischen Speichermedium (CD-Rom). Ja Nein Mit der Einstellung der Arbeit in die Bibliothek bin ich ein- verstanden. Der Veröffentlichung dieser Arbeit im Internet stimme ich zu. ................................................................................ (Ort, Datum) (Thies Möhlenhof) Zusammenfassung Moderne Softwareentwicklungsumgebungen (z.B. Eclipse, IntelliJ) bestehen aus verschiedensten Programmen bzw. Werkzeugen, welche zu einer integrierten En- twicklungsumgebung zusammengefasst werden. Dies wird durch eine spezielle Plug-in-Architektur, auf der Basis einer speziellen Programmierschnittstelle für jede Entwicklungsumgebung, realisiert. Dadurch entsteht eine große Abhängigkeit der Plug-ins zu einer bestimmten Entwicklungsumgebung und diese können so nicht in verschiedenen Entwicklungsumgebungen wiederverwendet werden. Die in dieser Arbeit beschriebene Microservice Architektur, bietet die Möglichkeit diese Struktur aufzubrechen und die so entstehenden Komponenten, durch textuelle Nachrichten zu verbinden. Dadurch wird die Integration von neuen Werkzeugen vereinfacht, da die Abhängigkeit zu einer speziellen Programmierschnittstelle der jeweiligen Entwicklungsumgebung aufgelöst wird. Das Konzept des Aufteilens der verschiedenen Werkzeuge auf mehrere kleine Programme, wird durch das Monto Projekt [44] eingehend beschrieben, welches als Grundlage dieser Arbeit dient. Abstract Modern Integrated Development Environments (IDEs) are, in general, a combina- tion of a textual editor, build tools and other services, which are combined by a plugin architecture. As a result, these services are in a deep correlation and depend on an Application Programming Interface (API) tailored to a specific IDE approach (e.g., Eclipse, IntelliJ). In this thesis, an architecture is presented, which breaks up this monolithic architecture and provides an expandable microservice architecture providing the same features by a correlation of services, inspired by the Monto Project [44], without the dependency to a specific editor or API. As a result, the integration of new services is simplified and services are reusable in different IDE approaches. Contents 1 Acknowlegement1 2 Introduction2 3 Related work5 3.1 Language workbenches.........................5 3.2 Kite.....................................7 3.3 Monto....................................7 3.4 NeoVim...................................8 3.5 Summary..................................8 4 Background9 4.1 Microservice Architecture........................9 4.2 Docker................................... 11 4.3 Service Discovery............................. 15 4.3.1 Consul............................... 16 4.3.2 etcd................................. 16 4.4 FSML Finite State Machine Language................. 17 5 Requirements 20 5.1 Architecture Requirements Specification (ARS)............ 21 5.2 User Requirements Specification (URS)................ 22 6 Design 28 6.1 Architecture Overview.......................... 29 6.2 Detailed Architecture........................... 30 6.2.1 Client Application........................ 31 i CONTENTS ii 6.2.2 Consul Server Node....................... 32 6.2.3 Service Node........................... 33 6.3 Highlighting Request Example..................... 35 7 Implementation 38 8 Requirement Analysis 41 9 Concluding remarks 43 9.1 Summary.................................. 43 9.2 Analysis.................................. 43 9.3 Future work................................ 45 List of Figures 3.1 Monto architecture............................7 4.1 Docker client-server architecture.................... 11 4.2 Docker example.............................. 13 4.3 Docker Swarm cluster example..................... 14 5.1 Syntax highlighting example...................... 22 5.2 Code formatting example........................ 23 5.3 Autocompletion example........................ 24 5.4 Code outline example.......................... 25 5.5 Input dialog example........................... 26 5.6 Output dialog example.......................... 26 5.7 Error message example.......................... 27 6.1 General architecture overview...................... 29 6.2 Architecture overview in detail..................... 30 6.3 Client application in detail........................ 31 6.4 Consul node in detail........................... 32 6.5 Service node in detail........................... 34 6.6 Highlight request example........................ 37 iii Chapter 1 Acknowlegement I would like to thank my family, friends and Prof. Dr. Ralf Lämmel for supporting me in my studies and this thesis. 1 Chapter 2 Introduction This technical elaboration is concerned with disintegration of features provided by an Integrated Development Environment. The fundamental idea is described by Sloane et. al [44]. An essential part in the daily life of a software developer are Integrated Devel- opment Environments (IDE). These environments are a great way to enhance the productivity of a developer, because they provide a large variety of tools and features, to help create correct and secure computer programs. Over the years many different approaches became popular (e.g., [1], [2]), these environments are established by a large community and generations of software developers. The features provided by a modern IDE are ranging from syntactic and semantic services [24], to project management services (e.g., [3]). Syntactic services, for in- stance, provide source code highlighting or syntactic source code completion for textual editors. Furthermore, they help to abstract the software development pro- cess, by enabling visual modeling and generating source code from model to text transformation. Moreover, IDEs include tools for collaborative work like version control [4] or even realtime messaging [5] making collaborative software devel- opment effortless. However, these services and tools are in a deep correlation, because they depend on a specific, well defined API for the target IDE approach. Therefore, it can be difficult to add new functionality to these environments and combine them with the already existing ones. These functionalities are mostly provided via plugins 2 3 [6], which are not reusable between different IDEs. Consequently, a language de- signer who, for example, wants to provide tooling for a novel language or new technologies to tackle new sets of problems, which differ from the common prob- lems, like testing or monitoring service oriented architectures encounters prob- lems. The designer needs to provide a special designed plugin for every IDE approach to make the new tool or language widely usable. The more and more popular concepts of distributed, service oriented architec- tures can be a solution, to decouple the components of an IDE, thus the integra- tion and disintegration of new components is simplified in contrast to the modern integrated approach. In recent work, named the Monto Project [44], this novel ap- proach is introduced. The Monto project provides a way to decouple the services of an IDE, by implementing them stand alone and combining them via textual messaging, thus a flexible and simple integration or disintegration is fulfilled. The overall idea of this concept, is to decouple the different components and pro- vide an environment, so the different components are able to work together by sending and receiving messages over a messaging based middleware. Thereby, an integration or disintegration of services or tools is plainly fulfilled. This new environment is called a Disintegrated Development Environment (DDE), which pro- vides the look and feel of a common IDE, but the different components are flex- ible, reusable, independent and simply interchangeable. Furthermore, what are the advantages and disadvantages of decomposing the features provided by an IDE, thus a simpler and faster integration of new features and functionalities is possible, in contrast to the common monolithic approach? Moreover, can the collaboration of the decomposed features be fulfilled by an established internet protocol and an entrenched messaging format like JSON or XML, to be as inde- pendent as possible from an underlining technology? This concept can be a great leap, because new and old features can be added faster and every software de- veloper is free to choose the editor he or she prefers. As a result, new languages or technologies can be spread faster with appropriate tooling and plugins do not need to be implemented multiple times for every IDE approach. In this thesis, the idea of a DDE is adopted and a different approach is presented. The approach presented, particular emphasis the independence of each service in regard to its deployment to an infrastructure, which is maintainable and expand- 4 able. Moreover, the implementation of each service is independent to a specific IDE Plug-in Architecture. The structure