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.
