Continuous Improvement in Software Engineering Explained for Beginners

// 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));
    }
}

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);
    }
}

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);
    }
}

// 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.");
    }
}