- Paperback: 528 pages
- Publisher: Addison-Wesley Professional; 1 edition (October 3, 2002)
- Language: English
- ISBN-10: 0201699567
- ISBN-13: 978-0201699562
- Product Dimensions: 7.3 x 1.2 x 9 inches
- Shipping Weight: 1.8 pounds
- Average Customer Review: 8 customer reviews
- Amazon Best Sellers Rank: #404,575 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Real-Time Design Patterns: Robust Scalable Architecture for Real-Time Systems Paperback – October 3, 2002
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Customers who bought this item also bought
What other items do customers buy after viewing this item?
From the Back Cover
When creating real-time and embedded (RTE) systems, there is no room for error. The nature of the final product demands that systems be powerful, efficient, and highly reliable. The constraints of processor and memory resources add to this challenge. Sophisticated developers rely on design patterns—proven solutions to recurrent design challenges—for building fail-safe RTE systems.
Real-Time Design Patterns is the foremost reference for developers seeking to employ this powerful technique. The text begins with a review of the Unified Modeling Language (UML) notation and semantics then introduces the Rapid Object-Oriented Process for Embedded Systems (ROPES) process and its key technologies. A catalog of design patterns and their applications follows.
Key topics covered in this book include:
The book's extensive problem-solving templates, which draw on the author's years in the trenches, will help readers find faster, easier, and more effective design solutions.
The accompanying CD-ROM contains:
About the Author
Bruce Powel Douglass is the Chief Evangelist for i-Logix, a leading producer of tools for real-time systems development. He contributed to the original specification of the UML and to the UML 2.0 as one of the co-chairs of the Object Management Group’s Real-Time Analysis and Design Working Group. Bruce consults for a number of companies and organizations, including NASA, on building large-scale, real-time, safety-critical systems. He is the author of seven other books, including Real-Time Design Patterns (Addison-Wesley, 2003) and Doing Hard Time (Addison-Wesley, 1999).
Browse award-winning titles. See more
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
Chapters 4 to 9 lays out a number of patterns that work well in embedded environments. Patterns for any one aspect of the system (memory, safety/reliability, etc.) are grouped into chapters, allowing easy understanding of the relationships between patterns that differ only subtly. Ch.7, especially, covers a number of related patterns that address to dealock avoidance - good stuff, but a bit more comparison between patterns and discussion of how to select between them would have helped. The discussion on deadlock in general is good too, but a standard OS textbook might cover aspects of deadlock in more detail.
Ch.6, on memory, will be a revelation to people who just use malloc() and free() without thinking. There are lots more ways of handling memory. His discussions of different patterns are good but there's always more to say. Memory pools, for example, may have many different meanings: different memory regions (cache vs. main memory) may have different performance features, or (as in DOS or Windows before about Win95) implications for the instruction sets required for memory access. Harvard and multi-bus architectures may use memory pools to reflect different memory accessibility rules. The "fixed-size buffer" pattern is another great one. I've seen it implemented in hardware, for on-chip buffers in network controllers, and in operating systems where objects of a specific data type are reused frequently. (This can overlap with the pool pattern, when there are different pools for buffers of different fixed sizes.)
Ch.3 talks about patterns in general, and the discussion ranges widely. It includes a fairly good discussion of using multiple patterns in one application, but stops short of the tricky cases where one object participates in two different patterns.
On the whole, this is a very useful book. It does presuppose some background in system (as opposed to software) design. That means it's not for the raw beginner, but it doesn't pretend to be. Some of the discussions of low-level system design suffer from shallowness, and some embedded topics are simply never discussed. Memory structures for block-erasable FLASH, for example, may resemble those used in writable CD-ROMs. Every book has bounds, though, and Douglass has done a good job within the bounds he chose.
I have found that many of the older problems as well as more recent ones are usually due to partial realization that the code is indeed using a pattern, but not instantiating all of it. The text continues to be an excellent resource while in training. Waiting for a chance to actually do something with it in practice
This makes the table of contents less useful and the index impossible to use. I have no idea whether I just received a bad print, or whether the entire edition is like that.
In my copy, there isn't even a hint of page numbers, just nothing at all.
I find the included CD-ROM of little use. It contains a outdated version of Rhapsody, but the Readme says, you need an evaluation license from iLogix. In other words, you might as well get a current evaluation copy straight from IBM, with a 1 month evaluation license. After that, you are going to be stuck, unless your company already uses the product. This is not an old version you could use for free.
Also lacking are any sample diagrams or any code from the book. Admittedly, this is not a book about learning UML. Nevertheless, it would have been nice, if the CD-ROM contained elaborations on the patterns in the book that you could dive into. So even if you do have access to IBM Rhapsody at work, the CD-ROM won't give you that much extra value.