This page is orientation for anyone landing on the deployed site rather than the repo directly. Object Lesson teaches object-oriented programming in Java to first-year students who've never written a class before, but who already drive a coding agent (a harness: Claude Code, Codex, or an equivalent tool) every day. The nine modules themselves, plus the reasoning behind their order, live in the repo, whose own README covers the same ground in more detail once you've cloned it. Nothing here substitutes for cloning it; this is orientation, not the content.
Two gates, not one
Every exercise runs through your own harness. A deterministic gate checks
first, a mechanical pass/fail with no judgment involved: javac compiles clean,
JUnit tests are green, Checkstyle is clean. Then a conceptual gate:
Coachgremlin, this workshop's teaching agent (a role you run yourself, inside your own
harness, not a hosted service), checks whether the design underneath is real, whether an
encapsulation actually protects an invariant or is just a getter and setter pasted onto
every field, whether inheritance was the right call or just the first one that compiled. A
class that compiles and passes its tests has cleared the first gate only; that is necessary,
never sufficient proof the design is sound.
New to the subject, not new to building software
This workshop assumes basic programming literacy: variables, conditionals, loops, functions, in any language. What it does not assume is any prior object-oriented programming or Java syntax, both are treated as genuinely new. That is a different gap than a practitioner picking up an unfamiliar language: here, the subject itself, not just its syntax, is the thing being learned for the first time.
The arc
Nine modules, each stating its real prerequisite rather than assuming you read the last one:
Classes & Objects, Constructors, Encapsulation, Inheritance, Polymorphism, Abstraction (with
a required-but-light Generics & Collections baseline, plus an optional deeper extension),
Composition vs. Inheritance, Exception Handling, then a synthesis capstone that hands you a
broken design and asks which concept is actually the root cause. Full reasoning for the
order, and the curriculum research it's checked against, is in the repo's
docs/workshop-design.md.
What you walk away with
Two different things get built during each module: your own judgment, and a reusable artifact your agent can load next time. See each module's own README (once authored) for the evidence behind its specific gate.
- You get practiced judgment: reading a compiler error and finding the real fix instead of a workaround, telling a real invariant apart from a cosmetic accessor, and deciding whether a relationship between two classes is genuinely "is-a" or actually "has-a."
- Your agent gets the packaged takeaways, artifacts you keep past the exercise itself: a class-vs-object scaffolding checklist, a constructor initialization checklist, an invariant-audit checklist, an is-a litmus test, a dynamic-dispatch debugging playbook, an interface-vs-abstract-class decision guide, a composition-vs-inheritance decision guide, a custom-exception-hierarchy template, and a personal OOP diagnostic playbook tying it all together.
The runbook
- Prerequisites: basic programming literacy in any language (variables, conditionals, loops, functions); already using a coding-agent harness regularly; a JDK installed.
-
Clone it:
git clone https://github.com/coderturtle/object-lesson.git -
Start at
modules/README.md. It has the full arc, in order, and a table of what each module's gate requires and what you keep from it. - Work through the nine modules in order. Each states its real prerequisite, and, where this workshop chose an order beyond what's structurally required, says so rather than dressing a preference up as a rule.
- No module completes by reading it. Every module states a required gate, checked first mechanically, then conceptually. If a module ever reduces to "read this, then move on," or a link here is broken, that's a defect: open an issue.