Kevoree Modeling Framework (KMF): Efficient modeling techniques for runtime use

The creation of Domain Specific Languages(DSL) counts as one of the main goals in the field of Model-Driven Software Engineering (MDSE). The main purpose of these DSLs is to facilitate the manipulation of domain specific concepts, by providing developers with specific tools for their domain of expertise. A natural approach to create DSLs is to reuse existing modeling standards and tools. In this area, the Eclipse Modeling Framework (EMF) has rapidly become the defacto standard in the MDSE for building Domain Specific Languages (DSL) and tools based on generative techniques. However, the use of EMF generated tools in domains like Internet of Things (IoT), Cloud Computing or Models@Runtime reaches several limitations. In this paper, we identify several properties the generated tools must comply with to be usable in other domains than desktop-based software systems. We then challenge EMF on these properties and describe our approach to overcome the limitations. Our approach, implemented in the Kevoree Modeling Framework (KMF), is finally evaluated according to the identified properties and compared to EMF.Comment: ISBN 978-2-87971-131-7; N° TR-SnT-2014-11 (2014

Integration of Visual Languages with SCS tools in the Software Development Industry

Source Control Systems (SCS), also known as Version Control Systems (VCS), help teams to organize and track changes in the software development process. These systems have become vital in the software development industry as the increased growth and geographical diversity of teams, forced them to find solutions to deal with multiple people accessing the same pieces of software concurrently. Although for a while SCS seemed to be coping well with the needs of software development, the rise of the low-code platforms and Visual Programming Languages (VPLs) brought a new challenge to version control: how to manage visual artifacts without losing SCS functionalities? The biggest cause of this challenge is the fact that SCS are mostly oriented to work with text-based programming languages. Thus text-oriented SCS are (in general) incapable of dealing with visual artifacts as well as they do with text. So, to cope with the loss of SCS functionalities in VPLs projects, teams either accept and work with this loss or are forced to come up with a solution of their own to tackle a specific version control problem. These issues can be found in the OutSystems platform, which is our case study. To solve this problem, we propose a system, termed OSGit, that acts as a man-in-themiddle between the low-code platform and the designated SCS. The proposed system will translate the requested version control operations from the low-code platform to native operations of the given SCS. In operations that require visual artifacts to be managed - like applying blames - we propose the creation of metadata files. The metadata files contain the needed information about the visual elements used to build applications in the lowcode platform. This information is thus a compacted representation of the visual elements through text. Therefore, using metadata files will allow the SCS to correctly handle the required visual artifacts while integrating this system with a low-code platform or a VPL. The produced system obtained auspicious results in the usability tests that were performed and that featured ten OutSystems developers. They showed great satisfaction when using OSGit and also gave suggestions for future improvements. OSGit bridges the gap between text-based SCS and visual artifacts, which proves the possibility of integrating these systems in the world of VPL with a high-level of user satisfaction

Model-Driven Development for Spring Boot Microservices

As microservices become more and more common, there is more interest in optimizing their development, making it faster, reducing the complexity and making it less error and bug prone. This work aims to explore how Model-driven Engineering (MDE) can be used to aid microservices’ development, especially Java microservices using Spring Boot. Firstly, this work starts by presenting its context, with a brief introduction to MDE and microservices, and how MDE can be used to facilitate microservices’ development. Then the State of the Art presents MDE base technologies and MDE-based solutions that can be used to develop microservices. Furthermore, a value analysis was also done, to explore the benefits of using MDE, and to define its value proposition. Lastly, a case study was elaborated following three different approaches, traditional development, DSL-based approach, and MDE-based tool approach, which were then compared by code quality and time required for development of the microservices. This work is especially interesting for someone who wants to develop Java microservices and wants to explore the different approaches and technologies to do so, namely by using MDE.À medida que os microserviços se tornam cada vez mais comuns, há mais interesse em otimizar seu desenvolvimento, otimizando o tempo de desenvolvimento, reduzindo a complexidade e tornando-o menos sujeito a erros e bugs. Este trabalho tem como objetivo explorar como é que Model-driven Engineering (MDE) pode ser usado para auxiliar o desenvolvimento de microserviços, especialmente microserviços Java usando Spring Boot. Em primeiro lugar, este trabalho começa apresentando seu contexto, com uma breve introdução ao MDE e microserviços, e explicando como é que MDE pode ser usado para facilitar o desenvolvimento de microserviços. Em seguida é apresentado o Estado da Arte, que apresenta tecnologias base de MDE e soluções baseadas em MDE (ferramentas), que podem ser utilizadas para desenvolver microserviços. Além disso, também foi feita uma análise de valor para explorar os benefícios do uso de MDE, e para definir sua proposta de valor. Por fim, foi elaborado um caso de estudo através de três abordagens diferentes, desenvolvimento tradicional, abordagem baseada em DSL, e abordagem utilizando uma ferramenta baseada em MDE, que foram então comparadas através da qualidade do código e pelo tempo necessário para o desenvolvimento dos microserviços. Este trabalho é especialmente interessante para quem quer desenvolver microsserviços Java e quer explorar as diferentes abordagens e tecnologias para o fazer, nomeadamente através da utilização de MDE