Sefism is free for learners. We are here to help you grow, one step at a time.Join for free
Sefism.

Roadmap · Foundations

Programming foundations (C++)

Free

For someone starting from zero, or self-taught with gaps, who wants to write code a team can trust. By the end you write, test and ship small programs in Python, JavaScript, Java, C++ or C#, use Git and the terminal daily, and can reason about memory, data structures and the cost of your code.

Curated by Tauseef Fayyaz6 stages, 52 topics~14 months at a few hours a week
Start the roadmapSign up to track your progress

By the end, you will be able to

  • Write and debug a program of a few hundred lines in your language without a tutorial open
  • Use the terminal, Git and GitHub for commits, branches, pull requests and recovering from mistakes
  • Choose a fitting data structure for a problem and state the Big-O of your solution
  • Refactor messy code into small, well-named units with unit tests around the core logic
  • Ship two documented, tested projects on GitHub that you can walk someone through line by line

The path

6 stages, in the order to learn them. Open one to start.

  1. 1Your first languageLearn modern C++ properly: types, control flow, functions, references, std::vector and std::string, and how compiling works. C++ shows you what the machine is doing, which makes it slower to learn and very rewarding.8 topics · ~4 months
    1. 1Compiling, linking and warningsC++ source code becomes a program in two steps: compiling and linking.
    2. 2Types, variables and inputC++ is statically typed and close to the hardware, so types have fixed sizes and real limits.
    3. 3Conditionals and loopsConditionals (if, else if and else) choose between paths.
    4. 4Functions and referencesA function has a return type and typed parameters, and it must be declared before it is called.
    5. 5std::vector, std::string and std::mapThe standard library gives you safe containers that grow as needed, so you rarely need raw arrays.
    6. 6Reading files and parsing inputMost real programs load data from files and then need parsing: turning lines of text into numbers and fields.
    7. 7Header files and multiple source filesOnce a program grows, split it into several files.
    8. 8Undefined behaviour and debuggingUndefined behaviour (UB) is code that the C++ standard gives no meaning to, so anything can happen.
    8 in this stageOpen this stage
  2. 2Command line and GitGet comfortable in the terminal and put every piece of code under version control. This is the tooling every team assumes on day one, and it protects your own work from now on.8 topics · ~4 weeks
    1. 1Navigating files in the shellThe terminal is a text window where you control your computer by typing commands, and every developer tool assumes you can use it.
    2. 2status, add, diff and commitGit records snapshots of your project called commits.
    3. 3What to commit and .gitignoreA repository should hold your source code and the files needed to build it.
    4. 4Branches and mergingA branch is a movable label pointing at a commit.
    5. 5Merge conflictsA merge conflict happens when two branches changed the same lines and Git cannot choose for you.
    6. 6clone, fetch, pull and pushA remote is another copy of the repository, usually on GitHub.
    7. 7Pull requests on GitHubA pull request asks to merge one branch into another on GitHub.
    8. 8stash, log and undoing mistakesUndoing mistakes is a skill of its own: everyone makes Git mistakes, and the trick is picking the right undo.
    8 in this stageOpen this stage
  3. 3How computers run your codeUnderstand what happens below your code: bits, memory, the CPU, compilers and interpreters, and the operating system. Enough that bugs about memory and numbers stop surprising you.9 topics · ~2 months
    1. 1Binary, bits and bytesComputers store everything as bits, ones and zeros.
    2. 2Text encodings: ASCII, Unicode and UTF-8Text is stored as numbers too.
    3. 3Integers and overflowIn most languages, integers are stored in a fixed number of bits.
    4. 4Floating point numbersDecimals are usually stored as IEEE 754 floating point numbers: a sign, an exponent and a binary fraction, 64 bits in a double.
    5. 5How a CPU runs a programA CPU, the chip that runs your code, repeats one cycle billions of times a second.
    6. 6Compiled vs interpreted codeThe CPU only understands machine code, so something must translate the code you write.
    7. 7Memory: the stack and the heapA running program uses two main areas of memory.
    8. 8What happens when you pass a value to a functionThis connects memory to code you write every day.
    9. 9Processes and the operating systemThe operating system (OS) sits between your program and the hardware.
    9 in this stageOpen this stage
  4. 4Data structures and Big-OLearn the handful of structures almost all code is built from, and how to reason about the time and memory a solution costs. This is what separates code that works from code that still works with a million rows.10 topics · ~3 months
    1. 1Big-O time complexityBig-O describes time complexity: how the work your code does grows as its input gets bigger, ignoring fixed constants.
    2. 2Arrays and dynamic arraysAn array stores items side by side in memory, in one contiguous block.
    3. 3Linked listsA linked list stores each item in its own node, together with a pointer to the next node.
    4. 4Stacks and queuesA stack is last in, first out (LIFO): you push and pop at the same end, like a pile of plates.
    5. 5Hash maps and setsA hash map stores key and value pairs.
    6. 6RecursionA recursive function solves a problem by calling itself on a smaller version of the same problem.
    7. 7Searching and sortingSearching an unsorted list means checking every item, which is O(n) in Big-O notation.
    8. 8Space complexityBig-O measures memory as well as time.
    9. 9Trees at a first lookA tree is a set of nodes (items) where each node has children and exactly one parent.
    10. 10Graphs at a first lookA graph is a set of nodes joined by edges (links), with no single root.
    10 in this stageOpen this stage
  5. 5Object-oriented design and clean codeOrganise programs so they stay readable as they grow: classes where they help, separation of concerns, small functions, tests first on the logic that matters, and documentation someone else can follow.10 topics · ~2 months
    1. 1Classes, objects and encapsulationA class bundles data with the behaviour that changes it, and an object is one instance of that class.
    2. 2Composition, inheritance and interfacesThere are two main ways to reuse behaviour between classes.
    3. 3Naming and small functionsCode is read far more often than it is written, so readability matters, and names do most of the explaining.
    4. 4Separation of concernsSeparation of concerns means each part of a program handles one kind of job.
    5. 5DRY, KISS and YAGNIThese are three short principles that work best as questions while refactoring (tidying code without changing what it does).
    6. 6Unit tests and edge casesA unit test calls one small piece of code with known inputs and checks the output automatically.
    7. 7Test-driven developmentTest-driven development flips the usual order.
    8. 8Code smells and refactoringRefactoring means changing the structure of code without changing what it does.
    9. 9Comments, docstrings and READMEsGood code explains what it does through its names.
    10. 10SOLID as review questionsSOLID is five design principles for object-oriented code, the kind built from classes.
    10 in this stageOpen this stage
  6. 6Build and ship your first projectsTurn skills into finished, shareable work: small programs that solve a real problem, with dependencies managed, tests on the core logic, a README and a history of honest commits.7 topics · ~3 months
    1. 1Scoping a small projectMost first projects fail because they are too big, not because they are too hard.
    2. 2CMake buildsOnce a project has several files and a test library, typing g++ commands by hand stops working well.
    3. 3Files and parsing inputA C++ command-line tool usually reads a text file, such as a CSV of transactions, and turns each line into a struct (a small record type).
    4. 4Command-line argumentsA tool that others can use takes its input from the command line, not from paths written into the code.
    5. 5Tests with GoogleTestGoogleTest is the most common C++ test framework.
    6. 6README with build stepsThe README is your project documentation, and for a C++ project its hardest job is explaining the build.
    7. 7Publishing on GitHubPublishing is the last step of the project, not an afterthought.
    7 in this stageOpen this stage

Related on Sefism

Picked from the other libraries by shared topics.

Best practices

See all

Checklists

See all

Project structures

See all

Career questions

See all

Cheat sheets

See all

Roadmaps

See all
Work with me

Stuck on something specific?

Writing only gets you so far. If you want an answer to your situation rather than the general case, book a session and we will work through it together. Sessions are free for approved Sefism members, and a few slots open each week.

  • 1:1 Mentorship
  • Fresh Graduate Mentorship
  • Career Guidance
Book a free sessionSee all services

Brand deals, promos and partnerships: tauseeffayyaz@gmail.com