REMICS was participating at European Conference on Software Architecture, This Tutorial will be held in Polytech'Montpellier in conjunction with the three co-located conferences (ECMFA, ECOOP and ECSA)
M. Śmiałek, “From Use Cases to Java in a Snap”, Tutorial held at the ECOOP/ECSA/ECMFA 2013 conference. http://www.lirmm.fr/ec-montpellier-2013/?id=158 #tutorial4
Model Driven Software Development promises to shorten the software development lifecycle. This promise is associated with the ability to define software models at one level of abstraction and then to automatically generate more detailed models (including code). In this tutorial we will show that this is possible even from the level of use cases. We will demonstrate how to write use case scenarios that are understandable by business experts in a wide range of domains and at the same time precise enough for automatic transformations. In this demonstration we will apply the Requirements Speciﬁcation Language (RSL) that is deﬁned with a strict meta-model. We will also demonstrate and conduct exercises using a novel tool (ReDSeeDS) that allows for specifying RSL-based models and then translating them into design models and fully dynamic Java code. We will show that from use-case based requirements associated with conceptual domain models, the whole code for the application logic and even the user interface forms, can be produced automatically. Moreover, the domain logic code can be initiated from the requirements-level vocabulary and verb phrases.
In the first part of this tutorial there will be introduced all the elements necessary to form automatically the path from use cases to Java code. In the tutorial we will discuss the pre-requisites for automating the creation of such software cases. Namely, there will be explained the level of precision and extensions needed for the use case models. During this first part, there will be also introduced a case study example - its thematic area and structure.
The second part of the tutorial will present the Requirements Speciﬁcation Language. There will be shown all the important language constructs. The presentation will mostly concentrate on these elements of the language that make it versatile, i.e. suitable for various problem domains. The presentation will also explain how to organise the domain vocabulary and link it with the requirements representations. The tutorial will also briefly explain the definition of the language and its meta-model. In this part, there will be introduced the ReDSeeDS tool (http://www.redseeds.eu/) used throughout the presentation. It will be shown how to use the tool to support precision in defining scenarios and in hyper-linking with the vocabulary. This will include presenting a larger case-study example with several use cases linked through various relationships.
The third part of the tutorial will present the mechanisms enabling automatic translation from RSL models into code. There will be explained general and detailed rules for transformation from requirements to detailed design models. This includes the rules for transforming regular subject-verb-object sentences of use case scenarios. Also the rules for generating decisions within code for condition scenario sentences will be presented. By using these rules, there can be generated partial code of the ﬁnal system. This includes full code skeleton containing all the classes with operations, attributes and other declarations. Moreover, the dynamic code (function calls, decision statements etc.) of the methods at the application logic layer can be generated automatically.
During the tutorial, the above introduced transformations will be performed within the case study example started in the first part. There will be briefly presented the transformation code written in the MOLA language. This code will be run in the ReDSeeDS tool. There will be discussed the results of the transformation visualised within a UML tool and the generated code. There will also be shown these fragments of code (methods for domain logic operations and for the presentation layer) that necessitate additional "manual" programming.
The tutorial will conclude with a discussion on the presented approach. This will be conducted by analysing change to software development practice from the point of view of different roles (analysts, designers and programmers). This analysis will be supported by the results of validation of the presented approach. This validation was performed by several industry organisations within the ReDSeeDS and REMICS Projects (under the 6th and 7th FP of the European Union), and also through comparative experiments with students.