If Statements, Determinism and Safer Control Flow

Starter: think before typing

Before running this safer branching example, find the line where the main idea becomes active. Write a prediction: what must already be true for that line to work, and what should be different after it runs? The checked run ends with `Moderation allowed for Ada Switch result: 5.0 Dispatch result: 7.0 list items Saved request Java allows boolean assignment in a condition: ready is now true`; predict how the focus line helps produce that evidence.

Learning Objectives

• Explain how an if statement creates alternative traces.
• Estimate why nested branches become hard to test.
• Use named predicates and guard clauses to flatten control flow.
• Choose switch, lookup tables or polymorphism when they make branching clearer.

Learning Outcomes

• By the end of the lesson, you can explain how an if statement creates alternative traces.
• By the end of the lesson, you can estimate why nested branches become hard to test.
• By the end of the lesson, you can use named predicates and guard clauses to flatten control flow.
• By the end of the lesson, you can choose switch, lookup tables or polymorphism when they make branching clearer.

Why this idea exists

Conditional flow is implemented as jumps through execution. A loop is a predictable jump around a repeated structure; an `if` is an execution-time decision point where the program may split into different traces.

The danger is not the keyword itself. The danger is path multiplication: every extra condition can double the number of routes through the code, and later state changes can make those routes hard to test or reason about.

Good programmers therefore treat `if` as a design choice, not a reflex. Prefer deterministic loops with clear bounds, named predicates, guard clauses, switch expressions, lookup tables or polymorphism when they make the flow clearer.

Deep dive

Lesson visual

Type this and run it

Create IfStatementsDeterminismDemo.java, type the program, and run it before changing anything. This section is about reproducing the checked baseline.

public class IfStatementsDeterminismDemo {
  enum Op { ADD, SUB, MUL, DIV }

  public static void main(String[] args) {
    User user = new User("Ada", true, false, "ADMIN");
    moderateIfAllowed(true, user);
    System.out.println("Switch result: " + apply(Op.DIV, 10, 2));
    System.out.println("Dispatch result: " + dispatch('+', 3, 4));
    runCommand("list");
    handle(new Request(true, true, false));
    demonstrateAssignmentTrap();
  }

  static void moderateIfAllowed(boolean isOpen, User user) {
    boolean canModerate = user.role().equals("ADMIN") || (user.active() && !user.banned());
    if (!isOpen) {
      System.out.println("Closed: no moderation trace.");
      return;
    }
    if (!canModerate) {
      System.out.println("Rejected: user cannot moderate.");
      return;
    }
    System.out.println("Moderation allowed for " + user.name());
  }

  static double apply(Op op, double a, double b) {
    return switch (op) {
      case ADD -> a + b;
      case SUB -> a - b;
      case MUL -> a * b;
      case DIV -> b != 0 ? a / b : 0;
    };
  }

  static double dispatch(char op, double a, double b) {
    java.util.Map<Character, Operation> ops = java.util.Map.of(
      '+', (left, right) -> left + right,
      '-', (left, right) -> left - right
    );
    Operation operation = ops.get(op);
    return operation == null ? 0 : operation.apply(a, b);
  }

  static void runCommand(String command) {
    java.util.Map<String, Runnable> commands = java.util.Map.of(
      "add", () -> System.out.println("add item"),
      "del", () -> System.out.println("delete item"),
      "list", () -> System.out.println("list items")
    );
    Runnable action = commands.getOrDefault(command, () -> System.out.println("Unknown command"));
    action.run();
  }

  static boolean handle(Request request) {
    if (!request.valid()) return false;
    if (!request.hasAuth()) return false;
    if (request.locked()) return false;
    return save(request);
  }

  static boolean save(Request request) {
    System.out.println("Saved request");
    return true;
  }

  static void demonstrateAssignmentTrap() {
    boolean ready = false;
    if (ready = true) {
      System.out.println("Java allows boolean assignment in a condition: ready is now " + ready);
    }
  }
}

interface Operation {
  double apply(double a, double b);
}

record User(String name, boolean active, boolean banned, String role) { }

record Request(boolean valid, boolean hasAuth, boolean locked) { }

Build and run it with:

javac IfStatementsDeterminismDemo.java && java IfStatementsDeterminismDemo

Expected baseline: Moderation allowed for Ada Switch result: 5.0 Dispatch result: 7.0 list items Saved request Java allows boolean assignment in a condition: ready is now true

Line-by-line explanation

Read the code as a sequence of responsibilities. The focus line for this lesson is enum Op { ADD, SUB, MUL, DIV }; the surrounding lines prepare it, use its result or make the behaviour observable.

Worked example

Trace the program

Common misconception

A common mistake in if statements, determinism and safer control flow is treating the example as a finished answer. For safer branching, the important question is narrower: which operation carries the idea, what does it make possible, and what would break if you changed it carelessly?

Quick checks

How to study this lesson

For If Statements, Determinism and Safer Control Flow, predict how safer branching changes the run before you press Run.

Use the first portfolio task as your main edit: Count the branches in a small function and list its possible traces.

Use the second task as your variation: Rewrite a nested if using named predicates and guard clauses.

Finish with evidence, not a diary entry: Replace an add/delete/list if-else command ladder with a switch, then with a dispatch map, and compare maintainability.

Portfolio Practice

1. Count the branches in a small function and list its possible traces.
2. Rewrite a nested if using named predicates and guard clauses.
3. Replace an add/delete/list if-else command ladder with a switch, then with a dispatch map, and compare maintainability.

Final self-check

Study route

Practise safer branching by predicting the Java example, typing it, running it in the browser, tracing the result and saving portfolio evidence.

Next, move into Methods and Decomposition and carry forward one improvement from this lesson into the next program.