Skip to content

Start Here

Welcome to Object-Oriented Programming using C++. This page is the guided route into the course. Work through it in order and you will have a working compiler, a program you have compiled yourself, and a plan for finishing the course — in about an hour.

If you would rather jump straight in, the short version is: install a compiler, then open Module 1.

If you have never studied on your own before, read How You Will Learn first. It explains the eight levels of difficulty the course uses, the predict-run-explain loop that runs through every module, and how to tell whether you have actually understood something — which is the hardest part of learning without a teacher.

The five steps

Step 1 — Check the prerequisites

Prerequisites lists what the course assumes you already know, and gives a short refresher of the one topic students most often arrive without: how references and pointers differ.

Read this even if you feel confident. It takes ten minutes, and it tells you exactly what is expected of you before Module 1.

Step 2 — Get a working toolchain

Set Up Your Toolchain covers three routes:

  1. Windows — MSYS2/MinGW-w64, WSL, or a single-file compiler bundle.
  2. Linux and macOS — your distribution's package manager, or the Xcode command-line tools.
  3. No installation at all — an online compiler in your browser, which is enough to complete most of the course.

There is nothing to configure and no build system to learn yet. The whole course compiles with one command.

Step 3 — Compile and run a real program

Your First Program walks you through compiling examples/playground/hello.cpp, understanding each line of the output, and then deliberately breaking the program to see what a compiler error looks like.

That last part matters more than it sounds. Learning to make mistakes on purpose in a program you control is what makes errors stop being frightening.

Step 4 — Learn to read compiler errors

Reading Compiler Errors explains the anatomy of a compiler message and gives a catalogue of the errors you will meet most often, each with its cause and its fix.

This is the highest-value page in the whole "Start Here" section. Beginners usually lose more time to unreadable error output than to the language itself.

Step 5 — Choose a pace

Study Plan gives three schedules:

Plan Length For whom
Full semester 16 weeks Following a university course, one module per week
Fast track 6–8 weeks You already program in another language
Revision 1–3 weeks Exams are close; consolidate with quizzes and cheat sheets

Each plan includes a weekly checklist, so "finished" is never ambiguous.

How the course is built

Knowing the structure saves a lot of hunting around.

Concepts live in the modules. All sixteen follow the same pattern: concepts and explanations, worked examples, code examples, exercises, a lab, challenge problems, self-assessment, a summary, and further reading. Same order every time, so you always know where to look — see All Modules, and How You Will Learn for what each section is for.

Practice lives alongside it. Labs build one system across all sixteen modules; exercises come in three tiers; projects are the larger pieces of work.

Checking yourself is built in. Every module has a quiz; there are practice assessments in exam style.

Reference is always available. Keep the cheat sheets open while you code, and use the glossary whenever a term is not quite clear.

Six habits that make self-study work

  1. Type the code. Do not copy and paste examples. Typing is where you notice the semicolons, the const, and the std::.
  2. Predict before you run. Before executing a program, write down what you expect it to print. Being wrong is the most useful thing that can happen.
  3. Break things deliberately. Change a value, remove a virtual, remove a const. Watch what breaks. That is how you learn what each keyword is for.
  4. Attempt before checking. Read an exercise, attempt it, and only then look at the solution. Reading a solution feels like learning and is not.
  5. Do the labs in order. They are cumulative; skipping a lab breaks the next one.
  6. Keep a mistakes file. Every bug you fix goes in it, in one line. It will become the most useful document you own.

What to do when you get stuck

Situation Where to look
The compiler refuses to build your file Reading Compiler Errors
The program builds but crashes or misbehaves The "Common mistakes" section of the current module; the glossary for the relevant term
You do not understand a term Glossary
You cannot remember syntax Cheat sheets
The concept itself is still unclear The module's Further reading section, and Further Reading
Something in the course looks wrong Open an issue — reporting it genuinely helps

Ready

You have read the map. Now do the first real thing: Set Up Your Toolchain.