Register your product to gain access to bonus material or receive a coupon.
Real-Time UML: Developing Efficient Objects for Embedded Systems, 2nd Edition
- By Bruce Powel Douglass
- Published Oct 27, 1999 by Addison-Wesley Professional. Part of the Addison-Wesley Object Technology Series series.
Book
- Sorry, this book is no longer in print.
Description
- Copyright 2000
- Dimensions: 7-3/8x9-1/4
- Pages: 368
- Edition: 2nd
- Book
- ISBN-10: 0-201-65784-8
- ISBN-13: 978-0-201-65784-5
"Real-Time UML, Second Edition, uniquely ties together the principal UML capabilities as they can apply to embedded, real-time systems. Real-time systems development is difficult; this book will help guide developers through some of the minefields."
--Doug Locke, Lockheed Martin Corporation
The increasing complexity of embedded and real-time systems requires a more premeditated and sophisticated design approach for successful implementation. The object-based Unified Modeling Language (UML) can describe the structural and behavioral aspects critical to real-time systems, and has come to the fore as an outstanding medium for effective design.
Like its best-selling predecessor, Real-Time UML, Second Edition, provides an overview of the essentials of real-time systems and an introduction to UML that focuses on its use in design and development. The book examines requirements analysis, the definition of object structure and object behavior, architectural design, mechanistic design, and more detailed designs that encompass data structure, operations, and exceptions. Numerous figures help illustrate UML design techniques, and detailed, real-world examples show the application of those techniques to embedded systems.
This edition features version 1.3 of the UML standard and includes extensive coverage of the action semantics metamodel and statecharts, as well as further descriptions and demonstrations of how to effectively apply use cases and capture object models and state behavior. Real-Time UML, Second Edition, also introduces an elaboration of the author's proven product development process, Rapid Object-Oriented Process for Embedded Systems (ROPES), and a new appendix on the UML extension process.
Key topic coverage includes:
- Specifying external events
- Identifying use cases
- Response time
- Concurrent collaboration diagrams
- Key strategies for object-identification
- Defining object state behavior
- UML state diagrams
- Orthogonal components and concurrency
- Implementing state machines
- Representing physical architecture in UML
- Safety and reliability patterns
- Concurrent state diagrams
- Assigning priorities
- State behavior patterns
0201657848B04062001
Sample Content
Table of Contents
(Each chapter concludes with A Look Ahead and References.)
Figure List.
About the Author.
Foreword by David Harel.
Preface to the Second Edition.
Preface to the First Edition.
Acknowledgments.
1. Introduction to Real-Time Systems and Objects.
What is Special About Real-Time Systems?
Dealing with Time.
Model-Based Development.
Development Activities of the ROPES Process.
Advantages of Objects.
Object Orientation with UML.
Objects.
Attributes.
Behavior.
Messaging.
Concurrency.
Classes.
Relations among Classes and Objects.
UML Diagrams and Notation.
2. Requirements Analysis of Real-Time Systems.
Use Cases.
Actors.
Requirements.
Use Case Relations.
Using Use Cases.
Filling Out the Details of the Use Cases.
Scenarios.
Sequence Diagrams.
Message Properties.
Capturing Time and Timelines.
Statecharts and Use Cases.
Identifying Use Cases.
3. Analysis: Defining the Object Structure.
The Object Discovery Process.
Connecting the Object Model with the Use Case Model.
Key Strategies for Object-Identification.
Underline the Noun Strategy.
Identify the Casual Objects.
Identify Services (Passive Contributors).
Identify Real-World Items.
Identify Physical Devices.
Identify Key Concepts.
Identify Transactions.
Identify Persistent Information.
Identify Visual Elements.
Identify Control Elements.
Apply Scenarios.
Identifying Object Associations.
Object Attributes.
Discover Candidate Classes.
Class Diagrams.
Elevator Class Diagram Example.
Defining Class Relationships and Associations.
Associations.
Aggregations and Composition.
RTOS Example.
Associative Classes.
Generalization Relationships.
4. Analysis: Defining Object Behavior.
Object Behavior.
Simple Behavior.
State Behavior.
Continuous Behavior.
Defining Object State Behavior.
UML Statecharts.
Basic Statecharts.
And-States.
Submachines.
Inherited State Models.
Cardiac Pacemaker Example.
The Role of Scenarios in the Definition of Behavior.
Timing Diagrams.
Sequence Diagrams.
Event Hierarchies.
Defining Operations.
Types of Operations.
Strategies for Defining Operations.
5. Architectural Design.
Overview of Design.
What is Architectural Design?
Physical Architecture Issues.
Software Architecture Issues.
Representing Physical Architecture in UML.
Architectural Patterns.
Master-Slave Pattern.
Microkernel Pattern.
Proxy Pattern.
Broker Pattern.
Concurrency Design.
Representing Tasks.
System Task Diagram.
Concurrent State Diagrams.
Defining Threads.
Identifying Threads.
Assigning Objects to Threads.
Defining Thread Rendezvous.
Sharing Resources.
Assigning Priorities.
6. Mechanistic Design.
What is Mechanistic Design?
Mechanistic Design Patterns.
Simple Patterns.
Reuse Patterns.
7. Detailed Design.
What is Detailed Design?
Data Structure.
Data Collection Structure.
Associations.
Operations.
Visibility.
Algorithms.
Exceptions.
Summary.
Appendix A: Notational Summary.
Appendix B: The Future of the UML for Real-Time.
Index. 0201657848T04062001
Preface
Preface to the Second Edition
I have been both pleased and gratified by the success of the first edition of Real-Time UML: Developing Efficient Objects for Embedded Systems. I think the popularity of the first edition is due to both its timeliness and the appropriateness of object technology (in general) and the UML (in particular) to the development of real-time and embedded systems. At the time of the publication of the first edition, it was clear that the UML would be a major force in the development of object-oriented systems. However, even its strongest supporters have been surprised by the rapidity and near totality of its acceptance by developers. As one methodologist supporting a different modeling approach expressed to me, "I ignored the UML and then got hit with a freight train." The UML is wildly successful in the Darwinian sense of the term, as well in its technical superiority, and has become the most dominant life form in the object ecosphere.
As embedded systems gain in complexity, the old hack-and-ship approaches fail utterly and completely and, occasionally, spectacularly. The complexity of today's systems is driving developers to construct models of the system from different viewpoints in order to understand and plan the various system aspects. These views include the physical, or deployment, view, and the logical, or essential, view. Both views must support structural and behavioral aspects. This is what the UML is about, and this is why it has been so successful.
Audience
The book is oriented toward the practicing professional software developer and the computer science major in the junior or senior year. This book could also serve as an undergraduate- or graduate-level text, but the focus is on practical development rather than a theoretical introduction. Very few equations will be found in this book, but more theoretical and mathematical approaches are referenced where appropriate. The book assumes a reasonable proficiency in at least one programming language and at least a cursory exposure to the fundamental concepts of both object orientation and real-time systems.
Goals
The goals for the first edition remain goals for this edition, as well. This book is still meant to be an easy-to-read introduction to the UML and the application of its notation and semantics to the development of real-time and embedded systems. At the time of this writing, it is one of two books on the UML and real-time systems. I am also the author of the other, Doing Hard Time: Developing Real-Time Systems with UML, Objects, Frameworks, and Patterns (Addison-Wesley, 1999). Doing Hard Time is a more in-depth look at the fundamentals and vagaries of real-time systems, with emphasis on analysis of object schedulability, the use of behavioral patterns in the construction of statechart models, and how to use real-time frameworks effectively. It is a deeper exploration of real-time systems, which happens to use the UML to express these concepts. In contrast, Real-Time UML is primarily about the UML and secondarily about capturing the requirements, structure, and behavior of real-time systems using the UML.
In addition to these original goals for the first edition, the second edition adds two more: (1) to bring the book in conformance with the recent changes in the UML standard, and (2) to enhance the book's effectiveness based on feedback from the first edition.
The UML has undergone a couple of revisions since its original acceptance by the OMG. The first revision, 1.2, is almost exclusively editorial, with no significant modification. The UML revision 1.3, on the other hand, is a significant improvement in a variety of ways. For example, the "uses" stereotype of generalization of use cases has now been replaced with the "includes" stereotype of dependency, which makes a great deal more sense.
Similarly, the notion of an action in UML 1.1 relied heavily on the use of "uninterpreted text" to capture its details. The UML 1.3 has elaborated the metamodel to encompass a number of different kinds of actions, making behavioral modeling more complete. The action semantics metamodel and how it relates to object messaging, is discussed in Chapters 2 and 4.
There have been a number of changes to the statechart model in the 1.3 revision, as well. The first edition of Real-Time UML devoted a lot of space to statecharts, and this second edition expends even more effort in the coverage of behavioral modeling with statecharts. Much of this space is used for the new features of statecharts--synch pseudostates, stub states, and so on. This resulted in a significant rewrite of Chapter 4, which deals with object behavioral modeling.
Recent consulting experience in fields ranging from advanced medical imaging to the next generation of intelligent, autonomous spacecraft, in addition to reader feedback from the first edition, is reflected in this second edition. For example, numerous consulting efforts have convinced me that many developers have a great deal of difficulty understanding and applying use cases to capture requirements for real-time and embedded systems. To address this need, I developed a one-day course called Effective Use Cases, which I have given at NASA and elsewhere. Principles that have proven their effectiveness in the field are captured here, in Chapter 2. Similarly, the techniques and strategies that have worked well for capturing object models or state behavior, have wound up expressed in this book, as well.
Another change in this book is the elaboration of an effective process for using the UML in product development. I call this process Rapid Object-Oriented Process for Embedded Systems (ROPES). The most common questions I have been asked since publication of the first book have been about the successful deployment of the UML in project teams developing real-time and embedded systems. Thus, Chapter 1 explains this process and identifies the work activities and artifacts produced during different parts of the iterative lifecycle. In fact, the ROPES process forms the basis for the organization of the book itself, from Chapter 2 through 7.
Despite the goals of the UML in terms of providing a standard, there has been some fractionalization as vendors try to differentiate themselves in the marketplace. While progress will naturally involve vendors providing new and potentially valuable model constructs above and beyond those provided by the UML, several vendors have claimed that their new features will be part of some new yet-to-be-announced UML for Real-Time. Interestingly, some of these vendors don't even participate in the OMG, while others provide mutually incompatible "enhancements." By spreading this FUD (fear, uncertainty, and doubt) among the developer community, I feel these vendors have done a great disservice to their constituency. Developers should understand both the benefits and risks of using single-source modeling concepts. These features may make the system easier to model (although, in many cases, these so-called enhancements fail in that regard), but it also locks the product development to a single vendor's tool. Another risk is the inability to use model interchange between tools when the models no longer adhere to the UML standard. This can greatly decrease the benefits to the developer of using the UML. In an effort to dispel some of the FUD, I've added Appendix B to outline what it means to make changes to the standard, why no single vendor can claim it owns the UML standard (it is, after all, owned by the OMG), and what changes are likely to be made to the UML over the next several years.
Finally, I would suggest that interested readers visit the I-Logix Web site, www.ilogix.com. There you will find a number of papers on related topics, written by myself and others, as well as the UML specifications, tool descriptions, and links to relevant sites.
--Bruce Powel Douglass, Ph.D.
Spring, 1999
Preface to the First Edition
Goals
Real-Time UML: Developing Efficient Objects for Embedded Systems is an introduction to object-oriented analysis and design for hard real-time systems using the Unified Modified Language (UML). UML is a third-generation modeling language that rigorously defines the semantics of the object metamodel and provides a notation for capturing and communicating object structure and behavior. Many methodologists--including Grady Booch (Booch Method), Jim Rumbaugh (Object Modeling Technique OMT), Ivar Jacobson (Object-Oriented Software Engineering OOSE), and David Harel (Statecharts)--collaborated to achieve UML. Many more participated, myself included, in the specification of the UML, and we believe that it is the leading edge in modeling for complex systems.
There are very few books on the use of objects in real-time systems and even fewer on UML. Virtually all object-oriented books focus primarily on business or database application domains and do not mention real-time aspects at all. On the other hand, texts on real-time systems have largely ignored object-oriented methods. For the most part, they fall into two primary camps: those that bypass methodological considerations altogether and focus solely on "bare metal" programming, and those that are highly theoretical, with little advice for actually implementing workable systems. Real-Time UML: Developing Efficient Objects for Embedded Systems is meant to be a concise and timely bridge for these technologies, presenting the development of deployable real-time systems using the object semantics and notation of the UML. This has many advantages, including focusing the development process of real-time systems into logical, concrete steps that progress in an orderly fashion, with a standardized notation.
Audience
The book is oriented toward the practicing professional software developer and the computer science major in the junior or senior year. This book could also serve as an undergraduate- or graduate-level text, but the focus is on practical development rather than a theoretical introduction. Very few equations will be found in this book, but more theoretical and mathematical approaches are referenced where appropriate. The book assumes a reasonable proficiency in at least one programming language and at least a cursory exposure to the fundamental concepts of both object orientation and real-time systems.
Organization
The book follows the normal analysis ' design ' implementation approach followed by most development projects. The first chapter identifies the fundamental concepts of objects and real-time systems. The next two discuss analysis--the identification and specification of the problem to be solved. Analysis is divided into two portions: black-box requirements analysis using context diagrams, use cases, and scenarios (Chapter 2), and capturing the key concepts and their relationships from the problem domain (Chapter 3).
Design follows analysis and adds details as to how the analysis model should be implemented. Design is broken up into three parts, each taken up in a separate chapter--architectural, mechanistic, and detailed design. The parts differ in the scope of their concerns. Architectural design deals with very broad scope strategic decisions, such as tasking models and inter-processor design. Mechanistic design focuses on how groups of objects collaborate to achieve common purposes. Both architectural and mechanistic design chapters include a number of patterns that have been found generally applicable in real-time systems. Finally, detailed design specifies the internal structure and function of individual objects.Throughout the book, UML notation is introduced where and as needed. However, a notational summary is provided in the appendix so that this book can continue to serve as a reference guide as your projects evolve.
Examples
Two different approaches to examples are used in different texts. Some authors (and readers) prefer a single example taken throughout the book to illustrate the various concepts. The other approach is to use many different examples, with the idea that it is more useful to see the concepts used in a wide variety of applications. This book uses a compromise approach. A variety of real-time examples illustrate the concepts and notation of UML in the several real-time application domains, but they reappear in different chapters of the book. This approach reinforces the concepts by showing how they apply in various situations. Special care has been taken to select real-time examples with rich behavioral semantics; however, examples that are not strictly real-time are used where appropriate.
--Bruce Powel Douglass, Ph.D.
Summer, 1997
0201657848P04062001