RUP is a software methodology and process framework that can be adapted and extended to suit the environment, organization and needs of the adopter. It is built on software development best practices, with embedded guidance on many techniques and approaches:

• Requirements analysis and use-case-driven development
• Modeling and the UML
• Architecture, components and re-use
• Iterative development
• Continuous integration
• Software quality assurance (SQA)
• Configuration and change management

The process itself combines two dimensions. The first dimension represents the static aspect, describing the process in terms of activities, workflows, artifacts, and workers, whereas the second dimension represents the dynamic aspect of the process as it is enacted, and it is expressed in terms of cycles, phases, iterations, and milestones.

Process description

The RUP employs three fundamental elements: workers, activities, and artifacts. Workflows associate workers with sequenced activities to produce artifacts.

Workers describe the ‘who’. A worker defines the behavior and responsibilities of a role. The behavior is expressed in terms of activities to be performed by the worker. The responsibilities are expressed in relation to artifacts to be produced, owned and controlled by the worker.

Activities describe the ‘how’. An activity defines the work to be performed by a worker, and is expressed in terms of creating or modifying artifacts, e.g. a model, a class, or a project plan. An activity should equate to a project-planning element so that its progress can be tracked.

Artifacts describe the ‘what’. An artifact is a tangible piece of information that is produced, modified, or used by a process. To perform an activity, workers use artifacts as inputs; they also form the output of such activities. Artifacts can be composed of other artifacts, e.g. a design model can contain many classes.

Workflows describe the ‘when’. A workflow provides a meaningful way to describe sequences of activities that produce artifacts and to show interactions between workers.

RUP is organized into nine core workflows:

1. Business modeling workflow
2. Requirements workflow
3. Analysis and design workflow
4. Implementation workflow
5. Test workflow
6. Deployment workflow
7. Project management workflow
8. Configuration and change management workflow
9. Environment workflow

Although workflows 1 through 6 constitute the sequential phases in a traditional waterfall process, in an iterative development cycle, these workflows are visited repeatedly in each iteration, throughout the lifecycle.

A shifting focus across the development lifecycle

The iterative process is organized in phases each concluded by a major milestone.

Inception: Achieve concurrence among all stakeholders on the lifecycle objectives for the project:

• Establish the scope and boundary conditions, including operational concept, acceptance criteria, and descriptions of functionality to be included in and excluded from the product.
• Classify the critical use cases that will drive the functionality and will influence the design trade-offs.
• Exhibit (and demonstrate) at least one candidate architecture.
• Estimate the cost and schedule for the project and provide detailed estimates for the elaboration phase.
• Identify and estimate the risks.

Elaboration: Analyze the problem domain, establish a sound architectural foundation, develop the project plan, and eliminate the highest-risk elements.

• Design, validate, and baseline the architecture.
• Baseline the vision.
• Baseline the high fidelity plan for the construction phase.
• Demonstrate that the baseline architecture will support the vision for a reasonable cost in a reasonable time frame.

Construction: Develop, integrate, and test the remaining components and application features.

• Minimize development costs by optimizing resources and avoiding unnecessary rework.
• Achieve the desired quality.
• Release versions that are useful to the recipient.

Transition: Promote the software to the user community.

• Achieve user self-supportability.
• Achieve stakeholder concurrence that deployment is complete and satisfies the evaluation criteria of the vision.
• Achieve final product baseline cost-effectively.

These four phases constitute a development cycle and produce a software generation. Software will evolve into the next generations through a repetition of the sequence of inception, elaboration, construction, and transition phases. Each phase comprises one or more iterations, and each iteration contains the core workflows, but from one iteration to the next, the emphasis on the various activities will change.