SCM & Re-engineering: Version Control, Builds, Refactoring & Legacy Systems

Core Concepts of Software Configuration Management (SCM)

What is SCM?

Software Configuration Management (SCM) is the process of systematically managing changes to software systems. It ensures that software is consistent, traceable, and reproducible across development, testing, and production environments. SCM includes:

• Version control: Tracking changes to source code and related artifacts.
• Build management: Automating compilation, testing, and deployment.
• Change control: Managing modifications through approval workflows.
• Release management: Coordinating software releases and rollbacks.

stateDiagram-v2
    [*] --> Idle: No changes
    Idle --> Edit: Developer modifies code
    Edit --> Commit: Changes saved to repository
    Commit --> Branch: New branch created
    Branch --> Merge: Changes merged into main
    Merge --> Test: Automated tests run
    Test --> Release: Deployed to production
    Release --> [*]: Software in use
    Release --> Rollback: Revert to previous version

Why SCM Matters

SCM solves real-world problems like:

1. Collaboration: Multiple developers working on the same project without overwriting each other’s work.
2. Traceability: Knowing who changed what and when (critical for debugging and audits).
3. Reproducibility: Ensuring builds and deployments are consistent across environments.
4. Disaster recovery: Rolling back to a stable version if a new release fails.

In the Real World

1. eSewa (Nepal):

   • Version Control: eSewa’s backend team uses Git to manage changes across microservices (e.g., payment processing, user authentication). When a new feature (like QR-based payments) is developed, it’s branched, tested, and merged into main only after rigorous review.
   • Build Automation: CI/CD pipelines (using Jenkins) automatically test and deploy code to staging servers, ensuring no broken payments reach users.

2. Khalti (Nepal):

   • Release Management: Khalti’s mobile app undergoes canary releases—new versions are rolled out to 1% of users first. If fraud detection logic fails, they roll back instantly using SCM tools to track the exact commit that introduced the bug.
   • Legacy System Integration: Khalti’s older COBOL-based banking integrations are refactored incrementally (re-engineering) to support modern APIs, reducing technical debt.

3. Pathao (Nepal/Global):

   • Branching Strategy: Pathao uses GitFlow to manage feature branches (e.g., "ride-sharing UI overhaul") separately from production (master). Hotfixes for crashes (e.g., during Diwali traffic surges) are deployed via emergency branches.
   • Configuration Management: Different driver apps (Android/iOS) share core logic but have platform-specific configurations (e.g., GPS APIs), managed via feature flags in SCM.

Version Control Systems (VCS)

Version control tracks changes to files over time, enabling collaboration and recovery. Two dominant models:

How Git Works: A Trace Example

Scenario: Two developers, A and B, work on a Khalti payment gateway feature.

1. Initial State:

   git clone https://github.com/khalti/payment-gateway.git
   

2. Developer A adds a new API endpoint:

   git checkout -b feature/upi-payments
   # Edit code, test locally
   git add .
   git commit -m "Add UPI payment support"
   

3. Developer B fixes a bug in the same file (without knowing A’s changes):

   git checkout main
   git pull origin main
   # Fix bug, commit
   git commit -m "Fix transaction timeout"
   

4. Merge Conflict:
   • Git detects conflicting changes in payment_handler.py.
   • Resolution: Use git mergetool to manually reconcile differences, then git push.

sequenceDiagram
    DeveloperA->>Git: git checkout -b feature/upi-payments
    DeveloperA->>Git: git commit (UPI code)
    DeveloperB->>Git: git checkout main
    DeveloperB->>Git: git pull
    DeveloperB->>Git: git commit (bug fix)
    Git->>DeveloperA: Conflict detected!
    DeveloperA->>Git: git merge --no-ff
    Git-->>DeveloperA: Merged commit

Build Automation and CI/CD

Build automation compiles code, runs tests, and packages software. CI/CD (Continuous Integration/Deployment) extends this to automate releases.

Key Components

1. Build Tools:
   • Maven/Gradle (Java): Manages dependencies and compiles projects.
   • Makefile (C/C++): Defines build steps (e.g., make clean && make).
2. CI Servers:
   • Jenkins: Open-source, plugin-based (used by eSewa for automated testing).
   • GitHub Actions: Native to GitHub, triggers workflows on git push.
3. Artifact Repositories:
   • Nexus/Artifactory: Stores compiled binaries (e.g., .jar, .exe) for deployment.

Worked Example: Daraz’s Order Queue System

Problem: Daraz’s backend processes orders in a queue. A new feature adds real-time order tracking, but it breaks the queue system. Solution: Use CI/CD with GitLab:

1. Developer pushes code to feature/order-tracking branch.
2. GitLab CI triggers:
   • Unit tests (JUnit) → Fail: Queue timeout bug found.
   • Rollback: Deploy previous stable version (v1.2.0) to production.
3. Fix: Developer amends the branch, and CI retests before merging to main.

flowchart TD
    A["Developer Pushes Code"] --> B["GitLab CI Trigger"]
    B --> C["Run Unit Tests"]
    C -->|"Fail"| D["Alert Team"]
    D --> E["Rollback to v1.2.0"]
    E --> F["Fix Bug"]
    F --> C
    C -->|"Pass"| G["Merge to main"]

Software Re-engineering

Re-engineering transforms legacy systems (old, poorly documented code) into modern, maintainable software. Two approaches:

Challenges in Re-engineering

1. Technical Debt: Accumulated shortcuts (e.g., spaghetti code) make refactoring hard.
2. Documentation Gap: No comments or design docs for old systems.
3. Business Logic Entanglement: UI, database, and business rules are mixed.
4. Performance Trade-offs: Modernizing may require rewriting optimized but obscure code.

Example: Nepal Rastra Bank’s Legacy Core Banking System

• Problem: Written in COBOL, runs on mainframes, lacks APIs for digital banking.
• Solution:
  • Step 1: Use reverse engineering to extract business logic (e.g., loan calculation rules).
  • Step 2: Refactor into microservices (e.g., LoanService, CustomerService).
  • Step 3: Forward engineer a new UI with React.js and integrate via REST APIs.

erDiagram
    LegacySystem ||--o{ BusinessRule : "contains"
    BusinessRule ||--o{ Microservice : "migrated to"
    Microservice ||--o{ API : "exposes"
    API ||--o{ MobileApp : "used by"

Configuration Management Tools

Exam Tip

What Examiners Want to See

1. SCM:

   • Define version control, branching strategies (e.g., GitFlow), and merge conflicts.
   • Compare Git vs. SVN with a table (as above).
   • Worked Example: Show how a team (e.g., Pathao) uses branches for features/hotfixes.

2. Re-engineering:

   • Explain reverse vs. forward engineering with a real system (e.g., NRB’s COBOL migration).
   • Challenges: List technical debt, documentation gaps, and trade-offs.
   • Tools: Mention Understand (reverse engineering) or Spring Boot (forward engineering).

3. Build Automation:

   • Diagram a CI/CD pipeline (use sequenceDiagram or flowchart).
   • Link to Nepal: How eSewa uses Jenkins for payment system testing.

Common Pitfalls

• Vague Definitions: Avoid saying "SCM is about managing code." Instead, specify version control, build automation, and change management.
• Ignoring Tools: Always name Git, Jenkins, or Docker in answers about real-world applications.
• Overlooking Challenges: Re-engineering questions often ask for risks (e.g., "Why is migrating COBOL hard?").

How Git tracks changes across branches and merges (Image: TheresNoTime, CC BY-SA 4.0, via Wikimedia Commons)