Continuous Improvement in Software — Why Teams Stall

package io.thecodeforge;

// CONTINUOUS IMPROVEMENT DEMO
// We'll show the SAME function at three stages:
// Stage 1 — first draft (it works, but it's hard to read and maintain)
// Stage 2 — after a code review (clearer names, single responsibility)
// Stage 3 — after a performance check (early exit, avoids unnecessary work)

public class PasswordValidator {

    // ─────────────────────────────────────────────
    // STAGE 1: First draft — written quickly to pass tests.
    // It works, but everything is crammed into one method.
    // A new teammate reading this has no idea what '8' means.
    // ─────────────────────────────────────────────
    public static boolean checkPwd(String p) {
        if (p.length() < 8) return false;       // magic number — what is 8?
        boolean h = false;                       // h? no one knows what this is
        boolean n = false;
        for (int i = 0; i < p.length(); i++) {
            if (Character.isUpperCase(p.charAt(i))) h = true;
            if (Character.isDigit(p.charAt(i)))     n = true;
        }
        return h && n;
    }

    // ─────────────────────────────────────────────
    // STAGE 2: After code review feedback.
    // Renamed everything. Extracted a constant for the minimum length.
    // Still one method, but now a new developer can read it like English.
    // ─────────────────────────────────────────────
    private static final int MINIMUM_PASSWORD_LENGTH = 8;

    public static boolean isPasswordValid(String password) {
        if (password.length() < MINIMUM_PASSWORD_LENGTH) return false;

        boolean containsUppercase = false;
        boolean containsDigit     = false;

        for (char character : password.toCharArray()) {
            if (Character.isUpperCase(character)) containsUppercase = true;
            if (Character.isDigit(character))     containsDigit     = true;
        }
        return containsUppercase && containsDigit;
    }

    // ─────────────────────────────────────────────
    // STAGE 3: After a performance retrospective.
    // The team noticed validation runs thousands of times per second.
    // Small win: break out of the loop as soon as both conditions are met
    // instead of always scanning the full password string.
    // ─────────────────────────────────────────────
    public static boolean isPasswordValidFast(String password) {
        if (password == null || password.length() < MINIMUM_PASSWORD_LENGTH) {
            return false; // guard against null input — caught in testing
        }

        boolean containsUppercase = false;
        boolean containsDigit     = false;

        for (char character : password.toCharArray()) {
            if (Character.isUpperCase(character)) containsUppercase = true;
            if (Character.isDigit(character))     containsDigit     = true;

            // Early exit: once both flags are true, keep scanning is wasted work.
            // This is the improvement — identical output, measurably faster at scale.
            if (containsUppercase && containsDigit) break;
        }
        return containsUppercase && containsDigit;
    }

    public static void main(String[] args) {
        String weakPassword  = "hello";           // too short, no uppercase, no digit
        String mediumPassword = "HelloWorld";     // long enough, has uppercase, no digit
        String strongPassword = "HelloWorld9";    // passes all checks

        System.out.println("=== Stage 1 (original checkPwd) ===");
        System.out.println("'hello'       valid: " + checkPwd(weakPassword));
        System.out.println("'HelloWorld'  valid: " + checkPwd(mediumPassword));
        System.out.println("'HelloWorld9' valid: " + checkPwd(strongPassword));

        System.out.println("\n=== Stage 2 (after code review) ===");
        System.out.println("'hello'       valid: " + isPasswordValid(weakPassword));
        System.out.println("'HelloWorld'  valid: " + isPasswordValid(mediumPassword));
        System.out.println("'HelloWorld9' valid: " + isPasswordValid(strongPassword));

        System.out.println("\n=== Stage 3 (after performance retro) ===");
        System.out.println("'hello'       valid: " + isPasswordValidFast(weakPassword));
        System.out.println("'HelloWorld'  valid: " + isPasswordValidFast(mediumPassword));
        System.out.println("'HelloWorld9' valid: " + isPasswordValidFast(strongPassword));
    }
}

package io.thecodeforge;

import java.util.ArrayList;
import java.util.List;

// This class models the kind of simple metric tracking a team
// might use to check whether they're actually improving sprint-over-sprint.
// Real teams use dashboards (Jira, DataDog) but the logic is the same.

public class SprintMetricsTracker {

    // Each Sprint holds the data points the team cares about.
    static class Sprint {
        String  sprintName;         // e.g. "Sprint 12"
        int     bugsReported;       // bugs found by users after release
        int     storyPointsDelivered; // work completed (higher = more productive)
        double  averageResponseTimeMs; // how fast the app responds on average

        Sprint(String name, int bugs, int points, double responseTime) {
            this.sprintName              = name;
            this.bugsReported            = bugs;
            this.storyPointsDelivered    = points;
            this.averageResponseTimeMs   = responseTime;
        }
    }

    // Compares two sprints and prints whether each metric improved.
    // This mirrors what a retrospective dashboard would show the team.
    public static void compareSprintProgress(Sprint previous, Sprint current) {
        System.out.println("\n── Improvement Report: "
            + previous.sprintName + " → " + current.sprintName + " ──");

        // Bugs: fewer is better
        int bugDelta = current.bugsReported - previous.bugsReported;
        System.out.printf("Bugs reported:       %d → %d   (%s)%n",
            previous.bugsReported,
            current.bugsReported,
            bugDelta < 0 ? "✓ IMPROVED by " + Math.abs(bugDelta)
                         : bugDelta == 0 ? "→ no change"
                                         : "✗ worse by " + bugDelta);

        // Story points: more is better (team is more productive)
        int pointsDelta = current.storyPointsDelivered - previous.storyPointsDelivered;
        System.out.printf("Story points:        %d → %d   (%s)%n",
            previous.storyPointsDelivered,
            current.storyPointsDelivered,
            pointsDelta > 0 ? "✓ IMPROVED by " + pointsDelta
                            : pointsDelta == 0 ? "→ no change"
                                              : "✗ dropped by " + Math.abs(pointsDelta));

        // Response time: lower is better (app is faster)
        double timeDelta = current.averageResponseTimeMs - previous.averageResponseTimeMs;
        System.out.printf("Avg response time:   %.0fms → %.0fms   (%s)%n",
            previous.averageResponseTimeMs,
            current.averageResponseTimeMs,
            timeDelta < 0 ? "✓ IMPROVED by " + Math.abs((int) timeDelta) + "ms"
                          : timeDelta == 0 ? "→ no change"
                                           : "✗ slower by " + (int) timeDelta + "ms");
    }

    public static void main(String[] args) {
        // Simulate three sprints of data for a team practising continuous improvement.
        // Notice the gradual, realistic improvement — not overnight perfection.
        Sprint sprint10 = new Sprint("Sprint 10", 14,  32, 420.0);
        Sprint sprint11 = new Sprint("Sprint 11", 11,  35, 390.0);
        Sprint sprint12 = new Sprint("Sprint 12",  7,  38, 310.0);

        List<Sprint> history = new ArrayList<>();
        history.add(sprint10);
        history.add(sprint11);
        history.add(sprint12);

        // Compare consecutive sprints to visualise the improvement trend
        for (int i = 1; i < history.size(); i++) {
            compareSprintProgress(history.get(i - 1), history.get(i));
        }

        System.out.println("\n── Overall Trend (Sprint 10 → Sprint 12) ──");
        compareSprintProgress(sprint10, sprint12);
    }
}

package io.thecodeforge;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

// This models a simple Kaizen-style change log.
// In a real team this would be a ticket in Jira or a row in Confluence.
// Here it demonstrates the habit: every small improvement is recorded,
// with WHO raised it, WHAT the problem was, and WHAT the fix was.
// That record is what turns a one-off fix into a team learning.

public class KaizenChangeLog {

    enum ImprovementCategory {
        CODE_QUALITY,    // cleaner, more readable code
        PERFORMANCE,     // faster execution or lower memory use
        PROCESS,         // team workflow or deployment pipeline
        SECURITY         // vulnerability or access control fix
    }

    static class ImprovementEntry {
        LocalDate            dateRaised;
        String               raisedByDeveloper;
        ImprovementCategory  category;
        String               problemObserved;   // what triggered this
        String               changeImplemented; // what was actually done
        boolean              measuredImpact;    // did we verify it helped?

        ImprovementEntry(
            LocalDate date,
            String developer,
            ImprovementCategory category,
            String problem,
            String change,
            boolean measured
        ) {
            this.dateRaised          = date;
            this.raisedByDeveloper   = developer;
            this.category            = category;
            this.problemObserved     = problem;
            this.changeImplemented   = change;
            this.measuredImpact      = measured;
        }

        // Prints a formatted summary — the kind of thing a team
        // would review at the start of a retrospective
        void printSummary() {
            System.out.println("Date:     " + dateRaised);
            System.out.println("Developer: " + raisedByDeveloper);
            System.out.println("Category:  " + category);
            System.out.println("Problem:   " + problemObserved);
            System.out.println("Fix:       " + changeImplemented);
            System.out.println("Measured:  " + (measuredImpact ? "✓ Yes" : "✗ Not yet — needs follow-up"));
            System.out.println("─".repeat(55));
        }
    }

    public static void main(String[] args) {
        List<ImprovementEntry> changeLog = new ArrayList<>();

        // Entry 1: a developer noticed something slow during a code review
        changeLog.add(new ImprovementEntry(
            LocalDate.of(2024, 3, 4),
            "Priya Nair",
            ImprovementCategory.PERFORMANCE,
            "Database query in UserService runs on every API call, even for cached users",
            "Added Redis cache layer; query now runs only on cache miss",
            true   // team checked response time dropped from 340ms to 85ms
        ));

        // Entry 2: raised in a retrospective, not a code review
        changeLog.add(new ImprovementEntry(
            LocalDate.of(2024, 3, 18),
            "Marcus Webb",
            ImprovementCategory.PROCESS,
            "Deployments take 40 minutes because Docker image is rebuilt from scratch every time",
            "Configured CI pipeline to cache dependency layer; build time now 9 minutes",
            true
        ));

        // Entry 3: improvement raised but not yet verified — flagged for next sprint
        changeLog.add(new ImprovementEntry(
            LocalDate.of(2024, 4, 1),
            "Sofia Torres",
            ImprovementCategory.CODE_QUALITY,
            "OrderProcessor class has 800 lines and handles pricing, tax, AND shipping logic",
            "Split into PriceCalculator, TaxCalculator, ShippingCalculator (Single Responsibility)",
            false  // tests pass but performance impact not measured yet
        ));

        System.out.println("══ Kaizen Change Log — Q1 2024 ══\n");
        for (ImprovementEntry entry : changeLog) {
            entry.printSummary();
        }

        // Summary: how many improvements have been verified vs pending?
        long verified = changeLog.stream()
            .filter(e -> e.measuredImpact)
            .count();

        System.out.printf("\nTotal improvements logged: %d  |  Verified: %d  |  Pending measurement: %d%n",
            changeLog.size(), verified, changeLog.size() - verified);
    }
}

package io.thecodeforge;

// This file shows how automated tests protect your improvements.
// The test suite here acts as a safety net: once the behaviour is
// correct and tested, you can refactor (improve) the implementation
// freely, knowing the tests will scream if you break anything.

// We're using plain Java assertions to keep this runnable without
// a test framework — in a real project you'd use JUnit 5.

public class ShoppingCartTest {

    // ── The class being tested ──────────────────────────────────────
    // This is a simplified shopping cart. Imagine the team is about
    // to refactor the applyDiscount method to be faster.
    // The tests below must all still pass after the refactor.

    static class ShoppingCart {
        private double totalPriceInPounds;

        ShoppingCart(double initialTotal) {
            this.totalPriceInPounds = initialTotal;
        }

        // Returns the price after applying a percentage discount.
        // e.g. applyDiscount(10) removes 10% from the total.
        public double applyDiscount(int discountPercentage) {
            if (discountPercentage < 0 || discountPercentage > 100) {
                throw new IllegalArgumentException(
                    "Discount must be between 0 and 100, got: " + discountPercentage
                );
            }
            // Calculate what fraction of the price to KEEP (not remove)
            double multiplier = (100.0 - discountPercentage) / 100.0;
            return totalPriceInPounds * multiplier;
        }
    }

    // ── Test runner ─────────────────────────────────────────────────
    // Each test method checks one specific behaviour.
    // If something goes wrong, we know EXACTLY which behaviour broke.

    static void testNoDiscountLeavesTotalUnchanged() {
        ShoppingCart cart = new ShoppingCart(50.00);
        double result = cart.applyDiscount(0);   // 0% off = no change
        assert result == 50.00 :
            "FAIL: 0% discount should return 50.00 but got " + result;
        System.out.println("✓ testNoDiscountLeavesTotalUnchanged");
    }

    static void testTenPercentDiscountIsCorrect() {
        ShoppingCart cart = new ShoppingCart(100.00);
        double result = cart.applyDiscount(10);  // 10% off £100 = £90
        assert result == 90.00 :
            "FAIL: 10% discount on £100 should return 90.00 but got " + result;
        System.out.println("✓ testTenPercentDiscountIsCorrect");
    }

    static void testHundredPercentDiscountGivesZero() {
        ShoppingCart cart = new ShoppingCart(75.00);
        double result = cart.applyDiscount(100); // 100% off = free
        assert result == 0.00 :
            "FAIL: 100% discount should return 0.00 but got " + result;
        System.out.println("✓ testHundredPercentDiscountGivesZero");
    }

    static void testInvalidDiscountThrowsException() {
        ShoppingCart cart = new ShoppingCart(50.00);
        try {
            cart.applyDiscount(150); // 150% is impossible — should throw
            // If we reach this line, the exception was NOT thrown — that's a failure
            System.out.println("FAIL: testInvalidDiscountThrowsException — no exception raised");
        } catch (IllegalArgumentException expectedException) {
            // This is exactly what we want — the method correctly rejected bad input
            System.out.println("✓ testInvalidDiscountThrowsException");
        }
    }

    public static void main(String[] args) {
        // Enable assertions — required for the 'assert' keyword to work.
        // Run with: java -ea ShoppingCartTest
        System.out.println("Running test suite for ShoppingCart...\n");

        testNoDiscountLeavesTotalUnchanged();
        testTenPercentDiscountIsCorrect();
        testHundredPercentDiscountGivesZero();
        testInvalidDiscountThrowsException();

        System.out.println("\nAll tests passed. Safe to refactor.");
        System.out.println("Refactor the applyDiscount method freely —");
        System.out.println("run this suite again afterwards to confirm nothing broke.");
    }
}

package io.thecodeforge;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

// A simple personal log to track one developer's continuous improvement.
// The act of writing it down reinforces the habit.

public class PersonalImprovementLog {

    static class Entry {
        LocalDate date;
        String description;
        String category;  // READABILITY, PERFORMANCE, TESTING, PROCESS
        boolean measured;

        Entry(LocalDate date, String description, String category, boolean measured) {
            this.date = date;
            this.description = description;
            this.category = category;
            this.measured = measured;
        }
    }

    public static void main(String[] args) {
        List<Entry> log = new ArrayList<>();

        log.add(new Entry(LocalDate.of(2026, 3, 10),
            "Extracted magic number 86400 into constant ONE_DAY_IN_SECONDS",
            "READABILITY", false));

        log.add(new Entry(LocalDate.of(2026, 3, 17),
            "Added unit test for DateUtils.parseISO — now 85% coverage on that class",
            "TESTING", true));

        log.add(new Entry(LocalDate.of(2026, 3, 24),
            "Changed loop in ReportGenerator to use StringBuilder instead of String concat",
            "PERFORMANCE", true));

        log.add(new Entry(LocalDate.of(2026, 4, 1),
            "Removed unused import in 12 files after running IntelliJ inspection",
            "PROCESS", false));

        System.out.println("══ My Personal Improvement Log ══");
        for (Entry e : log) {
            System.out.printf("%s | %s | %s | Measured: %s%n",
                e.date, e.category, e.description, e.measured ? "✓" : "✗");
        }

        long measuredCount = log.stream().filter(e -> e.measured).count();
        System.out.printf("\nTotal improvements: %d | Measured: %d (%.0f%%)%n",
            log.size(), measuredCount, (measuredCount * 100.0 / log.size()));
    }
}

package io.thecodeforge;

import java.util.Arrays;
import java.util.List;

// A simple checker to detect anti-patterns in a team's improvement process.

public class AntiPatternDetector {

    enum RiskLevel { LOW, MEDIUM, HIGH }

    static class CheckResult {
        String symptom;
        String category;
        RiskLevel risk;

        CheckResult(String symptom, String category, RiskLevel risk) {
            this.symptom = symptom;
            this.category = category;
            this.risk = risk;
        }
    }

    public static List<CheckResult> runChecks(TeamSnapshot team) {
        return Arrays.asList(
            // Retro action item ownership
            new CheckResult(
                team.retroActionItemsWithOwner < team.totalRetroItems * 0.8,
                "Retro items without owners: " + (team.totalRetroItems - team.retroActionItemsWithOwner),
                "RETRO_ACTION",
                team.retroActionItemsWithOwner < 1 ? RiskLevel.HIGH : RiskLevel.MEDIUM
            ),
            // Improvement measurement
            new CheckResult(
                team.improvementsMeasured < team.totalImprovements * 0.5,
                "Unmeasured improvements: " + (team.totalImprovements - team.improvementsMeasured),
                "MEASUREMENT",
                team.improvementsMeasured == 0 ? RiskLevel.HIGH : RiskLevel.MEDIUM
            ),
            // Big rewrite signal
            new CheckResult(
                team.bigBrewriteInProgress,
                "Big rewrite is planned — small steps may be lacking",
                "REWRITE",
                RiskLevel.HIGH
            )
        );
    }

    static class TeamSnapshot {
        int totalRetroItems;
        int retroActionItemsWithOwner;
        int totalImprovements;
        int improvementsMeasured;
        boolean bigBrewriteInProgress;

        TeamSnapshot(int retroItems, int ownedItems, int totalImps, int measuredImps, boolean rewrite) {
            this.totalRetroItems = retroItems;
            this.retroActionItemsWithOwner = ownedItems;
            this.totalImprovements = totalImps;
            this.improvementsMeasured = measuredImps;
            this.bigBrewriteInProgress = rewrite;
        }
    }

    public static void main(String[] args) {
        TeamSnapshot troubled = new TeamSnapshot(5, 1, 8, 0, true);
        List<CheckResult> results = runChecks(troubled);
        System.out.println("Anti-pattern scan results:");
        for (CheckResult r : results) {
            System.out.printf("[%s] %s — Risk: %s%n", r.category, r.symptom, r.risk);
        }
    }
}

// io.thecodeforge — cs-fundamentals tutorial

import json
from datetime import datetime

def create_retro_action(team: str, stop: str, start: str, continue_: str) -> dict:
    """Force a concrete action from retrospective feedback."""
    if not stop or not start or not continue_:
        raise ValueError("Each category needs at least one item")
    
    return {
        "team": team,
        "date": datetime.utcnow().isoformat(),
        "stop_doing": stop,
        "start_doing": start,
        "continue_doing": continue_,
        "owner": "unassigned",
        "status": "open"
    }

# Real usage: action items from a sprint retro
payment_pipeline_retro = create_retro_action(
    team="payment-pipeline",
    stop="merging without peer review on Fridays",
    start="write integration test for each new webhook handler",
    continue_="daily dependency scan in CI"
)

print(json.dumps(payment_pipeline_retro, indent=2))

// io.thecodeforge — cs-fundamentals tutorial

from datetime import datetime, timedelta

def calculate_cycle_time(commit_dates: list[str], deploy_date: str) -> float:
    """Returns average cycle time in hours from commit to deploy."""
    fmt = "%Y-%m-%d %H:%M:%S"
    deploy = datetime.strptime(deploy_date, fmt)
    commits = [datetime.strptime(d, fmt) for d in commit_dates]
    first_commit = min(commits)
    cycle_hours = (deploy - first_commit).total_seconds() / 3600
    return round(cycle_hours, 2)

# Real telemetry from a payment service deploy
commits = [
    "2025-04-07 09:15:00",
    "2025-04-07 11:30:00",
    "2025-04-07 14:45:00"
]
deploy = "2025-04-07 15:10:00"

print(f"Cycle time: {calculate_cycle_time(commits, deploy)} hours")

// io.thecodeforge — cs-fundamentals tutorial

import threading
from typing import Dict, List

class LeastConnectionBalancer:
    def __init__(self, servers: List[str]):
        self._servers = {s: 0 for s in servers}  # name -> active connections
        self._lock = threading.Lock()

    def next_server(self) -> str:
        with self._lock:
            min_server = min(self._servers, key=self._servers.get)
            self._servers[min_server] += 1
            return min_server

    def release(self, server: str):
        with self._lock:
            self._servers[server] = max(0, self._servers[server] - 1)

# Usage
balancer = LeastConnectionBalancer(["web-1", "web-2", "web-3"])
print(balancer.next_server())

// io.thecodeforge — cs-fundamentals tutorial

import threading
from typing import Dict, List

class LeastResponseTimeBalancer:
    def __init__(self, servers: List[str], alpha: float = 0.3):
        self._avg: Dict[str, float] = {s: 0.0 for s in servers}
        self._lock = threading.Lock()
        self._alpha = alpha

    def next_server(self) -> str:
        with self._lock:
            return min(self._avg, key=self._avg.get)

    def record_response(self, server: str, elapsed_ms: float):
        with self._lock:
            old = self._avg[server]
            self._avg[server] = (1 - self._alpha) * old + self._alpha * elapsed_ms

# Usage
balancer = LeastResponseTimeBalancer(["db-1", "db-2"])
balancer.record_response("db-1", 12.0)
balancer.record_response("db-2", 45.0)
print(balancer.next_server())

// io.thecodeforge — cs-fundamentals tutorial

import threading
from typing import Dict, List, Tuple

class Report:
    def __init__(self, cpu_pct: float, mem_pct: float):
        self.cpu = cpu_pct
        self.mem = mem_pct

def score(report: Report) -> float:
    return 0.6 * report.cpu + 0.4 * report.mem

class ResourceBasedBalancer:
    def __init__(self, servers: List[str]):
        self._reports: Dict[str, Report] = {s: Report(0, 0) for s in servers}
        self._lock = threading.Lock()

    def update(self, server: str, report: Report):
        with self._lock:
            self._reports[server] = report

    def next_server(self) -> str:
        with self._lock:
            return min(self._reports, key=lambda s: score(self._reports[s]))

# Usage
balancer = ResourceBasedBalancer(["compute-1", "compute-2"])
balancer.update("compute-1", Report(85.0, 40.0))
balancer.update("compute-2", Report(30.0, 70.0))
print(balancer.next_server())

import datetime
from collections import defaultdict

# Example: calculate deployment frequency from git log
def calculate_deployment_frequency(commits):
    # commits: list of datetime objects
    if not commits:
        return 0
    first = min(commits)
    last = max(commits)
    days = (last - first).days or 1
    return len(commits) / days

# Example: lead time for changes (simplified)
def lead_time_for_changes(commit_time, deploy_time):
    return (deploy_time - commit_time).total_seconds() / 3600  # hours

# Example: change failure rate
def change_failure_rate(deployments, failures):
    return failures / deployments if deployments > 0 else 0

# Example: time to restore service
def time_to_restore(incident_start, incident_end):
    return (incident_end - incident_start).total_seconds() / 60  # minutes

# Postmortem: [Incident Title]

**Date:** YYYY-MM-DD
**Severity:** P0/P1/P2
**Duration:** [start] - [end]
**Summary:** One-line description

## Timeline
- [Time] Event occurred
- [Time] Alert triggered
- [Time] Investigation began
- [Time] Mitigation applied
- [Time] Service restored

## Contributing Factors
- Factor 1: description
- Factor 2: description

## Action Items
- [ ] Action 1 (Owner, Deadline)
- [ ] Action 2 (Owner, Deadline)

## Lessons Learned
- What went well
- What could be improved
- How to prevent recurrence

groups:
  - name: api_alerts
    rules:
      - alert: HighLatency
        expr: histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m])) > 0.5
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "High p99 latency on {{ $labels.instance }}"
          description: "p99 latency is {{ $value }}s for 5 minutes"
      - alert: HighErrorRate
        expr: rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m]) > 0.01
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Error rate above 1% on {{ $labels.instance }}"