Skip to content

The path

Fourteen weeks, four modules, and one application that grows the whole way. Each module opens the week we reach it, so you can always see where you are and what is coming.

The four modules as a rising pathA path rises from the lower left to the upper right, passing through four markers. The first marker is a single block, the second is two blocks joined together, the third is a block inside a protective ring, and the fourth is an application window. The first section of the path is drawn in a solid accent colour to show the part of the course already covered.
One object holding its own dataA single rounded rectangle with a coloured title bar and two lines of fields inside it, representing one object that owns its data.

Module 1Weeks 1 to 4

Objects and State

You stop writing lists of instructions and start building things that hold their own data.

Tools and first codeClasses and objectsState and behaviourHolding many objects

By the end you can

  • Turn a description of a problem into a set of classes
  • Explain what a reference actually points at, and why that matters
  • Keep a collection of your own objects and work through it

Open module Sprint 1 opens in week 4

Objects connected to one anotherThree small rounded rectangles joined by lines, showing objects that collaborate rather than standing alone.

Module 2Weeks 5 to 8

Designing with Objects

One class is easy. The skill is deciding how classes relate to each other, and knowing when the popular answer is the wrong one.

Objects working togetherOne job per classInheritance, and when not toInterfaces and polymorphism

By the end you can

  • Decide which class owns a piece of work, and which only asks for it
  • Make two objects holding the same data count as equal
  • Choose between inheritance and composition, and say why
  • Write code against an interface instead of a specific class

Opens in week 5

Sprint 2 opens in week 8

An object protected and testedA rounded rectangle inside a dashed protective boundary, with a tick mark beside it, representing code that is guarded against failure and checked by tests.

Module 3Weeks 9 to 12

Robust and Modern Java

Code that survives bad input, saves what it made, and proves it works. This is where your programs start behaving like real software.

When things go wrongProving it worksData that outlives the programLambdas and streams

By the end you can

  • Fail honestly with a clear message instead of crashing
  • Write tests before you claim something works
  • Save your data and load it back next time
  • Do in three lines what used to take fifteen

Opens in week 9

Sprint 3 opens in week 12

An application window built on top of your objectsAn application window with a title bar, a sidebar and content, sitting above a smaller object below it, showing that the interface rests on the model built earlier in the course.

Module 4Weeks 13 to 14

Building an Application

You put a window on the program you have been growing all semester. If the design underneath is good, this part is quick. That is the whole lesson.

Maven and your first windowConnecting it, then shipping it

By the end you can

  • Build a desktop application people can open and use
  • Connect what happens on screen to the objects underneath
  • Package it so it runs on someone else's machine

Opens in week 13

Sprint 3 due in week 14

The three sprints

One application. You do not start over, you keep going.

  • Sprint 1 · weeks 4 to 7

    Your first working program, built from classes you designed yourself. It runs in the console and it does something real.

  • Sprint 2 · weeks 8 to 12

    The same program, redesigned now that you know what a weak design costs. It saves your data, it handles mistakes, and it has tests.

  • Sprint 3 · weeks 12 to 14

    The same program again, with a window on top and packaged so you can send it to someone.

What you walk away with

  • Thinking in objects

    • Turn a problem description into classes
    • Know what a reference points at
    • Read an error and find the cause
    • Keep and work through collections

  • Design judgement

    • Identity and equality that behave
    • Inheritance or composition, on purpose
    • Program to an interface
    • Model a domain with records and enums

  • Software that holds up

    • Handle failure honestly
    • Test your own work with JUnit
    • Read and write files safely
    • Process data with streams

  • Shipping it

    • Build and manage dependencies with Maven
    • Build a desktop application
    • Package it so others can run it
    • Keep a project on GitHub worth showing

Ready to start?

Set up your tools