Developing Software with Domain-Driven Model Reuse

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).