Customer Reviews

Doing Hard Time: Developing Real-Time Systems with UML, Objects, Frameworks, and Patterns

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

 

 

The book appears to be a testament to "why I am good" rather than a description of the topic at hand. Editorially, figures don't match text, grammar is expansive and lacks understandability, it is difficult to determine whether words used are used in their English or technical sense, and the use of words requiring dictionary lookup is laudable in grade schools somewhat suspect in a book of this caliber (try 'reify'). Technically little scholarship is shown. The section titles are good, the author often strays from them. For analysis of embedded systems, trivial results are stated and no attention is given to their derivation nor to analysis or references to analysis. Little attention is paid topics beyond their brief statement. Much time is wasted on examples which show the authors work engagements but which do not illustrate the point at hand. Critical topics (for embedded systems) need greater attention and technical analysis rather than restating obvious results and hand-waving (tasking, inter-task message passing, event disposition, etc). The employment of statecharts in situations that it is unsuited to is difficult to understand. The placement and analysis of statecharts within the context of UML, and the technical and organizational difficulties and advantages of statecharts within the context of UML need some discussion.

The obvious needs discussion and scholarly treatment, analytical results, including mathematical formulas, and not restatement and explanation by (generally poor) example.

A terrible, terrible book which needs scholarship for it's improvement. Full of pointless examples and lack of technical discussion.

I read this book as a first introduction to OO real time computing. I liked the introduction that covers the three topics of OO, RT systems and fault tolerance (though it does not connect the three topics in any sense). I gave up reading the book after the chapter on method, though I skipped through the remaining chapters. The rest of the book was mainly old stuff on waterfall models and OOA/OOD. The whole book was also very commercial and connected to a specific product from the company that the author works for. There was no comparison to other (in my opinion superior) methods and tools.

Instead of buying this book I would recommend you to buy an established book on real time systems and an established book on OO. You will end up spending less money and get a better overview of the two fields by reading fewer pages.

Wow! And I thought Real-Time UML was good! Doing Hard Time is everything Real-Time UML is plus so much more. I really liked the easy-to-read but in-depth coverage of the "hard stuff" of real-time and embedded systems.

What's special about this book: The coverage of safety critical systems is unparalleled -- safety explained in terms of design patterns and key concepts and how to do this using object methods. The development process in Chapter 4 on ROPES shows how to effectively apply UML to think about, design and construct real-time systems. Chapter 11 explains the difficult concepts of timeliness and gives ways to guarantee schedulability. I've looked at other books on that topic and they're filled with really ugly math which makes for a difficult read. This book explains those concepts in an easy going way. The chapters on behavioral patterns covers "design patterns" for wiring together state machines to solve commonly occurring behavioral issues. I also really liked the chapter on real-time frameworks; it really clarified a number of things that confused me.

This book has information that is either not available elsewhere or, if it is, is very hard to track down and is very opaque read. I've read a lot of books in this genre -- and this is clearly the best. I can hardly wait to apply it on my current project.

The structure of this book is described well in the Amazon's review (by Richard Dragan), so I will not dwell on that.

The size of the book is somewhat daunting (750 pages), however, reading it proved to be easy and even entertaining. This was due to the use of clear language, illustrative examples and due to inclusion of humorous remarks and anecdotes, which broke the otherwise inevitable tediousness of reading a technical book.

"Doing Hard Time" is written in such a way that it allows for two "modes" of reading. A sequential mode, i.e. reading from cover to cover - this is especially good if you trying to familiarize yourself with the field of RT. A "multi-threaded" mode, whereby you use this book as a reference material and consult only those chapters that are of particular interest to you at that instance of time. I also reckon that reading this book will help to prevent much frustration of trying to reinvent the wheel.

In the good tradition of the OO methodologies, some re-use has been accomplished from Douglass's previous book ("Real-Time UML"). However, each of the topics dealt with in the "RT UML" has been significantly expanded and new chapters have been added to this book. Even if you have "RT UML", I still suggest "Doing Hard Time" - it's "bigger and better", especially if you can get it on the Amazon's special (40% off!).

All in all, I wholeheartedly recommend "Doing Hard Time" to all embedded s/w developers, beginners and experts alike - this book has potential of becoming a "classic".

Everything I have said for RT UML holds for this book also: a MUST HAVE for embedded developers. This book adds to the previous one from Douglass a lot of material (it definitely includes the material presented in that one) but the main advantage for me is the plethora of design patterns for real-time described. Since this is a very large book, it does not prove as easy to read through, but the additional material is definitely worth it. Finally, another plus point is that the accompanying CD includes a lightweight demo of Rhapsody - the tool from I-Logix that amongst other things claims full code generation. END

I'd have to go along with the last 2 readers reviews. This book provides a brief summary of a lot of issues but provides no real substance. A lot of the examples just demonstrate the author's past experience with no explanation as to how you would apply them to your own. There are better books out there for designing systems with UML.

Even though this book focuses on object-oriented software development for real-time systems, I am certain that it can serve as a valuable source of insight for all developers - including those working on systems outside the targeted area or using alternative approaches. It is very comprehensive and provides clearly written discussions on many subjects which are generally not properly treated in other software development texts. Examples of such topics are: frameworks, patterns, statecharts, threads, architectural design and safety requirements. The author's conversational style combined with effective use of humour ensure that reading the more than 700 pages of this book will not be regarded as "doing hard time" but rather as an enjoyable experience.

A fantastic description of how to apply UML and OO process to Embedded and Real-Time systems. Bruce does a great job of keeping the material informative and interesting with concrete "real world" examples. I especially enjoyed the discussion of process and which UML artifacts are used in what phase of development and why. This book has quickly become required reading in my organization. If you want a UML book that provides "how to" knowledge without the doctoral dissertation, then this is for you.