Browse Books

Reviewer: David G. Reed

Over the history of computing, programmers have developed languages to further abstract programs from hardware. This allowed for increased productivity, and accessibility to programming, and is a key factor in the accelerating development of new programs. Today, systems span many subject areas, and often require high levels of integration. To remove the dependence on specific software or languages, model-driven architecture (MDA) was created to drive abstraction one level further. MDA is a standard framework, from the Object Management Group (OMG), that allows developers to link object models together to build complete systems. In practice, MDA is proposed to function like a higher-level compiler. It takes its set of rules, and runs them through a black box that makes code. In this way, the developer needs no knowledge of the underlying details. Fifth-generation languages were to accomplish this as well, but the problem scope ultimately overwhelmed them. This book is a well-written introduction to the MDA standard, its tools, and its technologies. The book explains the basic features of MDA, as well as how they fit together, and how they can be used. The book covers: the MDA framework, including the platform-independent model (PIM) and the platform-specific model (PSM); the meta object facility (MOF)-the OMG's adopted standard for metamodeling; horizontal, vertical, and merging mappings between models; building marks and marking models; elaborating models, including viewing generated models, and managing manual changes; building executable models with executable unified markup language (UML); and agile MDA development. The sections on building marks and marking models are very interesting, because it is here that language definitions for domain-specific requirements are described. The ability to accommodate rich domains is essential for the viability of the standard, and the authors explain it well. A weakness of the book is its lack of realistic examples, to bring the ivory tower tone down to earth. The authors state clearly that MDA is still under development, but some insight into more detail would make the topic more real, and its limits better defined. Right now, no one knows how workable MDA would be in software development. Seeing a concrete example would be a great benefit. Another concern is the context of the book. By that, I mean that this approach seems suited only to problems of large scope. How maintenance, rapid development, or smaller applications could use or integrate with MDA is not considered. These issues are a significant segment of the work performed today. Undoubtedly, MDA is a significant attempt, but its eventual success or failure is down the road for true enterprise adoption. The authors also mention that MDA will have the ability to transform business rules into good code, without manual rewrites or tuning. However, there are no examples of this in the book. This is where the rubber meets the road, and though MDA is still developing, some sort of end-to-end example would have been appropriate. Other MDA volumes [1,2,3,4] address many of the same issues. This book is more concise and tractable than these. Even with the dearth of examples, if I had one book to recommend to my peers for MDA, this would be it. Online Computing Reviews Service