{
  "id": "page:library-rup",
  "_kind": "Page",
  "_file": "wiki/library/rup.md",
  "_cluster": "wiki",
  "attributes": {
    "nodeKind": "Page",
    "title": "RUP (Rational Unified Process) (Library)",
    "displayName": "RUP (Rational Unified Process) (Library)",
    "slug": "library/rup",
    "articlePath": "wiki/library/rup.md",
    "article": "\n# RUP (Rational Unified Process)\n\n**Iterative software development framework with four phases and use-case driven, architecture-centric approach**\n\n## Overview\n\nThe Rational Unified Process (RUP) is a comprehensive iterative software development framework created by Rational Software (Grady Booch, Ivar Jacobson, James Rumbaugh) in the 1990s. RUP combines phases with workflows, emphasizing use-case driven development, architecture-centric design, and risk-driven iteration planning.\n\n## Key Principles\n\n1. **Iterative Development**: Software is built incrementally through iterations, not all at once\n2. **Risk-Driven**: Risks drive the sequence of activities and iteration priorities\n3. **Architecture-Centric**: Establish solid architecture early in Elaboration phase\n4. **Use-Case Driven**: Use cases capture functional requirements and drive development\n5. **Four Phases with Iterations**: Each phase contains multiple iterations\n6. **Six Core Workflows**: Business Modeling, Requirements, Analysis & Design, Implementation, Testing, Deployment\n\n## Four Phases\n\n### 1. Inception Phase\n**Milestone: Lifecycle Objective (LCO)**\n\n**Purpose**: Define project scope, identify risks, create business case, and determine project viability.\n\n**Activities**:\n- Create Vision Document\n- Develop Business Case with ROI analysis\n- Build Initial Use Case Model (brief descriptions)\n- Assess Project Risks\n- Create Initial Project Plan\n\n**Outputs**:\n- Vision document defining scope and stakeholders\n- Business case with financial justification\n- Initial use case model with actors and high-level use cases\n- Risk list with prioritized risks\n- Initial project plan with phases and iterations\n\n**Decision**: Is the project worth pursuing? Approve to continue to Elaboration.\n\n### 2. Elaboration Phase\n**Milestone: Lifecycle Architecture (LCA)**\n\n**Purpose**: Detailed requirements, establish architecture baseline, mitigate risks, and plan Construction phase.\n\n**Activities**:\n- Refine Use Case Model to Detailed Level (full specifications with flows)\n- Define Architecture Baseline (components, patterns, technology stack)\n- Build Executable Architecture Prototype\n- Mitigate High-Priority Risks\n- Refine Project Plan for Construction\n\n**Outputs**:\n- Detailed use case specifications with scenarios\n- Architecture baseline document with all views\n- Executable architecture prototype validating key scenarios\n- Risk mitigation report\n- Refined project plan with detailed iteration assignments\n\n**Decision**: Is the architecture stable enough for Construction? Approve to proceed.\n\n### 3. Construction Phase\n**Milestone: Initial Operational Capability (IOC)**\n\n**Purpose**: Iteratively build the software in incremental builds, achieving beta release quality.\n\n**Activities (per iteration)**:\n- Plan Iteration (select use cases, define goals)\n- Implement Iteration (analysis, design, implementation, unit testing)\n- Integrate and Test (integration testing, system testing)\n- Generate User Documentation\n- Review Iteration (lessons learned, velocity tracking)\n\n**Outputs**:\n- Multiple incremental builds (beta releases)\n- Implemented modules and features\n- Integration and system test results\n- User documentation\n- Iteration reviews with lessons learned\n\n**Decision**: Is the system operational enough for beta release? Approve to proceed to Transition.\n\n### 4. Transition Phase\n**Milestone: Product Release (PR)**\n\n**Purpose**: Beta testing, production deployment, user training, system tuning, and warranty support.\n\n**Activities**:\n- Conduct Beta Testing with real users\n- Finalize Product (address beta feedback)\n- Deploy to Production\n- Conduct User Training\n- Tune System (performance optimization)\n- Setup Warranty Support\n\n**Outputs**:\n- Beta test report with user feedback\n- Production deployment report\n- Trained users and support staff\n- System tuning report with performance metrics\n- Warranty support plan\n\n**Decision**: Is the product ready for full release? Approve for production release.\n\n## Six Core Workflows\n\nThese workflows run across all phases, with varying emphasis:\n\n1. **Business Modeling**: Understand business context (heavy in Inception)\n2. **Requirements**: Capture use cases (heavy in Inception and Elaboration)\n3. **Analysis & Design**: Architecture and detailed design (heavy in Elaboration and Construction)\n4. **Implementation**: Code the system (heavy in Construction)\n5. **Test**: Verify implementation (heavy in Construction and Transition)\n6. **Deployment**: Deliver to users (heavy in Transition)\n\n## RUP Iteration Planning\n\nRUP is **risk-driven**: iterations address the highest risks first.\n\n- **Inception**: 1-2 iterations (quick feasibility check)\n- **Elaboration**: 2-3 iterations (establish architecture, mitigate risks)\n- **Construction**: 3-5+ iterations (bulk of implementation)\n- **Transition**: 1-2 iterations (deployment and stabilization)\n\nEach iteration is a mini-project with its own plan, implementation, and review.\n\n## Use-Case Driven Development\n\n**Use cases are the foundation of RUP**:\n\n1. **Capture requirements as use cases**: Actors interact with system to achieve goals\n2. **Drive architecture**: Architecturally significant use cases shape the architecture\n3. **Drive iteration planning**: Use cases assigned to iterations based on priority and risk\n4. **Drive testing**: Test cases derive from use case scenarios\n5. **Drive documentation**: User documentation organized around use cases\n\n**Use Case Levels**:\n- **Inception**: Brief descriptions (name, actors, brief description)\n- **Elaboration**: Detailed specifications (main flow, alternate flows, exceptions)\n- **Construction**: Use case realizations (design and implementation details)\n\n## Architecture-Centric Approach\n\nRUP emphasizes establishing a **solid architecture baseline** early:\n\n1. **Elaboration Phase**: Define architecture baseline\n2. **Executable Prototype**: Build working architecture prototype to validate design\n3. **Four+1 Views**:\n   - **Logical View**: Key abstractions (classes, packages)\n   - **Process View**: Concurrency and synchronization\n   - **Deployment View**: System topology and distribution\n   - **Implementation View**: Code organization (layers, components)\n   - **(+1) Use Case View**: Scenarios that tie views together\n\n4. **Patterns and Frameworks**: Document design patterns and frameworks used\n\n## Risk-Driven Iteration\n\n**RUP is risk-driven**, not requirements-driven or schedule-driven:\n\n1. **Assess Risks**: Identify technical, schedule, business, and organizational risks\n2. **Prioritize by Exposure**: Risk Exposure = Probability × Impact\n3. **Address High Risks First**: Elaboration focuses on mitigating highest risks\n4. **Iterate Until Risks Manageable**: Continue iterations until risks are under control\n5. **Plan Iterations Around Risks**: Assign high-risk use cases to early iterations\n\n## Integration with Other Methodologies\n\nRUP can be composed with other methodologies:\n\n- **Use Cases from Impact Mapping or JTBD**: Use impact mapping to discover use cases\n- **DDD for Architecture**: Apply Domain-Driven Design during Elaboration phase\n- **TDD/ATDD within Iterations**: Use test-driven development within Construction iterations\n- **BDD for Use Case Scenarios**: Use Gherkin scenarios for use case specifications\n- **Agile Practices**: RUP iterations can use Scrum-like ceremonies (standups, retrospectives)\n\n## When to Use RUP\n\n**Best for**:\n- Large, complex projects (6+ months)\n- Projects where requirements are somewhat stable but not fully known upfront\n- Projects with high technical risk requiring architecture validation\n- Organizations wanting iterative development with more structure than Agile\n- Regulated industries needing documentation (FDA, aerospace, defense)\n- Projects where architecture must be solid before heavy implementation\n\n**Not ideal for**:\n- Very small projects (< 3 months)\n- Projects with rapidly changing requirements (consider Scrum instead)\n- Projects needing immediate delivery (RUP has longer setup with Inception/Elaboration)\n- Teams without experience in iterative, architecture-centric development\n\n## Comparison with Other Methodologies\n\n| Aspect | RUP | Waterfall | Scrum | XP |\n|--------|-----|-----------|-------|-----|\n| **Approach** | Iterative, phase-based | Sequential | Iterative, time-boxed | Iterative, practice-based |\n| **Requirements** | Use-case driven | Fixed upfront | Evolving backlog | Stories, continuous |\n| **Architecture** | Architecture-centric | Designed upfront | Emergent | Emergent |\n| **Risk Management** | Risk-driven | Phase gates | Sprint-based | Continuous refactoring |\n| **Documentation** | Comprehensive | Heavy | Lightweight | Minimal |\n| **Phases** | 4 phases with iterations | 6 sequential phases | Continuous sprints | Continuous iterations |\n| **Best for** | Large, complex projects | Stable requirements | Flexible requirements | Rapid change, XP practices |\n\n## Usage\n\n```javascript\nimport { process } from './methodologies/rup/rup.js';\n\nconst inputs = {\n  projectName: 'Enterprise CRM System',\n  projectVision: 'Modern CRM system to manage customer relationships, sales pipeline, and support tickets with advanced analytics and mobile access',\n  iterationsPerPhase: {\n    inception: 1,      // Quick feasibility\n    elaboration: 2,    // Architecture and risk mitigation\n    construction: 4,   // Bulk implementation\n    transition: 1      // Deployment and training\n  },\n  teamSize: 12,\n  useCaseSource: 'stakeholder-workshops',\n  architectureStyle: 'layered'\n};\n\nconst result = await process(inputs, ctx);\n```\n\n## Inputs\n\n| Parameter | Type | Required | Default | Description |\n|-----------|------|----------|---------|-------------|\n| `projectName` | string | Yes | - | Name of the project/system |\n| `projectVision` | string | Yes | - | High-level vision and goals |\n| `iterationsPerPhase` | object | No | `{inception:1, elaboration:2, construction:4, transition:1}` | Number of iterations per phase |\n| `teamSize` | number | No | 10 | Development team size |\n| `useCaseSource` | string | No | 'stakeholder-workshops' | Source for use cases |\n| `architectureStyle` | string | No | 'layered' | Preferred architecture style |\n| `predefinedUseCases` | array | No | null | Pre-defined use cases (optional) |\n| `predefinedRisks` | array | No | null | Pre-defined risks (optional) |\n\n## Outputs\n\n```javascript\n{\n  success: true,\n  projectName: 'Enterprise CRM System',\n  projectVision: '...',\n  phases: {\n    inception: {\n      visionDocument: { ... },\n      businessCase: { roi: 2.5, paybackPeriod: '18 months' },\n      useCaseModel: { totalUseCases: 42 },\n      riskAssessment: { highRisks: 5, mediumRisks: 12 },\n      projectPlan: { totalIterations: 8 }\n    },\n    elaboration: {\n      detailedUseCases: { totalDetailedUseCases: 42, totalScenarios: 128 },\n      architecture: { components: [...], architectureStyle: 'layered' },\n      prototype: { validatedScenarios: 15 },\n      riskMitigation: { mitigatedRisks: 5 },\n      refinedPlan: { ... }\n    },\n    construction: {\n      iterations: [...],\n      implementation: { modules: 48, linesOfCode: 125000 },\n      integration: { testsPassed: 980, totalTests: 1000 },\n      documentation: { userGuides: 12 }\n    },\n    transition: {\n      betaTesting: { betaUsers: 25, defectsFixed: 18 },\n      deployment: { status: 'deployed', productionUrl: '...' },\n      training: { usersTrained: 150 },\n      tuning: { performanceImprovements: {...} },\n      warranty: { warrantyPeriod: '12 months' }\n    }\n  },\n  useCaseModel: { ... },\n  architecture: { ... },\n  projectMetrics: {\n    totalIterations: 8,\n    totalUseCases: 42,\n    totalModules: 48,\n    totalLinesOfCode: 125000,\n    testPassRate: '98.0%',\n    betaUsers: 25,\n    usersTrained: 150\n  },\n  artifacts: {\n    inception: 'artifacts/rup/phase-1-inception/',\n    elaboration: 'artifacts/rup/phase-2-elaboration/',\n    construction: 'artifacts/rup/phase-3-construction/',\n    transition: 'artifacts/rup/phase-4-transition/'\n  }\n}\n```\n\n## Artifacts Generated\n\n### Phase 1: Inception\n- `vision-document.md`: Project vision, scope, stakeholders, success criteria\n- `business-case.md`: Economic justification, ROI, NPV, payback period\n- `use-case-model.md`: Initial use case model with actors and brief descriptions\n- `use-case-diagram.md`: Visual representation of actors and use cases\n- `risk-list.md`: Identified risks with assessments and mitigation strategies\n- `project-plan.md`: Initial project plan with phases, iterations, and milestones\n\n### Phase 2: Elaboration\n- `detailed-use-cases.md`: Full use case specifications with flows and scenarios\n- `use-case-realizations.md`: Design-level view of use case implementations\n- `architecture-baseline.md`: Architecture baseline document\n- `architecture-views.md`: Four+1 architectural views\n- `architecture-prototype.md`: Executable prototype description\n- `prototype-validation.md`: Validation results for key scenarios\n- `risk-mitigation.md`: Risk mitigation actions and results\n- `refined-project-plan.md`: Updated project plan for Construction\n\n### Phase 3: Construction\nFor each iteration:\n- `iteration-{N}/plan.md`: Iteration plan with goals and tasks\n- `iteration-{N}/implementation-report.md`: Implementation progress and results\n- `iteration-{N}/integration-test-report.md`: Integration test results\n- `iteration-{N}/user-documentation.md`: User guides and tutorials\n- `iteration-{N}/review.md`: Iteration review and lessons learned\n\n### Phase 4: Transition\n- `beta-test-report.md`: Beta testing results and user feedback\n- `beta-feedback.json`: Structured beta user feedback data\n- `finalization-report.md`: Final product changes before production\n- `deployment-report.md`: Production deployment details\n- `training-report.md`: User training results\n- `training-materials.md`: Training curriculum and materials\n- `system-tuning.md`: Performance tuning activities and results\n- `warranty-plan.md`: Warranty support plan\n- `support-procedures.md`: Ongoing support procedures\n\n### Project-Level\n- `project-summary.md`: Overall project summary and outcomes\n- `project-metrics.json`: Comprehensive project metrics\n- `lessons-learned.md`: Lessons learned across all phases\n- `final-documentation-index.md`: Index of all project documentation\n\n## Best Practices\n\n1. **Start with Clear Vision**: Ensure vision document has stakeholder buy-in\n2. **Risk-Driven Planning**: Address highest risks in Elaboration, not Construction\n3. **Architecture First**: Don't skip Elaboration - establish architecture before heavy coding\n4. **Validate with Prototype**: Build executable prototype in Elaboration to validate architecture\n5. **Detailed Use Cases**: Invest time in Elaboration to detail use cases thoroughly\n6. **Incremental Builds**: Construction iterations should produce working increments\n7. **Early Beta Testing**: Get beta users involved early in Transition\n8. **Continuous Risk Management**: Update risk list throughout all phases\n9. **Stakeholder Involvement**: Involve stakeholders at phase milestones for approval\n10. **Documentation Balance**: Document architecture and use cases well, but avoid over-documentation\n\n## Common Pitfalls\n\n1. **Skipping Elaboration**: Going straight from Inception to Construction without establishing architecture (leads to rework)\n2. **Waterfall-like RUP**: Treating phases as sequential waterfall phases instead of iterative\n3. **Over-documentation**: Creating too much documentation that doesn't add value\n4. **Ignoring Risks**: Not addressing high-priority risks in Elaboration phase\n5. **Weak Architecture**: Not investing enough in architecture baseline\n6. **Scope Creep**: Allowing scope changes without going through iteration planning\n7. **Skipping Phase Milestones**: Not getting stakeholder approval at phase boundaries\n8. **Throwaway Prototype**: Building prototype in Elaboration and discarding it (should be evolutionary)\n\n## References\n\n- [RUP on Wikipedia](https://en.wikipedia.org/wiki/Rational_unified_process)\n- [GeeksforGeeks: RUP Phases](https://www.geeksforgeeks.org/software-engineering/rup-and-its-phases/)\n- [ToolsHero: RUP Method](https://www.toolshero.com/information-technology/rational-unified-process-rup/)\n- Rational Unified Process: An Introduction (3rd Edition) by Philippe Kruchten\n- The Rational Unified Process Made Easy by Per Kroll and Philippe Kruchten\n\n## License\n\nPart of the Babysitter SDK orchestration framework.\n",
    "documents": [
      "specialization:rup"
    ]
  },
  "outgoingEdges": [
    {
      "from": "page:library-rup",
      "to": "specialization:rup",
      "kind": "documents"
    }
  ],
  "incomingEdges": [
    {
      "from": "page:index",
      "to": "page:library-rup",
      "kind": "contains_page"
    }
  ]
}