Developing Software with Domain-Driven Model Reuse

Developing Software with Domain-Driven Model Reuse

Audris Kalnins (University of Latvia, Latvia), Tomasz Straszak (Warsaw University of Technology, Poland), Michał Śmiałek (Warsaw University of Technology, Poland), Elina Kalnina (University of Latvia, Latvia), Edgars Celms (University of Latvia, Latvia) and Wiktor Nowakowski (Warsaw University of Technology, Poland)
DOI: 10.4018/978-1-4666-6359-6.ch012
OnDemand PDF Download:
$37.50

Abstract

This chapter presents an approach to software development where model-driven development and software reuse facilities are combined in a natural way. It shows how model transformations building a Platform Independent Model (PIM) can be applied directly to the requirements specified in RSL by domain experts. Further development of the software case (PSM, code) is also supported by transformations, which in addition ensure a rich traceability within the software case. Alternatively, the PSM model and code can also be generated directly from requirements in RSL, thus providing fast development of the final code of at least a system prototype in many situations. The reuse support relies on a similarity-based comparison of requirements for software cases. If a similar part is found in an existing software case, a traceability link-based slice of the solution can be merged into the new case. The implementation of the approach is briefly sketched.
Chapter Preview
Top

Introduction

Some of the most significant cornerstones for state-of-the art software development are model driven development (MDD) and software reuse. There is a lot of success in applying them separately, but only very few approaches try to combine them. The proposed approach provides a tight natural integration of both – “a model driven reuse”. The third equally important cornerstone is an adequate facility for specifying requirements to the software system being developed. Only in this way a complete MDD life cycle can be supported, where the use of models starts from the “very beginning”. This approach is based on a special Requirements Specification Language (RSL). This language is semiformal in the sense that it is close to a natural language and understandable to non-IT specialists, but on the other hand it has a meaning precise enough to be processed by model transformations and reuse mechanisms. Consequently, a true model driven development is possible, where the initial version of the next model in the chain is built from the previous one by model transformations. In totality, these models form a software case. Thus, there is an automatic transformation supported path from requirements to code. All these models play an important role in the reuse process.

More precisely, requirements in RSL consist of two related parts. The domain concepts to be used in the requirements are described in a domain vocabulary. This domain vocabulary serves as a semiformal easy readable equivalent of the domain class model. The meaning of domain elements can be specified by means of links to corresponding WordNet (Fellbaum, 1998) entries. The domain model serves as the basis for the other part of requirements – the required system behaviour description. This description is centred on use cases. The distinctive feature of RSL is that a use case is refined by one or more scenarios in a simple controlled language. Each noun within a scenario sentence must be defined in the domain vocabulary, thus the whole sentence gets a precise meaning. In addition to use cases, non-functional requirements to the system can be described by natural language sentences, using hyperlinks to the same vocabulary. The precise syntax of RSL is described by a metamodel. It will be described in more detail in the next section.

Due to separation of notions and their operations from use cases containing sequences of imperative Subject-Predicate sentences containing only links to the phrases in the vocabulary, RSL models capture the domain logic of the system at a high level of abstraction. At the same time, the domain logic is the foundational basis to specify the application logic describing the observable interaction of the users with the system. Requirements models expressed with the RSL characterize the essential (inherent) complexity of the software system, while accidental (technical) complexity comes from implementation aspects of these requirements (Nowakowski, Śmiałek, Ambroziewicz & Straszak, 2013). In the classical MDA model chain (Object Management Group, 2003) a requirements model in RSL can be treated as a Computional Independent Model (CIM).

When the software case development starts, the requirements model is transformed into the initial version of the Platform Independent Model (PIM) and the Platform Specific Model (PSM) in the selected subset of UML. The static structure of these models is generated from the domain vocabulary within requirements. Consequently, the whole structure of the system, especially its business logic and data access layers, depend on this domain. Thus a true domain driven design is supported. An initial version of the behaviour is obtained by transformations analyzing the use case scenarios, thus aspects of use case driven design are also present. Having the PSM models generated, the initial code for the system can be produced. The precise contents of the generated models depend on the selected transformation profile for the software system to be developed. Model transformation profiles supporting several architecture styles have been developed. More details on the transformation-assisted software case development will be given in section “Definition of software cases”. For software systems with a relatively simple behaviour, the proposed transformations can generate a nearly complete code of the system, at least at the prototype level. Thus a “smart definition” of requirements in RSL comes close to the usage of RSL as a sort of domain specific language (DSL) based on controlled natural language for the development of simple web-based information systems. The possibilities to describe the system behaviour in RSL are, for example, much richer than those of DSL examples in Brambilla, Cabot & Wimmer (2012).

Key Terms in this Chapter

ReDSeeDS: Requirements Driven Software Development.

Model Transformation: Derivation of one model from another.

Software Reuse: An approach of using once produced software artifacts in the new projects.

Domain-Driven Development: Software producing approach focused on reflecting the reality in models of the system.

Metamodel: Rules, constraints, models and theories applicable for modeling a predefined class of problems; is basis for automatic model transformations.

RSL: Requirements Specification Language.

MDA: Model Driven Architecture, software design approach where all design artefacts in form of models should be integrated into the software lifecycle by automatic transformations that are used to convert one model into another.

Complete Chapter List

Search this Book:
Reset