Facilitator Guide

This course is for developers who already understand data structures, control flow, functions, modules, testing, and at least one production language. The goal is not to teach programming from first principles. The goal is to help experienced developers become productive in Java by connecting Java syntax, runtime behavior, type-system choices, and library idioms to concepts they already know.

Course Promise

By the end of the six lessons, learners should be able to:

Read and modify idiomatic Java code that uses classes, records, interfaces, sealed hierarchies, generics, exceptions, and collections.
Explain how decorators and wrappers add behavior without changing a concrete implementation.
Use Java concurrency APIs at a practical level, including executors, futures, CompletableFuture, atomics, and virtual threads.
Build a small standard-library-only Java library and understand how image data flows through preprocessing and edge detection.
Explain all major Java @ annotation use cases and how frameworks interpret metadata.
Start a Spring Boot hello-world web app, trace a controller request, and test service and HTTP behavior.
Compile, run, reset, and inspect a Java project without relying on an IDE.

Delivery Format

The course is designed as six sessions of 120 minutes each. Each session has the same shape:

Time	Segment	Teaching Intent
0-10	Orientation	Connect the Java concept to equivalent ideas learners already know.
10-30	Demo run	Execute the demo, then inspect the entry point and type graph.
30-55	Guided code reading	Highlight Java-specific syntax, lifecycle, invariants, and API design choices.
55-85	Function-level exercise	Learners implement small functions with TODO comments and stable signatures.
85-105	Solution compare	Apply answers, compare with learner solutions, and discuss tradeoffs.
105-120	Extension and recap	Add a small variation, summarize rules of thumb, and note what to practice next.

The structure intentionally repeats so learners spend less cognitive energy understanding the workshop mechanics and more energy learning Java.

Instructor Preparation

Before class:

Run scripts/test.sh from the repository root.
Run scripts/verify_answers.sh to confirm completed exercise behavior.
Open cf_page.html in a browser for the course overview.
Read the relevant lesson_N/instructor_notes.md.
Reset exercises with scripts/reset_exercises.sh all.
Confirm the repo is in the learner-facing state with git status --short.

Recommended room setup:

One screen for the terminal and one screen for source code.
Font size large enough for code reading.
Editor configured for Java syntax highlighting.
No IDE automation required for the core course. IDEs are fine after learners understand the command line flow.
Lesson 6 needs Maven network access on first run to download Spring Boot dependencies.

Teaching Stance

Experienced developers usually need precision, not motivational filler. When a Java feature appears, explain:

What problem it solves.
What invariant or constraint it enforces.
What the equivalent concept might be in another language.
What mistake it prevents.
What mistake it can introduce when overused.

Prefer code reading and refactoring questions over trivia. For example, ask "what state can this object be in after construction?" instead of "what is a record?".

Handling Mixed Backgrounds

For developers from dynamic languages:

Spend extra time on compile-time types, method signatures, and generic constraints.
Explain that Java APIs often encode design intent in interfaces and constructors.
Emphasize that a compile error is often a design feedback loop, not just a syntax failure.

For developers from C, C++, Rust, or Go:

Compare Java references and garbage collection with ownership or pointer models.
Clarify where Java has value semantics by convention, such as records, but object identity still exists.
Emphasize runtime exceptions, checked exceptions in library APIs, and thread scheduling.

For developers from JavaScript or TypeScript:

Compare records to immutable data shapes, interfaces to structural contracts with nominal typing, and decorators to middleware/wrappers.
Point out where Java's nominal type system intentionally rejects shape-compatible objects.

Facilitation Checkpoints

Use these checkpoints before moving between major segments:

Learners can run scripts/run.sh lesson_N demo.
Learners can name the entry-point class and package.
Learners can explain one important method signature in plain language.
Learners can identify which files they should edit and which files are answer references.
Learners can reset their exercise without manual file copying.

Production Delivery Criteria

The material is delivery-ready when all of the following are true:

The course compiles and runs from a clean clone with JDK 21.
Lesson 6 verifies with Maven and can serve locally on 0.0.0.0:8080.
Each lesson has a clear 120-minute instructor plan.
Each lesson has a runnable demo and a compilable exercise before learner edits.
Each exercise has answer files and reset scripts.
The answer verification script proves the intended answer behavior.
The course overview and setup docs tell a new instructor what to run and what to expect.