Model-driven architecture

From Wikipedia, the free encyclopedia

Model-driven architecture (MDA) is a software design approach launched by the Object Management Group (OMG)[1] in 2001.

MDA supports model-driven engineering of software systems. MDA provides a set of guidelines for structuring specifications expressed as models. The MDA approach defines system functionality using a platform-independent model (PIM) using an appropriate domain-specific language. Then, given a platform definition model (PDM) corresponding to CORBA, .NET, the Web, etc., the PIM is translated to one or more platform-specific models (PSMs) that computers can run. The PSM may use different Domain Specific Languages, or a General Purpose Language like Java, C#, PHP, Python, etc.[citation needed]. Automated tools generally perform this translation.

The OMG organization provides rough specifications rather than implementations, often as answers to Requests for Proposals (RFPs). Implementations come from private companies or open source groups.

MDA principles can also apply to other areas such as business process modeling where the PIM is translated to either automated or manual processes[citation needed].

Contents

[edit] MDA approach

OMG focuses Model-driven architecture on forward engineering, i.e. producing code from abstract, human-elaborated
specifications[citation needed]. OMG's ADTF (Analysis and Design Task Force) group leads this effort. With some humour, the group chose ADM (MDA backwards) to name the study of reverse engineering. ADM decodes to Architecture-Driven Modernization. The objective of ADM is to produce standards for model-based reverse engineering of legacy systems [2]. Knowledge Discovery Metamodel (KDM) is the furthest along of these efforts, and describes information systems in terms of various assets (programs, specifications, data, test files, database schemas, etc.).

One of the main aims of the MDA is to separate design from architecture. As the concepts and technologies used to realize designs and the concepts and technologies used to realize architectures have changed at their own pace, decoupling them allows system developers to choose from the best and most fitting in both domains. The design addresses the functional (use case) requirements while architecture provides the infrastructure through which non-functional requirements like scalability, reliability and performance are realized. MDA envisages that the platform independent model (PIM), which represents a conceptual design realizing the functional requirements, will survive changes in realization technologies and software architectures.

Of particular importance to model-driven architecture is the notion of model transformation. A specific standard language for model transformation has been defined by OMG called QVT.

[edit] Related standards

The MDA model is related to multiple standards, including the Unified Modeling Language (UML), the Meta-Object Facility (MOF), XML Metadata Interchange (XMI), Enterprise Distributed Object Computing (EDOC), the Software Process Engineering Metamodel (SPEM), and the Common Warehouse Metamodel (CWM). Note that the term “architecture” in Model-driven architecture does not refer to the architecture of the system being modeled, but rather to the architecture of the various standards and model forms that serve as the technology basis for MDA.

[edit] The Executable UML approach

Main article: Executable UML

Executable UML, often abbreviated to xtUML [3] or xUML [4], is the evolution of the Shlaer-Mellor method[5] to UML, it is a specific approach to implement MDA. Executable UML graphically specifies a deterministic system using a profile of the UML. The models are testable, and can be compiled into a less abstract programming language to target a specific implementation. [5] [6] Executable UML supports MDA through specification of platform-independent models, and the compilation of the platform-independent models into platform-specific models. [7]

[edit] MDA tools

The OMG organization provides rough specifications rather than implementations, often as answers to Requests for Proposals (RFPs). The OMG documents the overall process in a document called the MDA Guide.

Basically, an MDA tool is a tool used to develop, interpret, compare, align, measure, verify, transform, etc. models or metamodels.[8] In the following section "model" is interpreted as meaning any kind of model (e.g. a UML model) or metamodel (e.g. the CWM metamodel). In any MDA approach we have essentially two kinds of models: initial models are created manually by human agents while derived models are created automatically by programs. For example an analyst may create a UML initial model from its observation of some loose business situation while a Java model may be automatically derived from this UML model by a Model transformation operation.

An MDA tool may be one or more of the following types[citation needed]:

  • Creation Tool: A tool used to elicit initial models and/or edit derived models.
  • Analysis Tool: A tool used to check models for completeness, inconsistencies, or error and warning conditions. Also used to calculate metrics for the model.
  • Transformation Tool: A tool used to transform models into other models or into code and documentation.
  • Composition Tool: A tool used to compose (i.e. to merge according to a given composition semantics) several source models, preferably conforming to the same metamodel.
  • Test Tool: A tool used to "test" models as described in Model-based testing.
  • Simulation Tool: A tool used to simulate the execution of a system represented by a given model. This is related to the subject of model execution.
  • Metadata Management Tool: A tool intended to handle the general relations between different models, including the metadata on each model (e.g. author, date of creation or modification, method of creation (which tool? which transformation? etc.)) and the mutual relations between these models (i.e. one metamodel is a version of another one, one model has been derived from another one by a transformation, etc.)
  • Reverse Engineering Tool: A tool intended to transform particular legacy or information artifact portfolios into full-fledged models.

Some tools perform more than one of the functions listed above. For example, some creation tools may also have transformation and test capabilities. There are other tools that are solely for creation, solely for graphical presentation, solely for transformation, etc.

One of the characteristics of MDA tools is that they mainly take models (e.g. MOF models or metamodels) as input and generate models as output[citation needed]. In some cases however the parameters may be taken outside the MDA space like in model to text or text to model transformation tools.

Implementations of the OMG specifications come from private companies or open source groups. One important source of implementations for OMG specifications is the Eclipse Foundation. Many implementations of OMG modeling standards may be found in the Eclipse Modeling Framework (EMF) or Graphical Modeling Framework (GMF), the Eclipse foundation is also developing other tools of various profiles as GMT. Eclipse's compliance to OMG specifications is often not strict. This is true for example for OMG's EMOF standard, which Eclipse approximates with its ECORE implementation. More examples may be found in the M2M project implementing the QVT standard or in the M2T project implementing the MOF2Text standard.

Power RAD is being developed by Outline Systems Inc. Microsoft is proposing the DSL tools approach which is a similar approach, not based on OMG standards. Another open source project called AndroMDA provides an extensible framework for generating code using virtually any technology/platform (e.g., .NET, Java, etc.) and is meant to be used repeatedly as part of the build process (i.e., instead of just generating starter code once at the beginning of a project).

One should be careful not to confuse the List of MDA Tools and the List of UML tools, the former being much broader. This distinction can be made more general by distinguishing 'variable metamodel tools' and 'fixed metamodel tools'. A UML CASE tool is typically a 'fixed metamodel tool' since it has been hard-wired to work only with a given version of the UML metamodel (e.g. UML 2.1). On the contrary, other tools have internal generic capabilities allowing them to adapt to arbitrary metamodels or to a particular kind of metamodels.

Usually MDA tools focus rudimentary architecture specification, although in some cases the tools are architecture-independent (or platform independent).

Simple examples of architecture specifications include:

  • Selecting one of a number of supported reference architectures like Java EE or Microsoft .NET,
  • Specifying the architecture at a finer level including the choice of presentation layer technology, business logic layer technology, persistence technology and persistence mapping technology (e.g. object-relational mapper).
  • Metadata: information about data.

[edit] Design methodologies for MDA

MDA requires that design is done in an architecture and technology neutral way. Design methodologies like URDAD have been specifically formulated to generate a UML-based, technology neutral design in the spirit of the MDA.

[edit] MDA concerns

Some key concepts that underpin the MDA approach (launched in 2001) were first elucidated by the Shlaer-Mellor method during the late 1980s. Indeed a key absent technical standard of the MDA approach (that of an action language syntax for Executable UML) has been bridged by some vendors by adapting the original Shlaer-Mellor Action Language (modified for UML)[citation needed]. However during this period the MDA approach has not gained mainstream industry acceptance; with the Gartner Group still identifying MDA as an "on the rise" technology in its 2006 "Hype Cycle"[9], and Forrester Research declaring MDA to be "D.O.A." in 2006[10]. Potential concerns that have been raised with the OMG MDA approach include:

  • Incomplete Standards: The MDA approach is underpinned by a variety of technical standards, some of which are yet to be specified (e.g. an action semantic language for xtUML), or are yet to be implemented in a standard manner (e.g. a QVT transformation engine or a PIM with a virtual execution environment).[11][12]
  • Vendor Lock-in: Although MDA was conceived as an approach for achieving (technical) platform independence, current MDA vendors have been reluctant to engineer their MDA toolsets to be interoperable. Such an outcome could result in vendor lock-in for those pursuing an MDA approach.[citation needed]
  • Idealistic: MDA is conceived as a forward engineering approach in which models are transformed into implementation artifacts (e.g. executable code, database schema) in one direction via a fully or partially automated "generation" step. This aligns with OMG's vision that MDA should allow modelling of a problem domain's full complexity in UML (and related standards) with subsequent transformation to a complete (executable) application[13]. This approach does, however, imply that changes to implementation artifacts (e.g. database schema tuning) are not supported . This constitutes a problem in situations where such post-transformation "adapting" of implementation artifacts is seen to be necessary. Evidence that the full MDA approach may be too idealistic for some real world deployments has been seen in the rise of so-called "pragmatic MDA"[14]. Pragmatic MDA blends the literal standards from OMG's MDA with more traditional model driven mechanisms such as round-trip engineering that provides support for adapting implementation artifacts.
  • Specialised Skillsets: Practitioners of MDA based software engineering are (as with other toolsets) required to have a high level of expertise in their field. Current expert MDA practitioners (often referred to as Modeller/Architects) are scarce relative to the availability of traditional developers.[15]
  • OMG Track Record: The OMG consortium who sponsor the MDA approach (and own the MDA trademark) also introduced and sponsored the CORBA standard which itself failed to materialise as a widely utilised standard[16].

[edit] Code generation controversy

Code generation means, that the user creates UML diagrams, which have some connoted model data, and the UML tool derives from the diagrams parts or all of the source code for the software system. In some tools, the user can provide a skeleton of the program source code, in the form of a source code template where predefined tokens are then replaced with program source code parts during the code generation process.

There is some debate among software developers about how useful code generation as such is. It certainly depends on the specific problem domain and how far code generation should be applied. There are well known areas where code generation is an established practice, not limited to the field of UML.

The idea of completely leaving the "code level" and start "programming" on the UML diagram level (i.e., design level) is quite debated among developers. That is the vision for MDA. This idea is not in such widespread use compared to other software development tools like compilers or software configuration management systems.

An often cited criticism is that the UML diagrams just lack the detail which is needed to contain the same information as is covered with the program source. Some developers even claim that "the Code is the design" [17][18].

[edit] Trademark

The Object Management Group holds trademarks on MDA, as well as several similar terms including Model Driven Development (MDD), Model Driven Application Development, Model Based Application Development, Model Based Programming, and others. The main acronym that has not yet been deposited by OMG until now is MDE. As a consequence, the research community uses MDE to refer to general model engineering ideas, without committing to strict OMG standards.[citation needed]

[edit] Conferences

Among the various conferences on this topic we may mention ECMDA, the European Conference on MDA and also MoDELS, former firmed as <<UML>> conference series (till 2004), the Italian Forum on MDA in collaboration with the OMG. There are also several conferences and workshops (at OOPSLA, ECOOP mainly) focusing on more specific aspects of MDA like model transformation, model composition, and generation.

[edit] See also

[edit] References

  1. ^ "OMG pursues new strategic direction to build on success of past efforts"
  2. ^ adm website http://adm.omg.org
  3. ^ Example usage: http://www.techonline.com/community/tech_topic/37519
  4. ^ Example usage: http://www.kc.com/xuml.php
  5. ^ a b Mellor, S; Balcer, M: "Executable UML: A foundation for model-driven architecture", Preface, Addison Wesley, 2002
  6. ^ Mellor, S; Balcer, M: "Executable UML: A foundation for model-driven architecture", chapter 1.4 Model Compilers, Addison Wesley, 2002
  7. ^ Mellor, S; Balcer, M: "Executable UML: A foundation for model-driven architecture", chapter 1.5 Model Driven Architecture, Addison Wesley, 2002
  8. ^ Bézivin, J, Gérard, S, Muller, P-A, and Rioux, L (2003). "MDA components: Challenges and Opportunities". In: Metamodelling for MDA.
  9. ^ "Hype Cycle for Emerging Technologies, 2006" $495.00
  10. ^ "MDA Is DOA, Partly Thanks To SOA"
  11. ^ "UML - Unified or Universal Modeling Language? UML2, OCL, MOF, EDOC - The Emperor Has Too Many Clothes"
  12. ^ "MDA: Nice Idea. Shame about the..."
  13. ^ "Bringing MDA to Eclipse, using a pragmatic approach"
  14. ^ "A Response to Forrester"
  15. ^ "Are You Ready For the MDA?"
  16. ^ "The Rise and Fall of CORBA"
  17. ^ http://www.developerdotstar.com/mag/articles/reeves_design_main.html by Jack W. Reeves
  18. ^ http://www.bleading-edge.com/

[edit] Further reading

  • MDA Distilled, Principles of Model Driven Architecture, Stephen Mellor, Kendall Scott, Axel Uhl, Dirk Weise, Addison-Wesley Professional, 2004, ISBN 0-201-78891-8
  • MDA Explained, The Model Driven Architecture: Practice and Promise, Anneke Kleppe, Jos Warmer, Wim Bast, Addison-Wesley, 2003, ISBN 0-321-19442-X
  • The MDA Journal: Model Driven Architecture Straight From The Masters, Meghan Kiffer, ISBN 0-929652-25-8
  • Model Driven Architecture, Springer-Verlag, ISBN 3-540-28240-8
  • Model Driven Architecture: Applying MDA to Enterprise Computing, David S. Frankel, John Wiley & Sons, ISBN 0-471-31920-1
  • Model Driven Architecture With Executable UML, Chris Raistrick, Paul Francis, John Wright, Colin Carter, Ian Wilkie Cambridge University Press, ISBN 0-521-53771-1
  • Executive Justification for MDA, Stanley J. Sewall

[edit] External links