SDLC Overview: The Complete Software Development Journey

# SDLC Phase Management System
# Practical example demonstrating SDLC phase tracking and validation
from datetime import datetime, timedelta
from enum import Enum
from typing import List, Dict, Optional
class SDLCPhase(Enum):
    """Enumeration of SDLC phases"""
    PLANNING = "Planning"
    ANALYSIS = "Requirements Analysis"
    DESIGN = "System Design"
    IMPLEMENTATION = "Development"
    TESTING = "Testing"
    DEPLOYMENT = "Deployment"
    MAINTENANCE = "Maintenance"
class ProjectStatus(Enum):
    """Project status indicators"""
    NOT_STARTED = "Not Started"
    IN_PROGRESS = "In Progress"
    COMPLETED = "Completed"
    BLOCKED = "Blocked"
class SDLCPhaseTracker:
    """
    Track and manage SDLC phases for a software project.
    Demonstrates phase dependencies, validation, and reporting.
    """
    
    def __init__(self, project_name: str, total_duration_weeks: int):
        """
        Initialize SDLC phase tracker.
        
        Args:
            project_name: Name of the software project
            total_duration_weeks: Total project duration in weeks
        """
        self.project_name = project_name
        self.total_duration_weeks = total_duration_weeks
        self.start_date = datetime.now()
        
        # Define phase allocation (percentage of total time)
        self.phase_allocation = {
            SDLCPhase.PLANNING: 0.08,        # 8%
            SDLCPhase.ANALYSIS: 0.17,        # 17%
            SDLCPhase.DESIGN: 0.17,          # 17%
            SDLCPhase.IMPLEMENTATION: 0.42,  # 42%
            SDLCPhase.TESTING: 0.12,         # 12%
            SDLCPhase.DEPLOYMENT: 0.04,      # 4%
        }
        
        # Track phase status
        self.phase_status: Dict[SDLCPhase, ProjectStatus] = {
            phase: ProjectStatus.NOT_STARTED 
            for phase in SDLCPhase
        }
        
        # Track phase completion percentage
        self.phase_completion: Dict[SDLCPhase, int] = {
            phase: 0 for phase in SDLCPhase
        }
        
        # Track deliverables
        self.phase_deliverables: Dict[SDLCPhase, List[str]] = {
            SDLCPhase.PLANNING: [
                "Project Charter",
                "Feasibility Study",
                "Budget & Timeline",
                "Risk Register"
            ],
            SDLCPhase.ANALYSIS: [
                "Software Requirements Specification (SRS)",
                "Use Case Diagrams",
                "User Stories",
                "Acceptance Criteria"
            ],
            SDLCPhase.DESIGN: [
                "System Architecture Document",
                "Database Schema",
                "API Specifications",
                "UI/UX Mockups"
            ],
            SDLCPhase.IMPLEMENTATION: [
                "Source Code",
                "Unit Tests",
                "API Documentation",
                "Build Scripts"
            ],
            SDLCPhase.TESTING: [
                "Test Plans",
                "Test Cases",
                "Test Reports",
                "UAT Sign-off"
            ],
            SDLCPhase.DEPLOYMENT: [
                "Deployment Plan",
                "Rollback Procedures",
                "User Training Materials",
                "Go-Live Report"
            ],
            SDLCPhase.MAINTENANCE: [
                "Incident Reports",
                "Change Requests",
                "Performance Reports",
                "Updated Documentation"
            ]
        }
        
        # Track issues found in each phase
        self.phase_issues: Dict[SDLCPhase, List[str]] = {
            phase: [] for phase in SDLCPhase
        }
    
    def start_phase(self, phase: SDLCPhase) -> bool:
        """
        Start a specific SDLC phase with validation.
        
        Args:
            phase: The SDLC phase to start
            
        Returns:
            True if phase started successfully, False otherwise
        """
        # Validate previous phase completion (except for first phase)
        if phase != SDLCPhase.PLANNING:
            previous_phase = self._get_previous_phase(phase)
            if previous_phase and self.phase_status[previous_phase] != ProjectStatus.COMPLETED:
                print(f"❌ Cannot start {phase.value}: {previous_phase.value} must be completed first")
                return False
        
        self.phase_status[phase] = ProjectStatus.IN_PROGRESS
        print(f"✅ Started {phase.value} phase")
        return True
    
    def _get_previous_phase(self, current_phase: SDLCPhase) -> Optional[SDLCPhase]:
        """Get the phase that should precede the current phase"""
        phase_order = [
            SDLCPhase.PLANNING,
            SDLCPhase.ANALYSIS,
            SDLCPhase.DESIGN,
            SDLCPhase.IMPLEMENTATION,
            SDLCPhase.TESTING,
            SDLCPhase.DEPLOYMENT,
            SDLCPhase.MAINTENANCE
        ]
        
        try:
            current_index = phase_order.index(current_phase)
            if current_index > 0:
                return phase_order[current_index - 1]
        except ValueError:
            pass
        
        return None
    
    def complete_phase(self, phase: SDLCPhase, completion_notes: str = ""):
        """
        Mark a phase as completed.
        
        Args:
            phase: The SDLC phase to complete
            completion_notes: Optional notes about phase completion
        """
        if self.phase_status[phase] != ProjectStatus.IN_PROGRESS:
            print(f"⚠️ Phase {phase.value} must be in progress before completing")
            return
        
        self.phase_status[phase] = ProjectStatus.COMPLETED
        self.phase_completion[phase] = 100
        
        print(f"✅ Completed {phase.value} phase")
        if completion_notes:
            print(f"   Notes: {completion_notes}")
    
    def log_issue(self, phase: SDLCPhase, issue_description: str):
        """
        Log an issue discovered during a phase.
        
        Args:
            phase: The SDLC phase where issue was found
            issue_description: Description of the issue
        """
        self.phase_issues[phase].append(issue_description)
        print(f"⚠️ Issue logged in {phase.value}: {issue_description}")
    
    def get_project_progress(self) -> float:
        """
        Calculate overall project progress percentage.
        
        Returns:
            Progress percentage (0-100)
        """
        total_progress = 0.0
        
        for phase, allocation in self.phase_allocation.items():
            phase_progress = self.phase_completion.get(phase, 0)
            total_progress += (phase_progress * allocation)
        
        return round(total_progress, 2)
    
    def generate_status_report(self):
        """Generate comprehensive project status report"""
        print(f"
{'='*70}")
        print(f"SDLC STATUS REPORT: {self.project_name}")
        print(f"{'='*70}
")
        
        print(f"Overall Progress: {self.get_project_progress()}%")
        print(f"Project Duration: {self.total_duration_weeks} weeks")
        print(f"Start Date: {self.start_date.strftime('%Y-%m-%d')}")
        print()
        
        print("Phase Status:")
        print("-" * 70)
        
        for phase in SDLCPhase:
            status = self.phase_status[phase]
            completion = self.phase_completion.get(phase, 0)
            
            # Status icon
            if status == ProjectStatus.COMPLETED:
                icon = "✅"
            elif status == ProjectStatus.IN_PROGRESS:
                icon = "🔄"
            elif status == ProjectStatus.BLOCKED:
                icon = "🚫"
            else:
                icon = "⏸️"
            
            print(f"{icon} {phase.value:20} | Status: {status.value:15} | {completion}% complete")
            
            # Show issues if any
            if self.phase_issues[phase]:
                print(f"   Issues ({len(self.phase_issues[phase])}):")
                for issue in self.phase_issues[phase][:3]:  # Show first 3 issues
                    print(f"     - {issue}")
        
        print("
" + "="*70 + "
")
    
    def get_expected_duration(self, phase: SDLCPhase) -> int:
        """
        Calculate expected duration for a phase in days.
        
        Args:
            phase: The SDLC phase
            
        Returns:
            Expected duration in days
        """
        if phase in self.phase_allocation:
            weeks = self.total_duration_weeks * self.phase_allocation[phase]
            return int(weeks * 7)  # Convert weeks to days
        return 0
# Example Usage: E-commerce Platform Development
print("="*70)
print("SDLC PHASE TRACKER - PRACTICAL EXAMPLE")
print("="*70)
print()
# Initialize project tracker
project = SDLCPhaseTracker(
    project_name="E-Commerce Platform",
    total_duration_weeks=24  # 6-month project
)
print(f"Project: {project.project_name}")
print(f"Duration: {project.total_duration_weeks} weeks (approximately 6 months)")
print()
# Phase 1: Planning
print("
--- PHASE 1: PLANNING ---")
project.start_phase(SDLCPhase.PLANNING)
print(f"Expected Duration: {project.get_expected_duration(SDLCPhase.PLANNING)} days")
print("
Deliverables:")
for deliverable in project.phase_deliverables[SDLCPhase.PLANNING]:
    print(f"  - {deliverable}")
# Simulate some progress
project.phase_completion[SDLCPhase.PLANNING] = 50
print("
Progress: 50% - Feasibility study completed")
# Complete planning phase
project.complete_phase(
    SDLCPhase.PLANNING,
    "Budget approved: $250K, Timeline confirmed: 24 weeks"
)
# Phase 2: Requirements Analysis
print("
--- PHASE 2: REQUIREMENTS ANALYSIS ---")
project.start_phase(SDLCPhase.ANALYSIS)
print(f"Expected Duration: {project.get_expected_duration(SDLCPhase.ANALYSIS)} days")
# Log an issue during analysis
project.log_issue(
    SDLCPhase.ANALYSIS,
    "Stakeholder disagreement on checkout flow - requires additional meeting"
)
# Complete analysis phase
project.phase_completion[SDLCPhase.ANALYSIS] = 100
project.complete_phase(
    SDLCPhase.ANALYSIS,
    "200 requirements documented, 50 user stories created"
)
# Phase 3: Design
print("
--- PHASE 3: DESIGN ---")
project.start_phase(SDLCPhase.DESIGN)
print(f"Expected Duration: {project.get_expected_duration(SDLCPhase.DESIGN)} days")
project.phase_completion[SDLCPhase.DESIGN] = 75
print("
Progress: 75% - Database schema and API design completed")
# Attempt to start implementation before completing design (will fail)
print("
--- ATTEMPTING TO SKIP AHEAD ---")
project.start_phase(SDLCPhase.IMPLEMENTATION)
# Complete design first
project.phase_completion[SDLCPhase.DESIGN] = 100
project.complete_phase(
    SDLCPhase.DESIGN,
    "Microservices architecture approved, PostgreSQL schema finalized"
)
# Now implementation can start
print("
--- PHASE 4: IMPLEMENTATION ---")
project.start_phase(SDLCPhase.IMPLEMENTATION)
project.phase_completion[SDLCPhase.IMPLEMENTATION] = 30
print("Progress: 30% - Sprint 3 of 10 completed")
# Generate comprehensive status report
project.generate_status_report()
# Calculate remaining time
remaining_phases = [
    SDLCPhase.IMPLEMENTATION,
    SDLCPhase.TESTING,
    SDLCPhase.DEPLOYMENT
]
remaining_days = sum(
    project.get_expected_duration(phase) 
    for phase in remaining_phases
)
print(f"
Project Insights:")
print(f"  Estimated remaining time: {remaining_days} days")
print(f"  Phases completed: 3/7")
print(f"  Total issues logged: {sum(len(issues) for issues in project.phase_issues.values())}")
print(f"  Next milestone: Complete Implementation (70% remaining)")
# Output demonstrates:
# ✅ Phase dependency validation
# ✅ Progress tracking
# ✅ Issue logging
# ✅ Duration estimation
# ✅ Comprehensive reporting