Practical UML Statecharts in C/C++ Second Edition bridges the gap between high-level abstract concepts of the Unified Modeling Language (UML) and the actual programming aspects of modern hierarchical state machines (UML statecharts). The book describes a lightweight, open source, event-driven infrastructure, called QP that enables direct manual coding UML statecharts and concurrent event-driven applications in C or C++ without big tools.
This book is presented in two parts. In Part I, you get a practical description of the relevant state machine concepts starting from traditional finite state automata to modern UML state machines followed by state machine coding techniques and state-machine design patterns, all illustrated with executable examples. In Part II, you find a detailed design study of a generic real-time framework indispensable for combining concurrent, event-driven state machines into robust applications. Part II begins with a clear explanation of the key event-driven programming concepts such as inversion of control (Hollywood Principle), blocking versus non-blocking code, run-to-completion (RTC) execution semantics, the importance of event queues, dealing with time, and the role of state machines to maintain the context from one event to the next. This background is designed to help software developers in making the transition from the traditional sequential to the modern event-driven programming, which can be one of the trickiest paradigm shifts.
The lightweight QP event-driven infrastructure goes several steps beyond the traditional real-time operating system (RTOS). In the simplest configuration, QP runs on bare-metal microprocessor, microcontroller, or DSP completely replacing the RTOS. QP can also work with almost any OS/RTOS to take advantage of the existing device drivers, communication stacks, and other middleware. The accompanying website to this book contains complete open source code for QP, ports to popular processors and operating systems, including 80x86, ARM Cortex-M3, MSP430, and Linux, as well as all examples described in the book.

*Focuses on core concepts rather than tools which are always changing allowing the reader to continue to use this information with various projects
*Provides a complete, ready-to-use, open source software architecture for small and large embedded systems
*Includes an extensive example using the ARM Cortex-M3 throughout the book highlighting issues programmers and architects encounter in everyday life

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 7 Ratings

Dr. Miro Samek does it again with this new 2nd edition! - 2009-06-13
Reviewer Rating:
I first met Dr. Samek at the Embedded Systems Conference in San Francisco, CA. I was drawn in by how simple his QP infrastructure was. Immediately upon reading the 1st edition of his book, I was able to get an embedded system up and running. Not only was the source code helpful, but the examples in the book provided real world applications. With this new 2nd edition, there are even more real world examples to learn from. In addition, the examples are utilizing many different MCU's - e.g. MSP430, ARM Cortex-M3, 80x86, etc.

I have used QP during the last few years both in the professional arena and as a hobbyist. Still today, the state machine framework is executing flawlessly. The concept of having decoupled state machines used to be mainly in academia while industry was more observant of the typical main() + ISR environments. But the trend is moving more toward event driven programming. UML in general can be rather convoluted with nomenclature and semantics that leave the developer questioning what they are getting themselves into. But with QP, the framework is simplified to the point where the developer only focuses on the actual application and need not worry about the underlying kernel, queuing mechanisms, tasks, etc. However, if the developer decides to understand what is executing 'under the hood' per se, the book goes through in detail all the intricacies of the infrastructure.

Furthermore, the GNU GPL provides a great way for new comers to view the source code and see what the platform is all about.

I will not repeat all the details of the book as previous reviewers have. However, I will note that this book is as comprehensive as can be for any embedded engineer who is interested in developing in a revolutionizing environment. Kudos to Dr. Samek!

This is a really good book - 2009-05-13
Reviewer Rating:
Many years ago Finite State Machine concept saved my life in an embedded software project. Thanks to this practical experience I realized how powerful the state machine concept used in software construction is. At that time the famous "C User Journal" was for me the only source of knowledge about state machines programming.

That is why I was excited when I spotted and read the first edition of the book a few years ago.
The current edition is much thicker - 700 pages in total.
State machines stuff occupy the first 250 pages and in my opinion, this is the mandatory reading for any embedded software engineer. The author starts from "A Crash Course in UML State Machines" which teaches a reader the skills needed to describe Finite State Machines and Hierarchical State Machines in UML.
The next chapter describes a few approaches to FSM implementation. Chapter 4 introduces Hierarchical State Machine implementation using QEP processor . Chapter 5 ends the "State Machine" part of the book with the detailed description of 5 state design patterns.
Going through these 5 chapters gives the reader the deep understanding of how to design state machines using UML and how they can be coded. This knowledge is universal and can be used with any CASE tool as well as for manual coding only.

The second part (nearly 450 pages) is devoted to the description of an inner construction and possible implementations of some kind of RTOS called QP. QP itself consists of Q Event Processor, Q event-driven Framework and Q preemptive Kernel. Part two is opened by the chapter called `Real-Time Framework Concepts'. It is especially useful for somebody who has so far used only home grown embedded systems with main loop and ISR. The chapter makes it clear to the reader what the benefits of using such infrastructure over homemade solution are.
The rest of the book is the detailed description of QP in action. The good information is that the reader learns a lot even if he is not going to use QP. The reason for that is a lot of information which describes general concepts e.g. `Synchronous and Asynchronous Preemptions' which are not specific for QP only.

The strong point of the book are many figures which clearly illustrate the author's ideas. The UML diagrams are used for state machines and class relationships descriptions. For data structures relations non UML notation is used just to show the concept in a convenient way. The C/C++ code itself is clean, nicely structured and intertwined with the explanations.

Because of these features I use the book as an educational aid for the graduates who join my team and need some introduction to real commercial programming.

Many years , one book ! ..simply a best seller book ... - 2009-02-11
Reviewer Rating:
For guys, like me, who has spent the last years searching, and coding at the same time!, for a way to generate powefull realtime, scalable, elegant, cost eefctive (memories size) and specially maintenance source code, this book is really a"PEARL".
In fact, you can collect many of Samek approachings over the net, but,have it all inside a book is simply perfect.
It seems you have a big buffet, ranging from hotdogs to salmon speciallities dishes under the same table :)
State machines is a very powerfull approach wich any designer should use extensively, since the begining, for almost everything.
After many years (unfurtenely) I got it ...
Samek put it to work in the middle of a "complete EMBEDDED" system context, I mean, events handling, objects / tasks switching, system exchanging messages etc etc.
He also shows the "prices" to pay for simple vesrsus more sophisticated issues, like cooperative x preemptive OS , simple versus hierarchical state machines.It is a very important point if you don't have endless memory devices.
Well, sometimes to make the thing work is easier then to explain anothers to how and why it is working...Samek made it clearly.
I really appreciated this book and strongly recommend it.
Ricardo Raupp (Chipsat - Brazil)

Critical Read for all Software Developers, not Just Embedded Systems Developers - 2009-08-19
Reviewer Rating:
Reading the other reviews, one might get the impression that this book is mostly geared to embedded systems. If you are an embedded systems developer, this is a no-brainer. However, you might be inclined to pass this up if you do not develop for embedded systems, and that would be a HUGE mistake.

On the surface, this is a technical book geared towards good software practice development on embedded systems, but the author brings such clarity and insight to the value and application of UML Statecharts, that this book is an essential read for anyone who is even thinking of using finite state or hierarchical state machines. It seems that statecharts get short-shrift in other books on UML, and certainly don't give the kind of detail as this book in terms of how one implements such an engine (though it seemed more discussion about the implementation were provided in his first book, another must read). I think he wisely focuses on his C implementation, because of its relevance to the Embedded Systems world, but he provides C++ implementations/ports on his web site, [...]. You should also check that out because he also has an active discussion board, so you can communicate directly with him and his team. It was a bit hidden, but here is the page with ports to other languages -- [...]

With this book, you get a rare perspective/combingation of someone who truly understands UML Statecharts and a savvy developer/architect who demonstrates how to exploit the methodology for practical purposes. The implementation is flexible, precise, and elegant -- a true model for professional software development.

framework-based software tracing - 2009-03-26
Reviewer Rating:
I had the pleasure to get my hands on this book before my talk at the Embedded World Conference about debugging and avoiding bugs [[...]] and discovered framework-based software tracing in it. Framework-based software tracing generates the true, precisely timestamped records of what's happening in the system, even without adding any instrumentation to the application. This is possible because the framework controls the application. Only to understand this concept is worth buying the book. Besides we (embedded) software people tried to improve productivity and quality and failed in both. Maybe the framework based approach for state machines besides just the tracing as described in this book is towards the right way out of the software crises?

--
Robert Berger
Embedded Software Specialist

Reliable Embedded Systems
Consulting Training Engineering
Tel.: (+30) 697 593 3428
Fax.:(+30) 210 684 7881
email: info@reliableembeddedsystems.com
URL: [...]

Browse Similar Topics

Top Level Categories:
Programming
Software Engineering

Sub-Categories:
Programming > C
Software Engineering > Methodologies
Software Engineering > UML