Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

[ ] (brackets)
guard conditions, Decisions and Merges
multiplicities on connectors, Connectors
: (colon)
in attribute name, Name and Type
in operation signature, Return Types
{ } (curly braces), constraints, Abstract Classes
:: (double colons), in fully-scoped class name, Namespaces and Classes Referring to Each Other
<< >> (guillemots), stereotypes, Stereotype applied to classes (see Chapters 4 and 5), Interfaces
# (hash symbol), protected visibility, Protected Visibility
- (minus symbol), private visibility, Private Visibility, Element Visibility
( ) (parentheses), annotations, Partitions (or Swimlanes)
+ (plus symbol)
public visibility, Public Visibility, Element Visibility
~ (tilde), package visibility, Package Visibility
4+1 view model (Krutchen), Views of Your Model, Views of Your Model
“Architectural Blueprints—The “4+1” View Model of Software Architecture” (Krutchen), A First Taste of UML

A

abstract classes, Modeling a System’s Logical Structure: Advanced Class Diagrams, Abstract Classes
abstraction level of classes, Abstraction
actions, Activity Diagram Essentials
in Activity diagram, Activity Diagram Essentials
inputs and outputs for, Showing Action Inputs and Outputs
objects passed between, Objects
parallel, Doing Multiple Tasks at the Same Time
activation bars
indicating active participant, Activation Bars
return messages at end of, The Return Message
active states, Essentials
activities, Activities and Actions
called within Activity diagram, Calling Other Activities
changing state of object, Showing How Objects Change State During an Activity
enclosing in activity frame, Decisions and Merges
ending, Activity Diagram Essentials, Starting an Activity
flow of, Activity Diagram Essentials
interrupting, Interrupting an Activity
naming, Decisions and Merges
starting, Activity Diagram Essentials, Starting an Activity
Activity diagram, Why UML 2.0?, Activity Diagram Essentials
actions in, Activity Diagram Essentials
calling other activities from, Calling Other Activities
compared to Interaction Overview diagram, The Parts of an Interaction Overview Diagram
concurrent tasks in, Doing Multiple Tasks at the Same Time
connectors in, Partitions (or Swimlanes)
decisions in, Activities and Actions, Decisions and Merges
edges in, Activity Diagram Essentials
ending, Starting an Activity
ending flows in, Ending a Flow
expansion regions in, Expansion Regions
final node in, Activity Diagram Essentials
guard conditions in, Decisions and Merges
in process view, A First Taste of UML
initial node in, Activity Diagram Essentials
interrupting, Interrupting an Activity
merges in, Activities and Actions, Decisions and Merges
objects in, Objects
partitions in, Partitions (or Swimlanes)
signals to and from external participants, Sending and Receiving Signals
starting, Starting an Activity
time events in, Time Events
when to create, What’s Next?
activity final nodes
in Activity diagram, Activity Diagram Essentials
multiple, Interrupting an Activity
activity frame, Activities and Actions, Calling Other Activities
actors, Capturing a System Requirement, Capturing a System Requirement
generalizations used with, Refining actors
naming, Outside Your System: Actors
notation for, Outside Your System: Actors
participation with use cases, showing, Communication Lines
primary actor for use case, Use Case Descriptions
relationships between, Refining actors
system boundaries excluding, System Boundaries
tricky actors, Tricky actors
aggregation between classes, Aggregation
agile methods of software development, Views of Your Model
Agile Software Development (Prentice Hall), Managing Package Dependencies
alt fragment, A Brief Overview of UML 2.0’s Fragment Types
angle brackets (<< >>), stereotypes, Stereotype applied to classes (see Chapters 4 and 5), Interfaces
annotations for partitions, Activity diagram, Partitions (or Swimlanes)
anonymous objects, Object Instances
arrows
arrowed lines (edges), Activity Diagram Essentials
connecting states (transitions), Essentials
dependency arrows, Dependency, Showing Components Working Together
dotted arrow (<<include>> relationships), The <<include>> Relationship
extension arrow in profile, Creating a Profile
filled diamond arrowhead (compositions), Composition
generalization arrow
class inheritance, Generalization and implementation reuse
use case inheritance, Special Cases
message arrows, Message Signatures, Message Arrows
on state-lines, Timing Constraints
artifacts, Deployed Software: Artifacts
dependencies between, Deploying an Artifact to a Node
deploying to a node, Deployed Software: Artifacts
deployment specifications as, Deployment Specifications
manifesting components, Tying Software to Artifacts
notation for, Deployed Software: Artifacts
of components, Showing Components Working Together
stereotypes applied to, Stereotypes applied to artifacts (see Chapter 15)
assembly connectors, Showing Components Working Together, Assembly Connectors
association classes, Association classes
associations between classes, Association
attributes representing, Class State: Attributes, Inline Attributes Versus Attributes by Association
object links requiring, Links
properties representing, Alternate Multiplicity Notations
asynchronous messages, Asynchronous Messages, Applying Participant Deletion, The Main Event
attributes, What Is a Class?, Class State: Attributes
as collections of objects (multiplicity), Multiplicity
associated with another class, Class State: Attributes
inline attributes, Class State: Attributes
naming, Name and Type
properties of, Attribute Properties
static, Static Parts of Your Classes
type of, Name and Type
visibility of, Visibility

B

base use cases, Special Cases
behavioral state machines, Modeling an Object’s State: State Machine Diagrams
binding templates, Binding Class Templates
black-box component views, Black-Box and White-Box Component Views
blueprint, UML used as, UML and the Software Development Process
BPM (business process management) tools, Activity Diagram Essentials
brackets ([ ])
guard conditions, Decisions and Merges
multiplicities on connectors, Connectors
break fragment, A Brief Overview of UML 2.0’s Fragment Types
business process management (BPM) tools, Modeling System Workflows: Activity Diagrams
business processes, Modeling System Workflows: Activity Diagrams

C

call activity node, Calling Other Activities
Chain of Responsibility (COR) design pattern, Showing Patterns with Collaborations
child classes, Generalization (Otherwise Known as Inheritance)
choice pseudostates, Advanced Pseudostates
Class diagram, Why UML 2.0?, Visibility
abstract classes in, Abstract Classes
attributes in, Class State: Attributes
class relationships in, Class Relationships
constraints in, Constraints
in logical view, A First Taste of UML
interfaces in, Interfaces
operations in, Class Behavior: Operations
Package diagram modeled using, Packages
static class elements in, Static Parts of Your Classes
templates in, Templates
when not to use, When Class Diagrams Won’t Work
when to create, What’s Next?
class invariant, Constraints
classes, Modeling a System’s Logical Structure: Introducing Classes and Class Diagrams
abstract classes, Modeling a System’s Logical Structure: Advanced Class Diagrams, Abstract Classes
association classes, Association classes
attributes of, Class State: Attributes
compared to components, A Basic Component in UML
composition relationship between, Parts of a Class
constraints for, Constraints, Links
delegation and, Multiple inheritance
encapsulation and, Encapsulation
interfaces for, Class Relationships, Interfaces, Showing How a Class Is Used
name of, Getting Started with Classes in UML
notation for, Visibility
operations of, Class Behavior: Operations
ports for, Internal Structure, Showing How a Class Is Used
public interface of, Public Visibility
realizing components, Classes That Realize a Component
relationships between, Class Relationships, Class Relationships
static, Static Parts of Your Classes
stereotypes applied to, Stereotype applied to classes (see Chapters 4 and 5)
templates for, Class Relationships, Templates
tightly coupled, Class Relationships, Generalization and implementation reuse
visibility of elements in, Visibility
clock, system, as tricky actor, Tricky actors
collaborations, Internal Structure, Showing Patterns with Collaborations
colons, double (::), in fully-scoped class name, Namespaces and Classes Referring to Each Other
Communication diagram, Why UML 2.0?, Participants, Links, and Messages
communication links in, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
compared to Sequence diagram, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
creating from interactions, Fleshing out an Interaction with a Communication Diagram
in logical view, A First Taste of UML
incorporated into Interaction Overview diagram, Modeling a Use Case Using an Interaction Overview
messages in, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
invoked conditionally, Invoking a Message Multiple Times
nested, Fleshing out an Interaction with a Communication Diagram
sent by pariticipant to itself, When a Participant Sends a Message to Itself
simultaneous, Messages Occurring at the Same Time
participants in, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
when to create, What’s Next, What’s Next, What’s Next?
when to use, What’s Next?
communication lines, Communication Lines
communication links, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram, The Main Event
communication paths between nodes, Communication Between Nodes
Component diagram, Why UML 2.0?, What Is a Component?
components in, A Basic Component in UML
dependencies in, Showing Components Working Together
in development view, A First Taste of UML
interfaces in, Provided and Required Interfaces of a Component
internal structures in, Delegation Connectors
realizing classes in, Classes That Realize a Component
views of components in, Black-Box and White-Box Component Views
components, Managing and Reusing Your System’s Parts: Component Diagrams
as subsystems, Provided and Required Interfaces of a Component
black-box view of, Black-Box and White-Box Component Views
compared to classes, A Basic Component in UML
dependencies between, Showing Components Working Together
interfaces for, Provided and Required Interfaces of a Component, Showing Components Working Together
internal structure of, Ports and Internal Structure
notation for, A Basic Component in UML
realized by classes, Classes That Realize a Component
stereotypes applied to, Stereotypes applied to artifacts (see Chapter 15)
white-box view of, Black-Box and White-Box Component Views
composite states, Composite States
Composite Structure diagram, Why UML 2.0?
collaborations in, Showing Patterns with Collaborations
connectors in, Connectors
objects with internal structures in, Showing Complex Relationships Between Contained Items
ports in, Showing How a Class Is Used
when to create, What’s Next, What’s Next
when to use, Internal Structure
concurrent tasks, Activity diagram, Doing Multiple Tasks at the Same Time
connectors
in Activity diagram, Partitions (or Swimlanes)
in Component diagram, Showing Components Working Together
constraints
for classes
in Class diagram, Constraints
in Object diagram, Links
in profiles, Creating a Profile
timing constraints, Timing Constraints
COR (Chain of Responsibility) design pattern, Showing Patterns with Collaborations
create message, Applying Participant Creation
critical regions, What’s Next?
curly braces ({ }), constraints, Abstract Classes

D

decisions, Activity diagram, Activities and Actions, Decisions and Merges
delegation, Generalization and implementation reuse
delegation connectors, Ports and Internal Structure
dependencies
between components, Showing Components Working Together
between packages, Package Dependency
Deployment diagram, Models and Diagrams, Deploying a Simple System
artifacts (files) in, Deployed Software: Artifacts
communication paths in, Communication Between Nodes
execution environments in, What Is a Node?
hardware in, Deploying a Simple System
in physical view, A First Taste of UML
nodes in, What Is a Node?
when to create, What’s Next?
when to use, When to Use a Deployment Diagram
deployment specifications, Deployment Specifications
design patterns, Showing Patterns with Collaborations
abstract classes and, Abstract Classes
collaborations as, Internal Structure
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley), Multiple inheritance, Interfaces, Showing Patterns with Collaborations
destroy method, Participant Creation and Destruction Messages
development view, A First Taste of UML, Managing and Reusing Your System’s Parts: Component Diagrams
diagram notations
arrows
arrowed lines (edges), Activity Diagram Essentials
connecting states (transitions), Essentials
dependency arrows, Showing Components Working Together
extension arrow in profile, Creating a Profile
filled arrow (messages), Participants, Links, and Messages
generalization arrow (class inheritance), Generalization and implementation reuse
message arrows, Message Arrows
on state-lines, Timing Constraints
artifact symbol, Deploying an Artifact to a Node
ball and socket (assembly connectors), Showing Components Working Together
ball symbol
interfaces, Interfaces
provided interfaces, Provided and Required Interfaces of a Component
brackets ([ ])
guard conditions, Decisions and Merges
multiplicities on connectors, Connectors
circle with enclosed character (connectors), Partitions (or Swimlanes)
circle, filled
initial node, Activity Diagram Essentials
initial pseudostates, States
circles, concentric, with filled center
final node, Activity Diagram Essentials
final states, Essentials
columns or rows in (partitions), Partitions (or Swimlanes)
cross
in Sequence diagram (participant destruction), A Top-Level Sequence Diagram
in Timing diagram (events), An Alternate Notation
cube (nodes), What Is a Node?
curly braces ({ }), constraints, Abstract Classes
diamond
decisions, Activities and Actions, Decisions and Merges
merges, Activities and Actions, Decisions and Merges
double colons (::), in fully-scoped class name, Namespaces and Classes Referring to Each Other
folder with tab (packages), Packages
forks (joins), Doing Multiple Tasks at the Same Time
fragment box (sequence fragments), Managing Complex Interactions with Sequence Fragments
guillemots (<< >>), stereotypes, Stereotype applied to classes (see Chapters 4 and 5), Interfaces
hourglass (time events), Time Events
italic operations (abstract classes), Abstract Classes
lines
activation bars for active participants, Activation Bars
arrowed lines (edges), Activity Diagram Essentials
between nodes (communication paths), Communication Between Nodes
between objects (links), Links
between participants (communication links), Participants, Links, and Messages
lifelines for participants, Participants in a Sequence Diagram, Applying Participant Creation, The Parts of an Interaction Overview Diagram
state-lines for participants, A Participant’s State-Line
minus symbol (-), private visibility, Element Visibility
nodes (hardware), Deploying a Simple System
oval, dashed (collaborations), Showing Patterns with Collaborations, Showing Patterns with Collaborations
parentheses (( )), annotations, Partitions (or Swimlanes)
pitchfork, upside-down (call activity node), Calling Other Activities
plus symbol (+)
public visibility, Public Visibility, Element Visibility
receive signal nodes, Sending and Receiving Signals
rectangle
participants, Focusing on Interaction Links: Communication Diagrams
rectangle split into sections (classes), Visibility
rectangle with tab icon (components), A Basic Component in UML
rectangle with underlined name (objects), Object Instances
rectangle, dashed rounded
interruption regions, Interrupting an Activity
rectangle, folded
notes, A First Taste of UML
tagged values, Tagged values
rectangle, rounded
actions, Activity Diagram Essentials
activity frames, Decisions and Merges
states, Modeling an Object’s State: State Machine Diagrams
rectangle, tabbed (protocol state machines), Protocol State Machines
send signal nodes, Sending and Receiving Signals
socket symbol (required interfaces), Provided and Required Interfaces of a Component
stick figure
actors, Capturing a System Requirement
stereotypes, A First Taste of UML
“t” in Timing diagram, Exact Time Measurements and Relative Time Indicators, Timing Constraint Formats
diagrams
as views of model, Models and Diagrams
complexity of
alternate Timing diagram notation for, An Alternate Notation
hardware node naming and, Deploying a Simple System
minimizing, Applying Participants to a Timing Diagram
Package diagram, UML Tool Variation
list of, Why UML 2.0?
views of, Views of Your Model
do behavior of states, Internal Transitions
documentation for UML, Want More Information?
double colons (::), in fully-scoped class name, Namespaces and Classes Referring to Each Other

E

edges, Activity diagram, Activity Diagram Essentials
encapsulation, Encapsulation
events, Events, Signals, and Messages
in Timing diagram, Events and Messages
timing constraints for, Timing Constraints
exact time measurements, Exact Time Measurements and Relative Time Indicators
executable UML, Why UML 2.0?
execution environments, What Is a Node?

F

final node, Activity diagram, Activity Diagram Essentials
final state, State Machine diagram, States
fork pseudostates, Advanced Pseudostates
forks
flow final nodes and, Partitions (or Swimlanes)
in Activity diagram, Doing Multiple Tasks at the Same Time
formal modeling language, Getting the Balance Right: Formal Languages
Fowler, Martin (ways of using UML), UML and the Software Development Process
fragment box, Managing Complex Interactions with Sequence Fragments
fragment operator, Managing Complex Interactions with Sequence Fragments
fragments, in Sequence diagram, Managing Complex Interactions with Sequence Fragments

G

generalization
multiple generalization, Multiple inheritance
of actors, Refining actors
guard conditions
for choice pseudostate, Advanced Pseudostates
in Activity diagram, Decisions and Merges
in State Machine diagram, Transition Variations
guillemots (<< >>), stereotypes, Stereotype applied to classes (see Chapters 4 and 5), Interfaces

H

hardware
deploying artifacts to, Deployed Software: Artifacts
nodes representing, What Is a Node?
notation for, Deploying a Simple System
Head First Design Patterns (O’Reilly), What’s Next, Showing Patterns with Collaborations

I

icons
associated with stereotypes, Stereotypes
inactive states, Essentials
incoming edges, Activity diagram, Activity Diagram Essentials
informal languages as modeling language, Verbosity, Ambiguity, Confusion: Modeling with Informal Languages
initial node
in Activity diagram, Activity Diagram Essentials, Starting an Activity
time event as alternative to, Calling Other Activities
initial pseudostates, State Machine diagram, States, Advanced Pseudostates
inline attributes, Class State: Attributes
interaction diagrams, Modeling Ordered Interactions: Sequence Diagrams
Interaction Overview diagram, Why UML 2.0?, The Parts of an Interaction Overview Diagram
compared to Activity diagram, The Parts of an Interaction Overview Diagram
creating from use case, Modeling a Use Case Using an Interaction Overview
when to use, What’s Next?
interactions
breaking into participants, Breaking an Interaction into Separate Participants
creating Communication diagram from, Fleshing out an Interaction with a Communication Diagram
executing in parallel, What’s Next?
timing constraints for, Timing Constraints
interfaces
for classes, Class Relationships, Interfaces, Showing How a Class Is Used
for components, Provided and Required Interfaces of a Component, Showing Components Working Together
notation for, Interfaces, Provided and Required Interfaces of a Component
interruption regions, Interrupting an Activity
invariants, Constraints
iterative methods of software development, Views of Your Model

J

Java 5 Tiger: A Developer’s Notebook (O’Reilly), What’s Next?
Java in a Nutshell, Asynchronous Messages
join pseudostates, Advanced Pseudostates
joins, Activity diagram, Doing Multiple Tasks at the Same Time

K

Krutchen, Philippe (“Architectural Blueprints—The “4+1"View Model of Software Architecture”), A First Taste of UML
Krutchen’s 4+1 view model, Views of Your Model

L

life cycle of object, States in Software
lifelines
in Interaction Overview diagram, The Parts of an Interaction Overview Diagram
in Sequence diagram, Participants in a Sequence Diagram
lines
activation bars for active participants, Activation Bars
arrowed lines (edges), Activity Diagram Essentials
between nodes (communication paths), Communication Between Nodes
between objects (links), Links
between participants (communication links), Participants, Links, and Messages
lifelines for participants, Participants in a Sequence Diagram, The Parts of an Interaction Overview Diagram
state-lines for participants, A Participant’s State-Line
links
between objects, Links
communication links, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
lists, templates used for, Templates, Binding Class Templates
logic analyzer, Timing diagram compared to, What Do Timing Diagrams Look Like?
logical view, A First Taste of UML
loop fragment, A Brief Overview of UML 2.0’s Fragment Types

M

Martin, Robert C. (Agile Software Development), Managing Package Dependencies
MDAs (Model Driven Architectures), Why UML 2.0?
merges, Activity diagram, Activities and Actions, Decisions and Merges
messages
in Communication diagram, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
nested, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
in Sequence diagram, Events, Signals, and Messages
arrows used by, Message Arrows
asynchronous, Asynchronous Messages, Applying Asynchronous Messages, The Main Event
nested, Nested Messages
return messages, The Return Message
synchronous messages, Synchronous Messages
in Timing diagram, Events and Messages
meta-models, What’s in a Modeling Language?, Working with the Meta-Model
minus symbol (-), private visibility, Element Visibility
Model Driven Architictures (MDAs), Why UML 2.0?
modeling language, What’s in a Modeling Language?
formal languages as, Getting the Balance Right: Formal Languages
software code as, Detail Overload: Modeling with Code
models
diagrams as views of, Models and Diagrams
sharing between machines, Why UML 2.0?
views of, Views of Your Model
multiple inheritance (generalization), Multiple inheritance
multiple processes, forks representing, Time Events
multiple threads, forks representing, Time Events

N

nested messages, Fleshing out an Interaction with a Communication Diagram
nodes, What Is a Node?
communication between, Communication Between Nodes
notation for, What Is a Node?
notation, What’s in a Modeling Language?
notes, A First Taste of UML

O

Object diagram, Why UML 2.0?, Object Instances
binding class templates in, Binding Class Templates
in logical view, A First Taste of UML
links in, Links
objects in, Object Instances
when to create, What’s Next, What’s Next
objects, Objects, Bringing Your Classes to Life: Object Diagrams
anonymous objects, Object Instances
as participants in Sequence diagram, Time
binding templates with, Binding Class Templates
classes’ relationship to, What Is a Class?
collaborations of, Showing Patterns with Collaborations
life cycle of, States in Software
links between, Links
notation for, Object Instances
passed between actions, Objects
OCL (Object Constraint Language)
expressions, building, Abstract Classes
types of constraints, Constraints
OMG (Object Management Group), Want More Information?, Building OCL Expressions, ...and Bake for 10 to 15 Years
operations, What Is a Class?, Class Behavior: Operations
static, Static Parts of Your Classes
visibility of, Visibility, Class Behavior: Operations
outgoing edges, Activity diagram, Activities and Actions

P

Package diagram, Why UML 2.0?, What’s Next?
in development view, A First Taste of UML
modeling using Class diagram, Packages
when to create, What’s Next, What’s Next
package visibility, Package Visibility
packages, Organizing Your Model: Packages
accessing another package, Importing and Accessing Packages
dependencies between, Organizing Your Model: Packages, Package Dependency, Managing Package Dependencies
importing another package, Importing and Accessing Packages
nested, Contents of a Package, Namespaces and Classes Referring to Each Other
notation for, Packages
target package, Importing and Accessing Packages
use cases in, Using Packages to Organize Use Cases
using in software, Package Dependency
visibility of elements in, Element Visibility
visibility of imports in, Importing and Accessing Packages
par fragment, A Brief Overview of UML 2.0’s Fragment Types
parallel actions, Doing Multiple Tasks at the Same Time
parallel messages, The Main Event
parent classes, Generalization and implementation reuse
parentheses (( )), annotations, Partitions (or Swimlanes)
participants
in Communication diagram, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
in Interaction Overview diagram, The Parts of an Interaction Overview Diagram
in Sequence diagram, Participants in a Sequence Diagram
naming, Participants in a Sequence Diagram
in Timing diagram, Applying Participants to a Timing Diagram
organizing, Organizing Participants on a Timing Diagram
state-lines for, A Participant’s State-Line
states of, States
partitions, Activity diagram, Partitions (or Swimlanes)
physical view, A First Taste of UML, Modeling Your Deployed System: Deployment Diagrams
PIMs (Platform Independent Models), Why UML 2.0?
pins, Showing Action Inputs and Outputs
Platform Independent Models (PIMs), Why UML 2.0?
Platform Specific Models (PSMs), Why UML 2.0?
plus symbol (+)
public visibility, Public Visibility, Element Visibility
ports
for classes, Internal Structure, Showing How a Class Is Used
postconditions, Abstract Classes
preconditions, Abstract Classes
private import, Importing and Accessing Packages
private visibility, Private Visibility, Element Visibility
process view, A First Taste of UML, Modeling System Workflows: Activity Diagrams
processes, forks representing, Time Events
profiles, Deployment Specifications, What Is a Profile?
as meta-models, Working with the Meta-Model
constraints in, Creating a Profile
creating, Creating a Profile
reasons to use, Why Bother with Profiles?
standard, Creating a Profile, Why Bother with Profiles?
stereotypes in, Stereotypes
using, Using a Profile
programming language, UML used as, UML and the Software Development Process
protected visibility, Protected Visibility
protocol state machines, What’s Next?, Protocol State Machines
provided interfaces
of classes, Showing How a Class Is Used
of components, Provided and Required Interfaces of a Component
pseudostates, Essentials
PSMs (Platform Specific Models), Why UML 2.0?
public import, Importing and Accessing Packages
public visibility, Public Visibility, Element Visibility
publications
Agile Software Development (Prentice Hall), Managing Package Dependencies
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley), Multiple inheritance, Interfaces, Showing Patterns with Collaborations
Head First Design Patterns (O’Reilly), What’s Next, Showing Patterns with Collaborations
Java 5 Tiger: A Developer’s Notebook (O’Reilly), What’s Next?
Java in a Nutshell, Asynchronous Messages

R

realization relationship, Interfaces
receive signals, Sending and Receiving Signals, Sending and Receiving Signals
recurring time events, Activity diagram, Calling Other Activities
ref fragment, Using a Sequence Fragment: The ref Fragment
region fragment, A Brief Overview of UML 2.0’s Fragment Types
region of states, Composite States
<<extend>> relationships, The <<extend>> Relationship
relative time indicators, Exact Time Measurements and Relative Time Indicators
required interfaces
of classes, Showing How a Class Is Used
of components, Provided and Required Interfaces of a Component
return messages, The Return Message
reuse
components for, What Is a Component?
generalization for, Generalization (Otherwise Known as Inheritance)

S

self-transition, Transitions
send signals, Sending and Receiving Signals
Sequence diagram, Why UML 2.0?, Participants in a Sequence Diagram
activation bars in, Activation Bars
compared to Communication diagram, Participants, Links, and Messages, Fleshing out an Interaction with a Communication Diagram
creating from use case, Bringing a Use Case to Life with a Sequence Diagram
creating Timing diagram from, Timing Constraints in System Requirements
events in, Events, Signals, and Messages
fragments in, Managing Complex Interactions with Sequence Fragments
in logical view, A First Taste of UML
incorporating into Interaction Overview diagram, Modeling a Use Case Using an Interaction Overview
messages (signals) in, Events, Signals, and Messages
participants in, Participants in a Sequence Diagram
time in, Time
when to create, What’s Next, What’s Next, What’s Next?
when to use, What’s Next?
sequence fragments, Managing Complex Interactions with Sequence Fragments
should requirements, Capturing a System Requirement
signals
between participants, Sending and Receiving Signals
between transitions, Signals
starting an activity, Starting an Activity
Singleton design pattern, Static Parts of Your Classes
sketch, UML used as, UML and the Software Development Process
software code
as artifact in Deployment diagram, Deployed Software: Artifacts
nodes hosting, What Is a Node?
package dependencies and, Managing Package Dependencies
packages used in, Package Dependency
reuse of
components for, What Is a Component?
generalization for, Generalization (Otherwise Known as Inheritance)
states in, States in Software
UML model as detailed as, UML and the Software Development Process
software development process
methods of, Views of Your Model
UML as part of, UML and the Software Development Process
source state, Transitions
standard profiles, Creating a Profile, Why Bother with Profiles?
standard stereotypes, Stereotypes
State Machine diagram, Models and Diagrams, What’s Next?
final state of, States
in logical view, A First Taste of UML
initial pseudostate of, States
pseudostates in, States, Advanced Pseudostates
states in, States
transition-oriented view of, Signals
transitions in, Transitions
when not to use, States in Software
when to use, What’s Next?, States in Software
states, Modeling an Object’s State: State Machine Diagrams, Essentials
active and inactive, Essentials
composite states, Composite States
in software, States in Software
internal behavior of, Advanced State Behavior
notation for, Essentials
regions of, Composite States
source state, Transitions
substates, Composite States
target state, Transitions
static classes or class elements, Static Parts of Your Classes
<<access>> stereotype, Importing and Accessing Packages
<<apply>> stereotype, Using a Profile
<<artifact>> stereotype, Showing Components Working Together, Deployed Software: Artifacts
<<component>> stereotype, A Basic Component in UML
<<deployment spec>> stereotype, Deployment Specifications
<<device>> stereotype, Deploying a Simple System, What Is a Node?
<<executable>> stereotype, Stereotypes applied to artifacts (see Chapter 15)
<<executionEnvironment>> stereotype, Showing Node Instances
<<file>> stereotype, Stereotypes applied to artifacts (see Chapter 15)
<<import>> stereotype, Importing and Accessing Packages
<<library>> stereotype, Stereotypes applied to artifacts (see Chapter 15)
<<realizations>> stereotype, Classes That Realize a Component
<<service>> stereotype, Stereotypes applied to artifacts (see Chapter 15)
<<source>> stereotype, Stereotypes applied to artifacts (see Chapter 15)
<<subsystem>> stereotype, Stereotypes applied to artifacts (see Chapter 15), A Basic Component in UML
<<utility>> stereotype, Stereotype applied to classes (see Chapters 4 and 5)
stereotypes, A First Taste of UML
creating new stereotypes, Deployment Specifications
for interfaces, Interfaces, Stereotype Notation for Interfaces
icons associated with, Stereotypes
in profiles, Stereotypes
notation for, Notes, Stereotype applied to classes (see Chapters 4 and 5), Stereotypes
profiles for, Deployment Specifications
standard, list of, Stereotype applied to classes (see Chapters 4 and 5)
tagged values for, Stereotypes applied to artifacts (see Chapter 15)
substates, Composite States
subsystems, Provided and Required Interfaces of a Component
system clock, as tricky actor, Tricky actors
system requirements
defining, Capturing a System Requirement
should requirements, Capturing a System Requirement

T

tagged values, Tagged values
target package, Importing and Accessing Packages
target state, Transitions
templates, Modeling a System’s Logical Structure: Advanced Class Diagrams, Templates
binding, Binding Class Templates
for lists, Templates, Binding Class Templates
threads
forks representing, Time Events
tightly coupled classes, Class Relationships, Multiple inheritance
time events, Activity diagram, Time Events
time, in Sequence diagram, Time
Timing diagram, Why UML 2.0?, What Do Timing Diagrams Look Like?
alternate notation for, An Alternate Notation
complexity of, An Alternate Notation
events in, Events and Messages
alternate notation for, An Alternate Notation
in logical view, A First Taste of UML
incorporated into Interaction Overview diagram, Modeling a Use Case Using an Interaction Overview
messages in, Events and Messages
participants in, Applying Participants to a Timing Diagram
organizing, Organizing Participants on a Timing Diagram
state-lines for, A Participant’s State-Line
states of, States
states in, States
alternate notation for, An Alternate Notation
timing constraints in, Timing Constraints
when to use, What’s Next?
transition-oriented view of State Machine diagram, Signals
transitions, Essentials, Transitions
internal transitions, Internal Transitions
notation for, Essentials
self-transition, Transitions
signals between, Signals
tricky actors, Tricky actors
triggers, Essentials, Transitions
tutorials for UML, Want More Information?

U

UML (Unified Modeling Language)
advantages of, What’s in a Modeling Language?, Why UML 2.0?
degrees of use of, UML and the Software Development Process
documentation and tutorials for, Want More Information?
executable, Why UML 2.0?
software development process and, UML and the Software Development Process
version 2.0, Why UML 2.0?
Use Case diagram, Why UML 2.0?
in use case view, A First Taste of UML
use case relationships in, Use Case Relationships
use cases in, Use Cases
Use Case Overview diagram, Use Case Overview Diagrams
use case view, Views of Your Model
use cases, Modeling Requirements: Use Cases
behaviors shared between
inheritance, Special Cases
creating Interaction Overview diagram from, Modeling a Use Case Using an Interaction Overview
creating Sequence diagram from, Bringing a Use Case to Life with a Sequence Diagram
description for, Use Case Descriptions
notation for, Use Cases
number of, guidelines for, Use Case Relationships
packages of, Managing Package Dependencies

V

visibility
of class elements, Visibility
of elements in package, Element Visibility
of operations, Class Behavior: Operations
of package import relation, Importing and Accessing Packages

W

waterfall method of software development, Views of Your Model
web site resources
Krutchen’s 4+1 view model, A First Taste of UML
Object Management Group, Want More Information?
white-box component views, Black-Box and White-Box Component Views
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.144.36.141