Toward a Unified Framework for Quality and Consistency Verification of UML Models

Model-Driven Development (MDD) is an emergent approach to software engineering which is based on the systematic use of software modeling as a primary form of expression. The central focus in MDD is on models, as opposed to source code in the traditional conception of software development. However the introduction of models in the software life cycle poses new issues and challenges that current state-of-the-art development tools do not support adequately. In this paper we investigate some of these challenges, taking into account the role played by models. Then we propose a unified framework which integrates different verification methods with the intent to check (UML) models against consistency issues and design defects. Our approach aims to integrate traditional techniques with model-based ones, keeping the advantages of both static and dynamic verification methods in order to increase the proficiency of the MDD activities. Model-Driven Development (MDD) is an emergent approach to software engineering which is based on the systematic use of software modeling as a primary form of expression. The central focus in MDD is on models, as opposed to source code in the traditional conception of software development. However the introduction of models in the software life cycle poses new issues and challenges that current state-of-the-art development tools do not support adequately. In this paper we discuss some of these challenges and how the practice of MDD affects software development tools. We start analyzing the role of models, that are a better medium than source code to express abstractions, which are the fundamental element of the software engineering practice [14,24]. Then we proceed addressing other issues concerned with models, the traditional activities of design, validation and verification (V&V). Taking into account these challenges allow us to identify the key features for developing a unified framework suitable to tailor the development process in the context of model-driven development environments, with particular attention to UML models. 1 Challenges of Model-Driven Development 1.1 Models should be the ubiquitous language in software development The core of software development is the design of abstraction. A good set of abstraction discovered during analysis and design stages form a vocabulary which is recognized as a valuable resource for analysts, software architects, and developers. Software patterns are a good example of such a vocabulary. The challenge is to see even models as the backbone of that ubiquitous language. Indeed they commit the development team to exercising that vocabulary in all communications using diagrams, writing, and especially speech [8]. With abstractions organized to form a ubiquitous language, the model is not just a design artifact: it becomes integral to everything the developers and the domain experts do together. Moreover, it is the most important place for those aspects of the design which do not appear in code (i.e.,large-scale structures that organize the whole system, conceptual or logical boundaries, and other patterns at architectural or component level). 1.2 The wishful thinking obstacle to build valuable models A typical obstacle that analysts and software architects experiment almost always when they try to implement abstractions in models is the so-called wishful thinking problem [20]. The developer team ends the design phase gathering a collection of names and concepts that seem to be simple and robust, but they turn out to be incoherent, and eventually they crumble in complexity as developers attempt to adapt them when the code changes or grows. This is a recurrent issue intrinsic in the nature of software because it is bounded with the vocabulary which gives shape to the software. Moreover, these flaws escaped at design time become evident (and painful) only during implementation. This is because the environment of programming is so much more “exacting” than the environment of sketching design abstractions [14]. The wishful thinking problem is addressed by the community of software practitioners using different approaches. One of them is rooted around the concept of “emergent design” and is adopted by the agile community, in particular by the eXtreme Programming (XP) movement. It recognizes the risk of wishful thinking and completely eliminates explicit design. The design of software emerges when the code is subject to refactoring. Unit testing and type checking are the tools used to guarantee the (syntactical) correctness and the constant delivery of an executable system. However, this has the unpleasant consequence that any attempt to anticipate problems during the design phase is substantially abandoned. A more suitable approach in the MDD context is referable to the Domain-Driven Design practice [8] which address the wishful thinking problem recognizing that useful models seldom “lies on the surface”. Great models do not just happen. As designers come to understand the domain and the specific needs of the application, they usually discard superficial elements that seemed