A

abstract classes

      guidelines for

abstract use case

      description of

acceptance test

      explanation of

acquiring

      staff

activity

      key concepts

actor

      artifact definition

      definition

      finding an

      guidelines for

      naming

actor-generalization

      establishing

      guidelines for

additional resources

      general information

      Rational training

aggregation

      association vs. aggregation

      guidelines for

Agile Practices and RUP

      concept

analysis class

      as artifact

      checkpoints for

      purpose of

analysis mechanisms

      categorizing

      describing

      examples of

      identifying

      qualifying

analysis model

      as artifact

      purpose of

any (role)

      description of

architectural control

      guidelines for import-dependency in implementation

architectural mechanism

      documenting

architectural proof-of-concept

      as artifact

      assessing viability of

      constructing

      purpose

architecture

      3-tier

      client/server

      distributed client/server

      distribution patterns

      fat-client

      fat-server

      introduction to

      peer-to-peer

      reviewing

artifact

      classification of

          could have

          must have

          should have

          won't have

      key concepts

association

      aggregation vs. association

      association classes

      guidelines for

      multiplicity

      N-ary associations

      naming

      navigability

      qualified associations

      recommendations for using

      self-associations

association classes

      guidelines for

attribute

      class, definition for

      definition for

      modeling external units with

attribute on object

      defining on classes

      describing

B

behavioral prototype

bibliography

      references for

boundary class

      associations, general guidelines

      designing

      packaging

browsing hierarchies

      user-interface guidelines

build

      as artifact

      explanation of

business case

      as artifact

      guidelines for

      purpose of

business risks

C

change control manager (role)

      description of

change management

      overview of

change request (CR)

      artifact definition

      brief outline of

      definition

      guidelines for

      purpose of

      states of

change request management

      confirm duplicate change request

      confirm rejected change request

      reviewing change requests

      submitting change requests

change request process

      viewing historical data

          tool mentor for

checkpoints

      for actors

      for analysis class

      for design classes

      for glossary

      for software requirements specification

      for stakeholder requests

      for supplementary specifications

      for use cases

      for use-case model

      for vision

class

      as artifact

      associations recommendations for use of

      creating design classes initially

      definition

      designing

      guidelines for

      operations on

      purpose of

      refining analysis classes

      representing graphical interfaces

      representing interfaces to external systems

class attribute

      definition

class diagram

      guidelines for

clearquest

      charts

CMM

      Reaching Levels 2 and 3 with the RUP

      RUP as an enabler

code

      mapping from design

      reverse engineering

communicates-association

      guidelines for

communication diagram

      guidelines for

compilation dependency

      guidelines for

      representing

component

      concepts

      reverse engineer

component diagram

      guidelines for

component-based development (CBD)

      as a feature in the Unified Process

concrete classes

      guidelines for

concurrency

      guidelines for

concurrency conflicts

      identifying

configuration and change management

      important decisions in

configuration management

      development area

      environment setup

      integration area

configuration manager (role)

      description of

construction iteration

      evaluating

      iteration patterns

control class

      associations recommendations for use of

      designing

CRC card

      use of technique

D

data model

      as artifact

      checkpoints

      purpose of

      reverse-engineering relational databases

database

      reverse engineering

database designer (role)

      description of

decision (in activity diagrams)

      business use-case model

deployment model

      as artifact

      purpose

design

      developer testing

          concept of

          test ideas

              for booleans and boundaries

              for method calls

      test-first design

design mechanism

      characteristics of

      describing

      mapping to implementation mechanisms

      mapping to implementation mechanisms examples

      mapping to implementation mechanisms refining

design model

      as artifact

      characteristics of a good

      checkpoints

      mapping from the Analysis Model

      mapping to the Implementation Model

      purpose of

      reverse-engineering relational databases

design package

      as artifact

      checkpoints

      describing how packages depend on each other

      functionally related classes? finding packages for

      guidelines for

      organizing using import-dependency

      package partitioning criteria

      purpose of

      subsystems vs. packages

design subsystem

      as artifact

      checkpoints

      defining high-level organization of

      defining low-level organization of

      describing subsystem dependencies

      designing

      distributing behavior on subsystem elements

      guidelines for

      identifying interfaces

      identifying subsystems

      packages vs. subsystems

      partitioning patterns

      purpose of

      unifying

designer (role)

      description of

developer

      executing tests

Developer Test

      artifact definition

      brief outline for

      purpose of

      tailoring of

developer testing

      automated tests

          maintanence of

      explanation of

      runtime analysis

developing

      a vision

development area

development environment

      concept of

development infrastructure

      as artifact

      purpose of

disabling the getting started process view

discipline

      key concepts

distribution patterns

      3-tier architecture

      client/server architectures

      distributed client/server architecture

      fat-client architecture

      fat-server architecture

      introduction to

      peer-to-peer architecture

dynamic highlighting

      user-interface guidelines for

E

e-business

      example project

elaboration iteration

      evaluating

      iteration patterns

element

      exporting from implementation subsystems

entity class

      associations recommendations for use of

      define persistent classes

      designing

environment

      development environment

essential use cases

      description

      in the Rational Unified Process

Estimating Effort

      Based on Use Cases

estimating effort

      concept of

evaluation criteria

      of iteration

event

      as artifact

      purpose of

events

      identification of

evolutionary lifecycle

evolutionary prototype

example

      e-business development project

existing product

      representing with packages

exploratory prototype

extend-relationship

      establish between use cases

      guidelines for

extended help

      using with the RUP web site

external units

      modeling with attributes

      representing interfaces to external units

F

flow of events

      alternative flow

      describing special requirements of

      detailing

      examples of

      guidelines for

      structuring

Formal-External (review level)

Formal-Internal (review level)

G

generalization

      guidelines for

      inheritance in programming languages

      inheritance to support implementation reuse

      inheritance to support polymorphism

getting started

      disabling the process view

Glossary document

      as artifact

      purpose of

grand design lifecycle

I

Implement Component

      implementation of tests for

implementation discipline

      purpose of

      relation to other disciplines

implementation element

      as artifact

      purpose of

implementation mechanism

      inventorying

      mapping from design mechanisms

      mapping from design mechanisms examples

      mapping from design mechanisms refining

implementation model

      as artifact

      checkpoints

      explanation of

      purpose of

implementation subsystem

      as artifact

      exporting elements

      guidelines for

      handling import dependencies between

      purpose of

implementation view

      introduction to

      updating

implementer (role)

      description of

import-dependency in design

      guidelines for

      organizing packages with

import-dependency in implementation

      guidelines for

inception iteration

      evaluating

inception phase

      iteration patterns

include-relationship

      establish between use cases

      guidelines for

incremental delivery lifecycle

incremental lifecycle

independent testing

      explanation of

Index Entry Category

       New Guideline

      this file subject

Informal (review level)

inheritance

      in programming languages

      multiple inheritance

      to support implementation reuse

      to support polymorphism

initial operational capacity milestone

integration

      benefits of

      introduction to

integration area

Integration Build Plan document

      as artifact

      evaluating

      purpose of

integration test

      explanation of

integration workspace integrators

integrator (role)

      description of

interaction

      describing interactions between design objects

interface

      as artifact

      defining operations

      describing

      documenting

      naming

      purpose of

interfaces

      identifying a subsystem's

iteration

      assessing

      assign responsibilities

      defining activities in

      defining evaluation criteria

      determining scope of

      strategies

Iteration Assessment document

      as artifact

      purpose of

iteration patterns

      construction iterations

      elaboration iterations

      inception iterations

      transition iterations

Iteration Plan document

      as artifact

      assign responsibilities

      defining evaluation criteria

      defining iteration activities

      determining scope of iteration

      developing

      guidelines for

      purpose of

Iterative

      Transition from Waterfall

K

key concepts

      identifying

      role

      tool mentor

L

layering

      guidelines

      guidelines for layering in implementation

      layering guidelines for design subsystems

      organizing design packages using import dependency

      partitioning patterns

lifecycle architecture milestone

lifecycle objective milestone

lifecycle patterns

      evolutionary lifecycle

      hybrid strategies

      incremental delivery lifecycle

      incremental lifecycle

links

      guidelines for

logical view

      guidelines for

      including classes in

M

macro agent

      user-interface guidelines

manage

      acquisition of staff

management discipline

      purpose of

      relation to other disciplines

Management Reviewer

      role definition

manifest dependency

      guidelines for

      representing

measures

      for perceived quality

      key measures of test

      types of test coverage

mechanisms

      using

mentor

mentoring

message

      in sequence diagram

method

      defining on class

metrics

      collecting

      introduction to

      motivation for

      templates for

milestone

      initial operational capacity

      lifecycle architecture

      product release

      product release milestone

      refining

modeling conventions

      defining

multiple inheritance

      guidelines for

multiplicity for associations

      guidelines for

MyRUP

      personalize the RUP web site

N

N-ary associations

      guidelines for

navigability on associations

      guidelines for

Navigation Map

      artifact definition

      purpose of

      tailoring of

network configuration

      defining

None (review level)

nonfunctional requirements

      handling of

O

object

      in sequence diagram

online help

      user-interface guidelines

operation

      defining on classes

      naming

P

patterns

      using

persistence

      relational databases and object orientation

persistent class

      identifying

persistent object

      describing

phase

      milestones

          initial operational capacity

          lifecycle architecture

          product release

Phase description of

phases

      overview

postcondition

      describing for a use case

      guidelines for

power find and select

      user-interface guidelines

precondition

      describing for a use case

      guidelines for

prioritizing

      test cases

      use cases

private class

      in package

process

      identifying communication mechanisms

      identifying process lifecycles

      map design elements to

      map process onto implementation environment

process discriminants

      business context

      degree of novelty

      managerial complexity

      technical complexity

process engineer (role)

      description of

programming languages

      designing inheritance

project lifecycle

      introduction to

project management

      defining milestone goals

      refine milestones

project manager (role)

      description of

protocol

      identification of

prototype

      behavioral prototype

      evolutionary prototype

      exploratory prototype

      introduction to

      structural prototype

prototyping of user interfaces

public class

      in package

Q

quality

      dimensions

R

references

      bibliography of

relational databases

      reverse engineering

requirements

      determining sources of

      eliciting stakeholder requests

      important decisions in

      introduction to

      reviewing

      workshop

requirements specifier (role)

      description of

requirements workshop

reuse

      identify reuse opportunities

Review Coordinator

      role definition

review record

      artifact definition

Reviewer

      role definition

reviewing

      architecture

reviews

      conducting of

      review record artifact

rework

      as part of iterations

risk

      business risks

      definitions

      identifying and assessing

      introduction to

      resource risks

      schedule risks

      strategies for risk management

      technical risks

      types of risks

risk list

      as artifact

      guidelines for

risk management

      strategies

      strategies for risk management

role

      key concepts

roles on associations

      guidelines for

      navigability property

      order property

runtime observation & analysis

      concept

RUP

      tool mentors

rup

      whats new

RUP tools

      searching RUP

S

scenarios

      refining

schedule risks

script

      in sequence diagrams

sequence diagram

      guidelines for

      messages in

      objects in

      script in

session information

      user-interface guidelines

signal

      as artifact

      checkpoints

      purpose of

small projects developing

      roadmap for

software architect (role)

      description of

Software Architecture Document

      checkpoints

Software Development Plan document

      as artifact

      purpose of

Software Requirement

      artifact definition

software requirement

      brief outline for

      purpose of

software requirements

      detailed specification of

          without use cases

      general organization of

software requirements specification

      artifact definition

      guidelines for

sorting

      user-interface guidelines

stages of test

      introduction to

Stakeholder Requests

      as artifact

      purpose of

stakeholder requests

      eliciting

stakeholder testing

      explanation of

state

      defining on classes

state machine

      guidelines for

      test ideas for

status assessment

      as artifact

      purpose of

storyboard

      as artifact

      guidelines for

structured class

      concepts

structuring

       of use-case models

subscribe-association

      guidelines for

supplementary specifications

      artifact definition

system administrator (role)

      description of

system analyst (role)

      description of

system test

      advocating quality

      explanation of

      identifying ideas for

      implementing a test suite

T

tailor the process

      activity description

tailoring the process

      guidelines for

Technical Reviewer

      role definition

technical risks

Test

      Implementing Developer Tests

test

      black-box test

          of units

      defining an approach

      determining results of

      developer testing

          concept of

          maintaining automated tests

          performing unit tests

          test ideas

              for booleans and boundaries

              for method calls

          test-first design

          unit test

              guidelines for

      key measures of

      levels of

      lifecycle of

      quality dimensions

      stages of

      white-box test

          of units

test analyst (role)

      description of

test case

      defining test data for

      guidelines for

      prioritizing based on risk

test designer (role)

      description of

test discipline

      important decisions

test evaluation summary

      artifact definition

      purpose of

test idea

      for state machine

test ideas catalog

      examples of

test lifecycle

      introduction to

test log

      artifact definition

      brief outline of

      purpose of

test manager (role)

      description of

test results

      artifact definition

      purpose of

test strategy

      brief outline for

      introduction to

test suite

      artifact definition

      brief outline of

      purpose of

test-ideas

      for booleans and boundaries

      for method calls

test-ideas catalog

      concept of

test-ideas list

      artifact definition

      brief outline of

      concept of

      purpose of

tester (role)

      description of

tool mentor

      key concepts

transition (in activity diagrams)

      in business use-case model

transition iteration

      evaluating

      iteration patterns

U

UML 2 . 0

      whats new

undo

      user-interface guidelines

unit test

      black-box test

      developer testing

      explanation of

      implementation of

      performing

      white-box test

usability engineering

      walkthrough concept for

usability testing

      introduction to

Use Case

      The Estimation of Effort Based on

use case

      abstract use case

      artifact definition

      describing postcondition of

      describing precondition of

      describing special requirements of

      design

      finding a

      flow of events

      guidelines for

      packaging

      prioritizing

      purpose of

      scope of a use case

      specification

      structuring the flow of events of

use case specifications

      examples CSPS Elaboration

use-case diagram

      guidelines for

use-case model

      artifact definition

      guidelines for

      presenting in diagram

      purpose of

      structuring of

use-case model survey report

      developing

use-case package

      as artifact

      guidelines for

      purpose of

use-case realization

      as artifact

      checkpoints

      guidelines for

      purpose of

use-case storyboard

      purpose of

use-case view

      introduction to

use-case-generalization

      establish between use cases

      guidelines for

user interface

      prototyping

user-centered design

      introduction to

user-controlled inheritance

      user-interface guidelines

user-interface

      representing in design model

user-interface designer (role)

      description of

user-interface guidelines

      browsing hierarchies

      dynamic highlighting

      find

      macro agent

      online help

      select

      session information

      sorting

      undo

      user-controlled inheritance

      window management

user-interface prototype

      as artifact

      purpose of

V

visibility

      of content in package

vision

      artifact definition

      developing a

      purpose of

visual dimensions

      color

      further aspects, identification

      introduction to

      position

      shape

      size

vocabulary

      finding common terms in software development

W

Waterfall

      Transition to Iterative

web architecture patterns

      introduction to

whats new

      in rup

window management

      user-interface guidelines

window-based user interfaces

      fundamentals

work order

      as artifact

workflow

      key concepts

X

XDE Developer-Java Platform

      Managing Databases

      Reverse Engineering Databases

XP

      A Comparison with RUP

      Pair Programming

      Test-first Design and Refactoring