Predict a result, run a cell, investigate what changes, and check your understanding. Build from your first calculation to a small TrailLedger cost and attendance calculator. All 24 Foundations labs are ready: 20 notebooks and four VM lessons. The two later tracks are coming soon.
Turn a small requirement into a Java program, check it, and explain how it works.
Design a maintainable application with interfaces, collections, streams, exceptions, files, and tests.
Reason about modern Java, concurrency and modules; diagnose failures and package a reliable application.
Turn a small requirement into a Java program, check it, and explain how it works.
Distinguish source code, compilation, and execution, first in the notebook and then with real command-line tools.
Run Java expressions, print text and numbers, and use comments.
Understand compilation, read error messages, and fix Java spelling, punctuation, and logic errors.
Follow a source file through compilation, execution, a stale class file, and a repaired compiler error.
Store values, calculate with their types, and understand which installed tools perform each job.
Declare variables, change stored values, trace assignments, and choose basic Java types.
Learn integer division, remainder, precedence, casts, overflow, and basic Math methods.
Map the installed tools and runtime, read real version metadata, and distinguish feature releases, updates, and vendor support.
Choose behavior with explicit conditions, then use JShell to test short pieces of Java directly.
Use comparisons, if/else, and logical operators to make decisions and check boundary values.
Select cases with switch statements and expressions, handle defaults, and follow nested decisions.
Explore expressions, variables, methods, diagnostics, and saved snippets with the real JDK REPL.
Trace repetition, update values correctly, and write loops that stop.
Use for, while, and do/while loops; trace updates; and check zero, one, and several iterations.
Use break and continue, keep loop state separate, bound nested loops, and repair missing updates.
Write bounded loops that count and total matching values, include endpoints, handle empty ranges, and repair updates.
Process groups of values and turn simple text into usable Java values.
Store several values, read array indexes, loop through sequences, and add or remove list elements.
Compare text with equals, extract and search text, split values, and understand String immutability.
Convert text into int and long values, separate simple fields, and reject malformed or invalid input.
Write reusable calculations and check their results on more than one input.
Turn a small requirement into a static method, pass inputs, return results, and separate calculation from printing.
Trace copied arguments, distinguish object mutation from parameter reassignment, and call simple method overloads.
Compare expected and actual results, report failed checks, test boundaries, and rerun earlier cases after a repair.
Store related state safely and make objects work together through small methods.
Create independent objects, initialize fields with constructors, use instance and static members, and protect state with validation.
Call different implementations through an interface, override inherited behavior, and read and handle controlled failures.
Store one object as a field of another, delegate behavior, and distinguish shared references from independent objects.
Assemble a small calculation, preserve behavior when rules change, and run it outside the notebook with JBang.
Split a cost in whole cents, summarize participant counts, validate inputs, and assemble a small report.
Exclude cancelled bookings, reuse one rule in reports, and stop a caller’s array changes from altering stored data.
Run an independent calculator offline, pass and validate arguments, then compare three source-to-program workflows.
Design a maintainable application with interfaces, collections, streams, exceptions, files, and tests.
Scenario: mutable booking data leaks into reports, while some values should never change after creation.
Scenario: a new discount policy must be added without a growing chain of type checks.
Scenario: duplicate bookings, unstable display order and an inefficient waiting list appear in the same release.
Scenario: a reusable repository returns the wrong kind of object and its casts fail late.
Scenario: the club wants useful summaries, but a tangled loop mixes filtering, formatting and totals.
Scenario: an imported roster has malformed lines; a partial export must not overwrite the good file.
Scenario: a departure time crosses a time-zone boundary and a report rounds prices incorrectly.
Scenario: a volunteer adds a refund policy shortly before a release. The application needs a trustworthy safety net.
Reason about modern Java, concurrency and modules; diagnose failures and package a reliable application.
Scenario: the code works in the notebook but a versioned release fails to compile or selects an unexpected overload.
Scenario: reports require grouping, rolling windows and a reliable reduction, not a chain copied from a tutorial.
Scenario: two workers confirm the same last booking slot. Repeated runs reveal inconsistent totals.
Scenario: a report engine has too many threads, loses failures, and carries the wrong trip context between tasks.
Scenario: reports work on the author's machine but fail with another charset, filesystem layout or locale.
Scenario: pricing plugins work on the classpath but fail after modularization. The release must contain what the application actually needs.
Scenario: a distributed release has changed since it was signed, while another release consumes unexpected memory.
Scenario: a release candidate must process incoming trip files correctly, survive bad input, and be handed to another maintainer with usable evidence.