Customer Reviews

Practical Statecharts in C/C++: Quantum Programming for Embedded Systems with CDROM

5 star:		(13)
4 star:		(1)
3 star:		(2)
2 star:		(1)
1 star:		(2)

 

 

Since I am not from the embedded system world, I was a bit apprehensive about approaching this book. While I can see that author Miro Samek has a directed target for his audience, I strongly feel that this book is a "must read" for technical developers in all areas who want to improve their program design abilities or developers who want to understand the philosophy, use, and implementation of statecharts intimately.

As the title indicates, this book brings the topic of statecharts from the realm of expensive design tools to the PRACTICAL realm, illustrating its points with full examples and extensive commentary.

Essentially Samek postulates that the slow adoption by developers of best practices by statechart design is due to lack of understanding of the fundamental nature of statecharts and how it is perceived as requiring expensive tools to use well. Samek insightfully discusses how statecharts as a best practice embody "behavioral inheritance" as a fundamental design concept that stands as a peer alongside the conventional pillars of object-oriented programming, namely inheritance, encapsulation, and polymorphism.

The book is very technical and written in an academic style, with ample references to original sources as well as detailed code reviews and many reader exercises. I would caution anyone from approaching this book as a quick or light read. For me, it took a seriousness and good understanding of C and C++ to follow Samek's examples and achieve the "a-ha", which was always worth it in the end.

The two basic parts of the text are (1) an explanation of statecharts and their methodological implications, and (2) a description of how to apply statecharts as a data structure in real applications, namely embedded as control strategies for "active objects." In several places in the text, Samek makes an analogy between statechart (and active object) semantics and quantum mechanics. This parallel was an interesting philosophical argument, but didn't add much for me in terms of accepting his "quantum framework" as a best practice -- I was sold by his methodological arguments he had presented already.

Speaking from experience in writing a book about using statecharts to build simulations, I can say Samek is a visionary who extended my perception of statecharts several steps. I know I will be quoting from it and referring to it in my work to come. This book has earned a prominent place on my bookshelf, and I would heartily recommend it to any other developer who wants to create correct, verifiable, scaleable, and solid designs (which should be ALL developers!).

A couple of months ago I would have fully agreed with most of the reviewers: yes, statecharts is an important topic, and Samek covers it well. Indeed he does: The book is chock-full of (working!) code and will give you a head-start at tackling difficult behavioral control problems. I do not develop real-time software, but thinking of _every_ software as if it were real-time can increase quality. I feel I gained a lot of insight, and it made me rethink some architecture issues.

You can brush over the quantum-babble, mainly because it's irrelevant and an already overstreched analogy-for-everything. With regards to Statecharts, no harm is done that Samek is evangelizing a little bit too forcefully.

So why 3 stars only? After working with the concepts and coding a number of statemachines the Samek-way, I started to notice that Samek's approach does not quite deliver as promised:
* Be prepared to be disconnected from the community: Samek's statecharts part in a lot of aspects from the UML 2.0 statecharts (although there is a website w/ quite a lot of activity). Looking at UML-compliant statecharts from fellow developers you will realize that you cannot transcribe them easily using Samek's framework. Main reason: UML has functionality (= non-statemachine code) in transition actions and event guards, Samek in state event handlers.
* Samek's statemachines are "run-to-completion", which results excessive self-posting of events and queuing. Although the code is not spaghetti, the execution is - and debugging is _very_ difficult.
* After a while, it is very difficult to infer the statechart semantics from the code. I certainly want to believe Samek that there is no real value in separating semantics (= statechart description) from functionality (= code which uses the statemachine), but this turned out to be a maintainance nightmare.
* Samek's statemachines do not offer orthogonal states, but for bigger projects you will need orthogonality to model concurrent aspects of a system. The lack of orthogonality is salvaged by the publish/subscribe framework also included in the book: You just use a number of statemachines and connect them via a message bus. This might work in the real-time space but it's obviously not something you will be able to include in your software. As a consequence, it is difficult to use statemachines in a "tactical" fashion.

David Harel (the inventor of statecharts, see his paper from '87, e.g. on citeseer) designed statecharts as a visual language to enable thinking (alone and in the team) about the behaviour of systems. Samek disagrees: coding and thinking go hand in hand. This might seem to be very "agile" but there are pitfalls. Actually he seems to be as strict in his assertions than Harel is - not agile at all.

There are approaches which are more balanced in that they mimic statechart semantics "better" (= more UML-compliant) than his. Take a look at SCXML (XML-driven, Java-interpreted) or at CHSM (C++/Java code generation). Also take a look at the roundtrip modelling tools which (most likely) ship w/ your preferred development environment.

Samek is very up-beat and a strong believer in what he says. I bought into his vision and hoped for a productivity / morale boost comparable to using unit tests (like JUnit). It never really turned out that way, and statemachine coding à la Samek remained a trial-and-error business until I decided to use a different approach.

It's an important, very original book, and an interesting read. My advice: Give it a try, but don't get carried away.

This book has done a great job in consolidating many key concepts and techniques in embedded software design. Though state machines and event-driven design are not new, the author proposed a truly reusable and integrated framework which is very well designed and particularly suitable for resource constrained embedded systems.

Author's implementation of state machines is innovative and remarkable. It supports state nesting, automatic execution of entry/exit actions and default event handling by superstates. This allows you to implement UML statecharts in C++/C conveniently.

In general this book is very clearly written and comprehensive. Its reference list is also valuable, pointing to some classics in OOD and good articles in Embedded Systems Programing. This book will definitely become a classic in embedded software itself.

On the downside, I find the repeated analogy of the software model to quantum physics overwhelming. Besides the author chose to show you examples and implications before showing you the details and internal. This kind of abstraction may pose some question marks in your mind when you read the first few chapters. But do read on and you will appreciate the great ideas.

I think the title is a little misleading.
It is more a introduction to state machines and implementing them on embedded systems. It fact it is more about developing on embedded systems!
Having said that it does it very, very well. I would even reccomend it to non-embedded developers,particularly the sections on multi-threading issues and Active objects.

I'm not sure who the audience is though. A lot of embedded developers are unfamiliar with C++, UML while non-embedded developers may not even think that state machines could be useful to them.

I appreciate the quantum physics analogies, but I don't think they needed so much space.

The section on implementing O-O in C is good, but once again,is it relevant to a book on state-machines and active objects.

The framework looks good, butI would tweak the C++ version to get rid of all those macro's and function pointers! Particularly if you wanted to port it to java.

Excellent book but change the title!

I want to congratulate Miro Samek for his book.

The book is well structured. The UML Statecharts are well introduced. The Actives Objects approach and the related Framework are very attractive. With the Framework (QF) for embedded real-time systems included, you are really able to use it for your application. You can then focus on your application objects and no more on the "glue" around them. You have a common strategy for all your applications.

The best book on UML for embedded system from a long time.

This book was a definite eye-opener for me with regard to state machines. I recently rewrote a major piece of code to utilize the Quantum Framework (included with the book) and it has worked wonders. My previous code used a more traditional state machine and had quickly evolved into spaghetti code. The hierarchical state machine approach made the new code smaller, more robust, and much easier to maintain and extend.

I noticed the first version of the hierarchical statemachine framework from Samek in ESP magazine August 2000. It seemed interesting and very efficient but on this book Samek has improved the framework a lot. Multitasking is included for example.
In addition the book gives good examples and instructions to use the framework in embedded systems software projects.
If you think you should re-think your architectural design in your embedded project read the article in ESP magazine ...

Most of the embedded books I've read mainly focus discussion on basic assembly language (such as interrupt subroutine) and simple hardware interfacing (for instance, keypad, debouncing). I've been looking for book discuss on larger embedded program. If you have mastered the basic skill on microcontroller, this book will definitely enhance your knowledge on the embedded software architecture .

I used to put a lot of flag in my program to indicate the state. This will eventually become confusing as program grow larger. The knowledge on statechart that I learn from this book greatly tidy up my code, even I have only finished reading a few chapters. The concept is well-explained with the aid of chart diagram and codes. Furthermore, this books is platform independent, you can use it on any microcontroller. I highly recommend this book to intermediate and advanced embedded programmer!

This book has done a great job in consolidating many key concepts and techniques in embedded software design. Though state machines and event-driven design are not new, the author proposed a truly reusable and integrated framework which is very well designed and particularly suitable for resource constrained embedded systems.

Author's implementation of state machines is innovative and remarkable. It supports state nesting, automatic execution of entry/exit actions and default event handling by superstates. This allows you to implement UML statecharts in C++/C conveniently.

In general this book is very clearly written and comprehensive. Its reference list is also valuable, pointing to some classics in OOD and good articles in Embedded Systems Programing. This book will definitely become a classic in embedded software itself.

On the downside, I find the repeated analogy of the software model to quantum physics overwhelming. Besides the author chose to show you examples and implications before showing you the details and internal. This kind of abstraction may pose some question marks in your mind when you read the first few chapters. But do read on and you will appreciate the great ideas.

I read the book over several days then experimented with the knowledge I had gained by upgrading my reusable C++ Finite State Machine classes to add a subset of the most useful heirarchical state machine features.

All the debugging, banging and refitting I did to my classes gave me an appreciation for how much easier it would be to code and maintain statecharts using the author's pre-selected ideas and coherant, maintainable, elegant framework. My legacy design is about 180 degrees from the authors, using state objects (e.g.: I used nouns, and the author uses verbs) and all my functionality is set in externally through event and transition functions. Even using the book from that divergent viewpoint, the book's information and method of presentation was very useful.

On the logic side, I'm reimplementing some standalone FSM algorithms using my new statechart capabilities and I appreciate the grounding in practical statechart design I received from this book. This includes a basic set of the most useful and powerful features and an understanding of how to implement more complicated special purpose features if I should ever decide I need them, and also an understanding of why I may never choose to do so.