Other Sellers on Amazon
+ 13.61 Delivery charge
MDA Explained: The Model Driven Architecture™: Practice and Promise (Addison-Wesley Object Technology (Paperback)) Paperback – Import, 21 Apr 2003
Special offers and product promotions
From the Back Cover
"Jos Warmer’s work has contributed greatly to the semantics of the UML. From that perspective, and in this book, he offers insight on how one can and can’t use the UML to move to the next level of abstraction in building systems."
Experienced application developers often invest more time in building models than they do in actually writing code. Why? Well-constructed models make it easier to deliver large, complex enterprise systems on time and within budget. Now, a new framework advanced by the Object Management Group (OMG) allows developers to build systems according to their core business logic and data―independently of any particular hardware, operating system, or middleware.
Model Driven Architecture (MDA) is a framework based on the Unified Modeling Language (UML) and other industry standards for visualizing, storing, and exchanging software designs and models. However, unlike UML, MDA promotes the creation of machine-readable, highly abstract models that are developed independently of the implementation technology and stored in standardized repositories. There, they can be accessed repeatedly and automatically transformed by tools into schemas, code skeletons, test harnesses, integration code, and deployment scripts for various platforms.
Written by three members of OMG’s MDA standardization committee, MDA Explained gives readers an inside look at the advantages of MDA and how they can be realized. This book begins with practical examples that illustrate the application of different types of models. It then shifts to a discussion at the meta-level, where developers will gain the knowledge necessary to define MDA tools.
Highlights of this book include:
The advent of MDA offers concrete ways to improve productivity, portability, interoperability, maintenance, and documentation dramatically. With this groundbreaking book, IT professionals can learn to tap this new framework to deliver enterprise systems most efficiently.
About the Author
Anneke Kleppe is a consultant and adviser at Klasse Objecten, which she founded in 1995 to train and coach companies on the use of object technology, modeling, and MDA. She was intensively involved in the development of the Unified Modeling Language (UML) and the new UML 2.0 standard. The author of several books, Anneke started a knowledge center for object technology at KPN Research in Leidschendam, Netherlands. She is a member of the authoring team of the OCL 2 standard, where she has a special focus on the definition of the semantics of the OCL.
Jos Warmer is the primary author of the OCL standard. He is an active member of the Unified Modeling Language (UML) Revision Task Force, which defined the revisions in the UML 2.0 standard. Previously he was a member of the UML core team, where he was responsible for the development of the Object Constraint Language (OCL). The author of several books and numerous international articles, Jos is an advisor on the UML method and techniques at the De Nederlandsche Bank.Wim Bast is Compuware’s OptimalJ MDA architect.
032119442XAB07222003 See all Product description
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter mobile phone number.
|5 star (0%)|
|4 star (0%)|
|3 star (0%)|
|2 star (0%)|
|1 star (0%)|
Most helpful customer reviews on Amazon.com
MDA is the concept of using models developed using a modeling language (UML) to generate real applications. This book can be seen as a high level overview of MDA and at 150 pages it is a fairly easy and quick read. The authors show both what is available today (not too much) and what might be available in the future (perhaps all applications will be generated from models). The authors do try to make the book practical by showing how you can use modeling tools to at least build skeletons of code that can be the start of code development. MDA brings a new set of acronyms but this book explains each of them without too much pain.
So how much of what is discussed here is needed by a typical developer or designer? Probably not too much. But if you want to keep your eye on the future of IT then this book is well worth the read. Perhaps one day writing code will be thought of the same way we think of writing machine language. When that happens you will be able to say you knew it was coming.
Big problems, almost by definition, have lots of parts. Today, that means databases, network protocols, incompatible languages, distributed processing on disparate platforms, and more. Building any one part on any one platform is easy enough. The problem is to guarantee that the database, the Enterprise Bean interfaces, the HTML forms, and everything else match each other. There are two ways to make matching work. First, you can spend the rest of your life running around and looking at all interacting pairs of things, hoping that nothing changed while you weren't looking. Second, you can derive all those parts automatically from a common source. That's what the MDA is about.
The MDA defines hierarchies of meta- and meta-meta-models. If you read between the lines, you'll probably see that each level of meta-abstraction requires a successively more knowledgeable, capable developer. This book works at the highest levels, so probably won't make much sense to entry-level staff with a more concrete and immediate view. (I shudder to think about maintenance of high-level tools by entry-level staff, and it will happen, somewhere some day.) The MDA approach assumes complete fluency with the UML, MOF, OCL, and other alphabet soup. That is necessary because the MDA half-defines transformation rules that convert a specification, in successive steps, into code. It's a bit like the filter approach of XSLT.
The good news is that one specification can be transformed into a database schema, a Java Bean, a web form, and more, by applying different transformations to the spec. Consistency is ensured, at least to the extent that the different transformation rules are correct and consistent.
There are a few problems with the MDA approach. First, the authors point out that it's just not there. It's a blue-sky spec, with no underlying implementations. A few vendors have declared their products MDA-compatible. I'm reminded that a block of wood with two nails driven in wass compatible with the electrical safety specs from the old Ma Bell days. Non-interference is a form of compatibility, just not a very interesting one.
Second, if you have a small problem, though, you're stuck. The only apparent way for MDA to handle a small problem is first to turn it into a big problem, then solve that. Victims of heavy-weight CASE tools in light-weight projects will have some experience of that already.
Third, and most critical, is that it just isn't complete enough. The transformation rules, at least as shown here, don't really have the expressive power needed for generating compilable code. That operation, the one that matters, seems to be "implementation dependent", i.e. jungle rules. Also, despite the authors' assurance (sec 12.1.3) that MDA really will generate code that doesn't need manual involvement, they have no shown that. Quite the opposite. The sample application (p.120) shows how the model generates a business-rule method, but gives no indication how that method's body is to be defined!
The MDA is interesting, but perhaps not the "paradigm shift" that the authors claim. In many ways, it's like the common code-generating CASE tools writ large. Getting to the authors' ultimate vision will take years, many incremental steps, and probably a good bit of pain on the developers' part.
Still, software is getting bigger and software problems are getting bigger. They need to be tamed somehow, and maybe the MDA will address important parts of the problems. I'm watching and waiting, but getting on with my business in the mean time.