Skip to content

Real Time UML Advances in the UML for Real-Time Systems

Spend $50 to get a free DVD!

ISBN-10: 0321160762

ISBN-13: 9780321160768

Edition: 3rd 2004 (Revised)

Authors: Bruce Powel Douglass

List price: $79.99
Shipping box This item qualifies for FREE shipping.
Blue ribbon 30 day, 100% satisfaction guarantee!
what's this?
Rush Rewards U
Members Receive:
Carrot Coin icon
XP icon
You have reached 400 XP and carrot coins. That is the daily max!

Description:

The two previous editions were written as easy-to-read introductions to the UML, and how to apply its notation and semantics to the unique requirements involved with the development of real-time and embedded systems. This third edition is no exception. Although the book's emphasis is on UML, it is also about capturing the requirements, structure, and behavior of real-time systems. The most significant change in this revision will be it's integration throughout the book of UML 2.0, and all indications are that UML 2.0 is even more accepting of the unique aspects of real-time and embedded systems development.
Customers also bought

Book details

List price: $79.99
Edition: 3rd
Copyright year: 2004
Publisher: Addison Wesley Professional
Publication date: 2/17/2004
Binding: Paperback
Pages: 752
Size: 7.25" wide x 9.50" long x 1.50" tall
Weight: 2.398
Language: English

Figure List
About the Author
Foreword to the Third Edition
Foreword to the Previous Editions
Preface to the Third Edition
Preface to the Second Edition
Preface to the First Edition
Acknowledgments
Introduction to the World of Real-Time and Embedded Systems
What Is Special about Real-Time Systems?
Time, Performance, and Quality of Service
Modeling Actions and Concurrency
Modeling Resources
Modeling Time
Modeling Schedulability
Modeling Performance
Systems Engineering vs. Software Engineering
What Do We Mean by Architecture?
The Rapid Object-Oriented Process for Embedded Systems (ROPES) Process
Model-Driven Development (MDD)
The ROPES Spiral in More Detail
MDA and Platform-Independent Models
Scheduling Model-Based Projects
Why Schedule?
Estimation
BERT and ERNIE
Scheduling
Model Organization Principles
Why Model Organization?
Specific Model Organization Patterns
Working with Model-Based Projects
Looking Ahead
Exercises
References
Object Orientation with UML 2.0--Structural Aspects
Object Orientation with UML
Small Things: Objects, Classes, and Interfaces
Objects
Classes
Notation
Interfaces
Messaging
Relations
Associations
Aggregation
Composition
Generalization
Dependency
Structural Diagrams
Mapping Objects to Code
Big Things: Packages, Components, and Subsystems
Model Organization: Packages
Structured Classes: Composites, Parts, Ports, and Connectors
Components
Subsystems
Deployments: Nodes and Nonesuch
So, Nodes or Classes?
Architectural Hierarchy
Advanced: UML Metamodel of Structural Elements (for the Advanced Modeler)
Additional Notations and Semantics
Looking Ahead
Exercises
References
Object Orientation with UML 2.0--Dynamic Aspects
Behavior and the UML
Types of Behavior
Simple Behavior
State Behavior
Continuous Behavior
Behavior Primitives: Actions and Activities
Behavior and the Single Object
Basic Statechart Elements
And-States
Pseudostates
Inherited State Models
Ill-Formed Statecharts
Cardiac Pacemaker Example
Protocol State Machines
Activity Diagrams
Interactions
Sequence Diagrams
Timing Diagrams
Summary
Exercises
References
UML Profile for Schedulability, Performance, and Time
UML Profiles
Stereotypes
Tagged Values
Profiles
"RT UML" Profile
General Resource Model Subprofile
Time Modeling Subprofile
Concurrency Modeling Subprofile
Schedulability Modeling Subprofile
Performance Modeling Subprofile
Real-Time CORBA Subprofile
Looking Ahead
Exercises
References
Requirements Analysis of Real-Time Systems
Requirements
Use Cases
Actors
Use Cases and Text
Use Case Relations
Using Use Cases
Identifying Use Cases
Detailing the Use Cases
Scenarios for Use Cases
Statecharts
Activity Diagrams
Timing Diagrams
Looking Ahead
Exercises
References
Analysis: Object Domain Analysis
The Object Discovery Process
Connecting the Object Model with the Use Case Model
Key Strategies for Object Identification
Underline the Noun Strategy
Identify the Causal Objects
Identify Services (Passive Contributors)
Identify Messages and Information Flows
Identify Real-World Items
Identify Physical Devices
Identify Key Concepts
Identify Transactions
Identify Persistent Information
Identify Visual Elements
Identify Control Elements
Apply Scenarios
Identify Object Associations
Object Attributes
Discovering Candidate Classes
Class Diagrams
Associative Classes
Generalization Relationships
Looking Ahead
Exercises
References
Analysis: Defining Object Behavior
Object Behavior
Simple Behavior
State Behavior
Continuous Behavior
Defining Object State Behavior
Cardiac Pacemaker Example
Calculator Example
Event Hierarchies
Interactions
Sequence Diagrams
Defining Operations
Types of Operations
Strategies for Defining Operations
Looking Ahead
Exercises
References
Architectural Design
Overview of Design
What Is Architectural Design?
Logical Architecture
Physical Architecture
Subsystem and Component View
Concurrency and Resource View
Distribution View
Safety and Reliability View
Deployment View
Physical Architecture Issues
Software Architecture Issues
Software Meets Hardware: Deployment Architecture in UML
Concurrency and Resource Design
Representing Threads
System Task Diagram
Concurrent State Diagrams
Defining Threads
Identifying Threads
Assigning Objects to Threads
Defining Thread Rendezvous
Sharing Resources
Assigning Priorities
Looking Ahead
Exercises
References
Mechanistic Design
What Is Mechanistic Design?
Mechanistic Design Patterns
The Observer Pattern
Abstract
Problem
Pattern Structure
Collaboration Roles
Consequences
Implementation Strategies
Sample Model
The Proxy Pattern
Abstract
Problem
Pattern Structure
Collaboration Roles
Consequences
Implementation Strategies
Sample Model
Reliable Transaction Pattern
Abstract
Problem
Pattern Structure
Collaboration Roles
Consequences
Implementation Strategies
Sample Model
Smart Pointer Pattern
Abstract
Problem
Pattern Structure
Collaboration Roles
Consequences
Implementation Strategies
Related Patterns
Sample Model
Guarded Call Pattern
Abstract
Problem
Pattern Structure
Collaboration Roles
Consequences
Implementation Strategies
Sample Model
Container Pattern
Abstract
Problem
Pattern Structure
Collaboration Roles
Consequences
Implementation Strategies
Sample Model
The Rendezvous Pattern
Abstract
Problem
Pattern Structure
Collaboration Roles
Consequences
Implementation Strategies
Related Patterns
Sample Model
Looking Ahead
Exercises
References
Detailed Design
What Is Detailed Design?
Data Structure
Associations
Operations
Visibility
Algorithms
Exceptions
Summary
Exercises
References
Special Topic: C[superscript 4]ISR Architecture and the UML
Introduction
What is C[superscript 4]ISR?
Required Products of C[superscript 4]ISR
AV-1 Overview and Summary Information
The AV-2 Integrated Dictionary
OV-1 High-Level Operational Concept Graphic
OV-2 Operational Node Connectivity Description
OV-3 Operational Information Exchange Matrix
SV-1 System Interface Description
TV-1 Technical Architecture Profile
Supporting Products
OV-4 Command Relationships Chart
OV-5 Operational Activity Model
OV-6a Operational Rules Model, SV-10a Systems Rules Model
OV-6b Operational State Transition Description, SV-10b Systems State Transition Description
OV-6c Operational Event-Trace Description, SV-10c Systems Event Trace Description
OV-7 Logical Data Model
SV-3 Systems-Systems Matrix
SV-4 Systems Functionality Description
SV-5 Operational Activity to Systems Function Traceability Matrix
SV-6 Systems Data Exchange Matrix
SV-7 Systems Performance Parameters Matrix
SV-8 Systems Evolution Description
SV-9 Systems Technology Forecast
SV-11 Physical Schema
Summary
Acknowledgments
References
Notational Summary
Index