Back to learning
Java Programming

Java Foundation

Start from nothing and finish with a Student Management System you built, debugged and can explain.

  • Beginner
  • About 8 weeks
  • 7 milestones
  • 24 steps
Java
Start this journey
What you will have builtA working Java application you wrote yourself — students, marks, grades and a menu — plus a written defence of why it is built the way it is.Start this journey

What this asks of you

Every figure below is read from the journey itself, not written about it.

BeginnerNo prior experience needed
About 8 weeksAn estimate, not a deadline
7 milestonesEach one claims a capability
24 stepsShort, and every one is built

What you will be able to do

Every milestone claims one engineering capability. You reach it by building something, not by finishing a chapter.

Java runs on your machineGet Java running on your own machine and prove that a program you wrote executes on itNothing here is about programming yet. It is about having somewhere to put the work, knowing what you are installing, and getting a program to run — the four hours most beginners lose before writing a line.
4 steps
Show the 4 steps
  • Create the project you are going to build

    Create the public project where your Student Management System will live, and get back the link you will use for the rest of this journey.

  • What Java is and what runs it

    Explain in your own words what the JDK, the JVM and bytecode each are, and which one you are about to install.

  • Install and prove the JDK

    Install the Java 21 JDK and confirm from a newly opened terminal that both `java --version` and `javac --version` report 21.

  • Your first program, compiled and run

    Write, compile and run a Java program that prints a student profile, and read the compiler’s message when you break it on purpose.

Programs remember and decideWrite a program that takes information from a person and reaches a different answer depending on what they gave itThe program stops being a fixed printout. By the end it takes something in from a person and reaches a different answer depending on what they typed.
4 steps
Show the 4 steps
  • Variables and types

    Replace every value written directly into your program with a named variable of an appropriate type.

  • Operators and expressions

    Compute the total and average of three marks from the marks themselves, and produce the integer-division bug on purpose before fixing it.

  • Reading input

    Take the student’s details from whoever runs the program, so nothing about the student is written into the code.

  • Decisions

    Turn an average into a letter grade using boundaries you have written down, and test every boundary value rather than the comfortable middles.

Programs repeat and organiseHandle many values and many people without repeating yourself, and keep a rule in exactly one placeOne student becomes many, and main stops being the whole program. The milestone ends by deliberately building the mess that milestone 4 exists to clear up.
4 steps
Show the 4 steps
  • Loops

    Read however many marks the user says there are, using a loop instead of a fixed number of questions.

  • Arrays

    Keep every mark rather than only the total, and hold several students’ names and averages in two arrays side by side.

  • Methods

    Move the calculating and printing out of `main` into named methods, so that changing one rule is a one-line edit.

  • Strings

    Print a report whose columns line up, and detect a name that is blank or nothing but spaces.

A student is a thing, not five variablesModel a real thing as an object, so that a relationship the program depends on cannot be broken rather than merely not being brokenObjects arrive as the answer to a problem the learner has already been bitten by. The milestone opens by breaking their own program on purpose and leaving it broken.
4 steps
Show the 4 steps
  • Why parallel arrays break

    Make your own program produce a confidently wrong report, and write down what is missing — without fixing it.

  • Classes, objects and fields

    Create a `Student` type and rebuild the program around it, so that the mismatch from the last step becomes impossible rather than merely avoided.

  • Constructors

    Make it impossible to create a `Student` without a name and an ID.

  • Encapsulation

    Make every field private, decide deliberately which ones may be changed from outside, and move the average calculation onto `Student`.

Objects that work togetherDesign two or more classes that work together, and add a new kind of thing without changing the code that uses itOne object was a container. Several objects with a relationship is a design. Kept strictly to what a beginner can hold — no patterns, no injection, no generics beyond the angle brackets they type.
3 steps
Show the 3 steps
  • Inheritance

    Move what every person in the system has into a `Person` class, and decide what belongs only to a student.

  • Polymorphism and abstraction

    Print a directory of every person in the system with one loop, without any code asking what kind of person it is holding.

  • Collections

    Replace the fixed array of students with a list that grows, add lookup by ID that does not search, and give the collection one owner.

Find out why it is wrongWork out why a program you did not write is wrong, and repair it with the smallest change that addresses the causeEverything so far has been code the learner wrote, working the way they intended. Here they are handed someone else’s broken program — which is what most of the job actually is.
2 steps
Show the 2 steps
  • When Java throws

    Obtain the supplied broken program, confirm you have the right version, and for each of three crashes name the exception, the file, the line and the value responsible — changing no code.

  • Diagnose and fix a supplied broken SMS

    Find the actual cause of four faults, fix each with the smallest change that addresses the cause, and explain why each fix is right.

A system you can explainAssemble a working application and defend the decisions behind its design against the alternatives you rejectedNothing new is taught. Everything is assembled, and then defended — because a beginner who can say why they built it that way has learned something a beginner who merely finished has not.
3 steps
Show the 3 steps
  • Design the menu loop

    Build the shell the application runs in: a menu that repeats until the user chooses to leave, and survives anything typed at it.

  • Build the complete CRUD + results

    Fill in every menu option against the service, refusing bad input with a message the user can act on, without ever losing their place.

  • Explain and defend the design

    Write a design document naming each class’s responsibility, defending three decisions against the alternatives you rejected, and stating one real limitation.

How the work is verified

  1. ReadThe context you need for this step, and why it matters. Never more than that.
  2. BuildYou produce something real. The work is yours, in your own repository.
  3. SubmitYou send it, with a note on what you chose and what you were unsure about.
  4. ReviewA senior engineer reads it and responds. They may ask for changes — that is the normal path through engineering review, not a failure.
  5. VerifiedThe capability is confirmed, it goes on your record, and the next step opens.

How you want to work

You choose when you start. Both cover the same journey and the same definition of done.

Mentor guidedReviewed by a person

A senior engineer is assigned to you. They read every submission, respond in writing, and decide when a capability is verified. Expect to be asked for changes.

Self pacedVerified by you

You work through the same journey and verify your own work against the same definition of done. Nothing is submitted to anyone, and nothing waits on anyone.

What you end up with

Counted from this journey, not described in general.

A working Java application you wrote yourself — students, marks, grades and a menu — plus a written defence of why it is built the way it is.Built by you, in your own repository.
7 verified capabilitiesEach one confirmed against its definition of done, with the name of whoever confirmed it. There is no certificate. The work is the credential.

Ready to start Java Foundation?

You will choose how you want to work on the next screen. Nothing starts until you confirm it. You can run several journeys at once, and each one is mentor-guided or self-paced on its own.

Start this journey