The companion CD-ROM contains:

• Complete source code, executable images, and Visual C++ projects mentioned in the book.
• Answers to all exercises scattered throughout the book.
• The Evaluation Version of On Time RTOS-32 v4.0.
• Visio™ stencils used to create the diagrams in this book.
• Information about the book and promotion of other related CMP publications.
• Several references in Adobe Portable Document Format (PDF).

From the back cover...

About the Author...

Dr. Miro Samek is the President of Quantum Leaps, provider of modern, event-driven software for embedded systems. Dr. Samek is the author of numerous articles for magazines, and is a regular speaker at the Embedded Systems Conference. Before founding Quantum Leaps Miro worked as Software Architect at Global Locate (San Jose, CA), where he designed GPS software for mobile phones and before that designed GPS receiver software for IntegriNautics Corporation (now Novariant, Menlo Park, CA). Miro started his embedded career at GE Medical Systems, where he has developed safety-critical, real-time software for diagnostic imaging x-ray machines. He earned his Ph.D. in nuclear physics at GSI (Darmstadt, Germany).

Readers' feedback...

Key Points...

Selected Reviews

Reviewer

Review

Chris Hills
ACCU Reviewer

The following review appeared on ACCU (Association of C & C++ Users) Reviews

This is not so much a book as a way of life. The book is part of the Quantum Programming way of life. It is based on UML state charts and active objects for multithreading.

The best way to discover if this is for you is to spend a few minutes browsing http://www.state-machine.com where you will discover lots of information on Quantum Programming, resources and cook books, other books and magazine articles on QP, the QP community and discussion forum. They really have gone to town on this. The CD with the book is no exception. It is a joy to behold. One day all CDs with books will be of this standard! This is for both content and execution. It auto starts with a virtual web site logically arranged with links to all the software and resources with notes, links to other resources etc. So this is not 'just a book' on someone's wild ideas. The other important point is that the web site is (almost) complete. Sometimes many authors promise a web site that never materialises, this one was there before the book.

By the time you have looked at the web site it makes my review of the book superfluous, as it contains much of the subject on the website. The good news is that whilst this system will work with most (they list eight) UML CASE tools it is designed to be a lightweight system that does not need a CASE tool. There is even a set of MS Visio Templates and a coding standard both downloadable so you could 'start with it on Monday' as they say in the book, without a major investment in tools.

For those interested in QP this book will be ideal as a reference. I know many have broadband Internet and could download the source and the information on the website but a book is still better than printouts (even when bound up) and does contain a lot of additional information.

The book itself is in two parts. The first covers UML state charts, real-time, etc. The second part introduces the Quantum methods and ideas. This is an event-message type system.

The examples in the book are designed to work on x86 (under Win9x-2K, DOS or RTOS-32) with VC++ and Borland compilers (all code is on the CD). The evaluation version of RTOS-32 is provided though it is claimed that the QF source has been 'carefully designed to work with nearly any RTOS'.

By coincidence, whilst writing this review there was a brief flurry of messages on comp.arch.embedded where someone asked about QP. There were only a few replies but everyone liked the method and had used it on at least one real world project.

The method works for both C and C++ though personally I have always had reservations about using UML for C. As for the book itself; I like it. It is logical, clearly written and the exercises use the code on the CD and work to a practical example. They are not designed as exercises for students where only the lecturer has the answers. If you are using or looking at UML then look at the QP web site first. If you think QP is for you then definitely buy the book. This book is recommended to all interested in QP.

Note from the author: The overlap between the book and the quantum-leaps.com website is not nearly as significant as this review would suggest. The mission of quantum-leaps.com is not to repeat the material already published in "Practical Statecharts in C/C++" ("PSiCC"). Rather, the website complements the book by offering different perspectives, related subjects, and recent developments in both the code and understanding of the concepts.

Jonathan Kaye
Author
Flash MX for Interactive Simulation
jmk@amethyst-research.com

The following review appeared on SlashDot.org and triggered quite a few comments.

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 (www.FlashSim.com), 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!).

Ed Nisley
Columinst
Dr. Dobbs Journal
ed.nisley@ieee.org

The following excerpts come from the Embedded Space column published in the December 2002 issue of Dr.Dobb's magazine. The complete text is available online.

...

...Miro Samek accomplishes three mighty feats in Practical Statecharts in C/C++: He explains how hierarchical state machines work, converts those machines into C/C++, then provides a framework to run those machines in real-time environments or your favorite GUI. Along the way, he demolishes the opposition (how you used to do it), shows you the right way (with code to prove the point), and doesn't bore you to tears (even when explicating quantum mechanics). Quite a feat by any stretch of the imagination.

...In under 200 pages, the first half of Practical Statecharts in C/C++ covers state machines, statecharts, the usual implementations, behavioral inheritance, the five key state-machine design patterns, and how to actually pull off inheritance in both C and C++, all with highlighted code samples. Whew!

At that point, you have enough motivation to reform your current methods and enough knowledge to get it right. That's worth the price of admission and, frankly, you should read this part of the book just to open eyes to a different way of doing things. Even if you never use the code directly, it'll be a win.

The second part of the book describes Samek's Quantum Framework and the techniques used to bolt it onto the operating system of your choice. He gives examples in DOS(!), Windows, and OnTime's RT-Kernel32, showing that, while you don't need an inherently multitasking OS to get the job done, it certainly makes the job a lot less tedious.

State machines are a nearly perfect fit for real-time and highly reactive systems because they easily distribute the workload among many distinct states that inherently avoid compute-bound lumps of indivisible code. At the risk of oversimplifying, the Quantum Framework handles the hocus-pocus required to transfer control between the OS and the current state within your design.

Even if you're not doing embedded programming (thanks for following along, though), you should read pages 215 through 248 of Chapter 8, where Samek provides a clear and concise discussion of the most common program design pitfalls — handling errors and exceptions, memory management problems, threads and blocking, and event passing. Expect to smack your forehead and go rummaging for an old source file when you realize that you've made a mistake he describes.

The reminder of the book covers the implementation of the Quantum Framework in sufficient detail that you'll know not only how it works but why he did it that way. While not exactly a can't-put-it-down thriller, it's certainly well done and worth perusing, which I can't say about a lot of technical books these days

Reentry Checklist

CMP Books publishes Practical Statecharts in C/C++, which means, as nearly as I can tell, that I've been discussing a book put out by a relative of this very magazine. Other than sending me a (free) review copy, nobody's done any arm-twisting.

...

Michael Barr
Editor in Chief
Embedded Systems Programming
mbarr@cmp.com

This review appeared as the editorial column in the August 2002 issue of ESP magazine. Courtesy of Michael, his review is also available in PDF.

Relatively few of the embedded systems books I receive are worthy of permanent space on my bookshelf. That's why I want to tell you about one recent standout.

I don't buy many books about embedded systems. Most of the relevant ones find their way to me as review copies. I try to read, or at least skim, those that look promising. Unfortunately, I've found that relatively few are worthy of permanent space on my bookshelf or recommendation to others. That's why I want to tell you about one recent standout.

Perhaps you recall the article "State-Oriented Programming," which appeared precisely two years ago in this magazine. It described a simple manual technique for turning hierarchical state machines into compact C or C++ code. Though I was certainly impressed by the authors' approach, I didn't then recognize the brilliance of the underlying ideas. The primary author's recent publication of a book-length treatment of the topic has helped me see the light.

The book, by Miro Samek, is titled Practical Statecharts in C/C++ (CMP Books). The title of the book is a major understatement. What stands out in my mind is not the practical nature of the solution it provides to a common recurring problem, but the downright revolutionary ideas behind that solution.

The author's so-called "Quantum Programming" may ultimately change the way embedded software is designed. Never before has there been a viable alternative to the traditional main()+ISR vs. RTOS problem. Preemptive multitasking only works well in specific scenarios, while main()+ISR comes with its own set of problems when you try to scale it. A third way is needed.

This book offers a solution, based around state machines, that is compact (5KB is all that's typically required), realized in C and C++ (no fee or royalties), of theoretical value in any language, and can support multiple state machines running in parallel if necessary. It's also the first good way I've seen to deal with the inheritance of state behavior in hierarchical state machines.

Before quantum programming, there were basically three approaches to state machine implementation: switch statements, tables of function pointers, and object-oriented programming constructs. The issue of substates in hierarchical state machines was complex in all of these approaches. Hierarchical state machines are common, with part of each state's behavior being determined by its parent state and the rest by the substate itself. This is difficult to implement in all of the traditional approaches, as it either requires duplication of code or additional function/method calls. At best, the results tend toward spaghetti code.

In a nutshell, quantum programming is a design pattern for direct and efficient implementation of (hierarchical) state machines. It uses the popular and proven UML statecharts as its graphical specification language, and leaves the choice of implementation programming language up to the developer. Hierarchical states are implemented via an externally driven "event processor," the use of which ensures that substates need not duplicate the functionality of their parents (and grandparents). Dr. Samek calls his implementation the "Quantum Framework."

I believe that these innovative techniques will quickly become popular, and have already put them to good use. If you read only one book about embedded systems this year, make it Practical Statecharts in C/C++.

Brian Schmidt
Plexus Technology Group
Sr. Design Engineer
- Embedded Software
brian.schmidt @plexus.com

Great book! Here is my review...

The laws of Quantum Physics provide an interesting background against which to test the correctness of the proposed Quantum Framework. In his book, Miro accomplishes his goals of providing a technique to implement state machines and providing a platform for a future programming paradigm or language.

Miro's book serves in dual roles as a springboard to immediately start implementing better state machines and as an 'almost mathematical' proof of his Quantum Framework. Beyond simply talking about concepts, Miro provides complete source code and code walkthroughs alleviating the difficult task of implementing abstract concepts.

As an experienced software engineer who has implemented several state machines I wanted to skip ahead to discover the proposed Quantum Framework and the Hierarchical State Machine design. Yet, I still found the beginning chapters riddled with tidbits of useful information.

The added appendices of 'Object-Oriented Programming in C' and a 'Guide to [UML] Notation' provide an added bonus.

This book is a must have for embedded software engineers who wish to leverage the power of hierarchical state machines.

Errata