Executable UML: A Foundation for Model-Driven Architecture [Paperback]

Stephen J. Mellor (Author), Marc J. Balcer (Author)

Book Description

Publication Date: May 24, 2002 | ISBN-10: 0201748045 | ISBN-13: 978-0201748048 | Edition: 1

Using Executable UML (xUML), developers can build UML models that can not only be unambiguously interpreted by human readers, but can be tested and validated through actual execution, and ultimately translated directly and completely to target code. This technology offers immense potential for accelerating development projects, enhancing reliability, and reducing cost. In this book, two of the field's leading experts introduce every facet of xUML. The authors introduce Executable UML's goals, premises, and features; then drill down to explain its key elements. Along the way, readers will discover exactly how to use xUML to create software systems that can be tested even before they are coded, enabling far greater reliability at significantly lower expense. For all developers, analysts, and project managers seeking to improve software reliability, time-to-market, and value. This book will be especially valuable to real-time programmers, and to thousands of programmers who have used Shlaer-Mellor methodologies.

Editorial Reviews

From the Back Cover

Executable UML is a major innovation in the field of software development. It is designed to produce a comprehensive and understandable model of a solution independent of the organization of the software implementation. It is a highly abstract thinking tool that aids in the formalization of knowledge, and is also a way of describing the concepts that make up abstract solutions to software development problems.

This timely new book, Executable UML: A Foundation for Model-Driven Architecture, thoroughly introduces, documents, and explains this important new technology. The authors show how UML can formalize requirements and use cases into a rich set of verifiable diagrams, how it can be used to produce executable and testable models, and how these models can be translated directly into code. In addition, the book explains how individual system domains are woven together by an executable UML model compiler.

The book is full of tips and techniques to help you:

• Partition a system into subject matters based on individual aspects
• Pick the right level for use case modeling to speed subject matter comprehension
• Model classes and focus on relationships to capture subject matter semantics precisely
• Express behavior using the newly adopted UML action semantics and action languages
• Specify constraints using tags specified in OCL (Object Constraint Language)

In addition, this book tackles topics of particular importance in execution, such as how to:

• Synchronize objects by building lifecycles using statechart diagrams
• Model relationships and contention safely
• Distribute dynamics to avoid unmaintainable controller objects
• Verify the models by executing test cases against the statechart diagrams and constraints

A large-scale, fully developed case study runs throughout the book to illustrate concepts and techniques. These models, plus tools to translate and run Executable UML models, can be downloaded from the book's websites, www.executableumlbook.com and www.projtech.com.

0201748045B05092002

About the Author

Stephen J. Mellor is cofounder of Project Technology, Inc., a company focused on tools to execute and translate UML models, where he now serves as vice president. He chaired the UML Action Semantics Consortium, and is now active in specifying MDA. In his copious spare time, he is a member of the IEEE Software Industrial Advisory Board.

Marc J. Balcer is a consultant with fifteen years of experience in providing custom application development services to Global 1000 companies. In 1991 he began his collaboration with Stephen J. Mellor and the late Sally Shlaer, and he now applies the techniques on client projects in such diverse areas as medical instrumentation, transportation logistics, telecommunications, and financial services.

See all Editorial Reviews

Product Details

• Paperback: 416 pages
• Publisher: Addison-Wesley Professional; 1 edition (May 24, 2002)
• Language: English
• ISBN-10: 0201748045
• ISBN-13: 978-0201748048
• Product Dimensions: 9.2 x 7.3 x 0.9 inches
• Shipping Weight: 1.6 pounds (View shipping rates and policies)
• Average Customer Review: 4.4 out of 5 stars  See all reviews (7 customer reviews)
• Amazon Best Sellers Rank: #550,595 in Books (See Top 100 in Books)
  • #64 in Books > Computers & Technology > Programming > Software Design, Testing & Engineering > UML

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

30 of 32 people found the following review helpful:

5.0 out of 5 stars An must read for serious software developers!, July 3, 2002

By 

Leon Starr (San Francisco, CA United States) - See all my reviews
(REAL NAME)   

This review is from: Executable UML: A Foundation for Model-Driven Architecture (Paperback)

Before clarifying who I think will benefit from this book, I must contradict the review that claims this book is just for Bridgepoint users. I have been building executable models since 1984 using a variety of tools, on numerous real-time/embedded projects. I used Illogix on a recent project for example. In the olden days we used AutoCAD to enter the models and AutoLISP to extract the model content and generate partial code. Regardless of toolset, my colleagues and I have successfully implemented the critical concepts described in Steve and Marc's book. Experienced engineers know that you start with an engineering process and THEN figure out what tools you need to get the job done. Not the other way around (as today's most popular tool vendors would have you believe!)

NOTE: If you meet the criteria I've listed under "Who should buy this book", Chapter 14: Control Strategies alone is worth the price of this book, no matter what object oriented methodology or tool set you use.

In addition to the handful of tools that fully support the engineering approach defined in Steve and Marc's book, there are many tools out there that partially support this approach. Combinations of mainstream tools and increasingly available Opensource utilities can also help you get the job done. Okay, enough about the tools, let's focus on what is really important.

You should NOT buy this book if:
-------------------------------------
All you do is slap quick and dirty scripts and utilities together.

You really love coding in C++ or Java and can't imagine why you would ever want to do anything differently.

Your only interest in UML is to display your C++ in pretty rectangles with happy stickmen.

The development time required to build a complete product in your organization is on the order of 1-3 months max.

You SHOULD buy this book if:
--------------------------------
You have attempted to use UML on a real project and been seriously disillusioned.

You want to focus effort at a higher level of abstraction than that afforded by implementation dependent languages like C, C++ or Java.

You develop large real-time distributed or embedded applications with complex requirements.

You know that there must be some way to disentangle the fundamental application rules from the implementation, yet each time your company creates a new product version or a spinoff, the application has to be re-specified and re-coded to a large extent.

You routinely tackle extreme complexity, but don't want to end up with obnoxiously complex statecharts (See my note on Chapter 14 at the end of this review).

Some things that make this book DIFFERENT
---------------------------------------------------------
There are over a hundred UML books that you can buy on Amazon. But even those books that try to address real-time systems fail miserably to address many PRACTICAL issues critical to building complex real-time systems.

Steve and Marc define a complete development language. This language uses the UML notation, but is a LOT more than just notation. In addition to the UML notation, they:
Define an explicit model of synchronization (how time works when you don't know what processor, operating system or even hardware partitioning into which your software is ultimately packaged).

Provide complete executable semantics for an implementation independent interpretation of how models execute on any arbitrary implementation.

Explain a process whereby the specification can be fully separated from the implementation and various layers of middle ware can be separated from both of these layers.

Raise the level of abstraction (way above C++ and Java) for solving complicated application problems while at the same time providing a language that can be (and has been) translated into non-object oriented (VHDL, C or Assembler) as well as object-oriented language implementations.

In particular, Chapter 14: Control Strategies (Domain Dynamics) is one of my favorite chapters. I haven't seen anything like this in ANY other UML book. This chapter, if you have the experience and patience to work through the example and really understand what is going on (I predict most people will just skim through and completely miss the point) will change the way you think about organizing class collaborations (communicating state machines). It shows you an excellent process for decreasing the complexity of your collaborations. This is just one of the many concepts presented in this book that transcends your model editor/development tools.
----------
Everything in this book is practical. There isn't a thing in here that I and my colleagues haven't applied to solve real problems on a real project. This stuff works! Read this book and the world of software development as you know it will change forever. Welcome to the next level.

13 of 13 people found the following review helpful:

5.0 out of 5 stars Good ideas bear up well over time., November 30, 2002

By 

Michael M. Lee - See all my reviews

This review is from: Executable UML: A Foundation for Model-Driven Architecture (Paperback)

Two events at the Object-Oriented Systems, Languages, and Applications Conference of 1996 were memorable for me. The first was the opening address given by one of the more insightful architects/designers of the 20th century, Christopher Alexander. And the second was a debate between Stephen Mellor (one of the authors of this book) and Grady Booch on the topic "Translation: Myth or Reality?". Six years later, with the addition of Action Semantacs to UML, the Model Driven Architecture initiative of the Object Management Group, and the publication of this book, it appears that Mr. Mellor is as persistent in his position that executable (and hence translatable) models are indeed a reality, as Mr. Alexander was that the resonance between the structure of a solution and the corresponding problem is a measure of the solution's quality. Good ideas bear up well over time.

Mr. Mellor, and this book, are not for the faint hearted. It is his position that building software systems should be more about engineering a solution than artfully handcrafting one, and that to do this, one needs a disciplined process and a rigorous and precise engineering tool: Executable UML. If you agree with this tenet, and accept its implied challenge--or just want to know where they will lead you--this is a book for you.

In this book, Mellor and Balcer present a very lean and agile profile of UML and define the underlying execution semantics that enable it to be used as a valuable engineering tool for analyzing, designing, and implementing your systems. They also prescribe an engineering process to follow when modeling a software system, and thoughtfully walk the reader through this process and the various UML models with numerous examples and real-world experiences. If you use UML to model software, and aspire to engineer that software in the process, this book will give you a lot to think about and add significantly to your engineering tool chest.

11 of 11 people found the following review helpful:

5.0 out of 5 stars Comprehensive and well-written, August 20, 2003

By 

Paul Clothier (Sausalito, CA United States) - See all my reviews
(REAL NAME)   

This review is from: Executable UML: A Foundation for Model-Driven Architecture (Paperback)

Having worked for an organization that has implemented a model-driven architecture technology approach to create highly robust software applications I can attest to the practical value of translatable models and the information and techniques in this book.

I have always been a fan of the rigor and completeness of the Shlaer-Mellor methodology and this book distils this rigor into a profile of UML that hopefully will inspire a wider audience to look at the reality of creating executable and translatable models.

I found the book extremely well written and very complete in its treatment of every aspect of the subject from basic UML ideas through to model compilers. Unlike many technical texts I found absolutely no fluff in this book - each sentence and section has been carefully worded to be clear, consistent and unambiguous - a breath of fresh air for a pedant like myself.

I have used this book (along with Leon Starr's "Executable UML: How to Build Class Models") as a reference for my course development work on executable UML and found it invaluable. The table of contents and index are complete and well put together - something that I feel is crucial in any reference text.

I highly recommend this book for anyone using UML for software development who wants to explore this new technology of building executable and translatable models - and have it explained clearly and comprehensively.