Sefism Programming Foundations Roadmap

What this roadmap is

Programming foundations is Sefism's starting roadmap for someone learning to code from zero, or self-taught with gaps. It is built to produce code a team can trust, not just code that runs. In six stages it covers one language learnt properly, the terminal and Git, what happens below your code, data structures and Big-O, object-oriented design and clean code, and finally shipping real projects.

By the end you should 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

Who it suits, and who should start elsewhere

It suits complete beginners, students whose first programming course went too fast, career switchers, and self-taught developers who can follow tutorials but cannot yet build alone.

If you already write a few hundred lines comfortably and want problem solving, go straight to DSA and problem solving. If you are a university student and want a plan that runs alongside your degree, University to job-ready is a better fit. If you already know you want to build for the web, finish the first two stages here and then move to Frontend development or Backend development.

Editions, prerequisites and time

You pick one language: Python (the default, the gentlest start and used everywhere), JavaScript, Java, C++ or C#. The stages are the same, while topics, recommended material and project ideas follow your language.

No prior experience is needed. You do need a computer you can install things on and the patience to type every example yourself.

The estimate is about 305 hours across 6 stages:

• A student with 10 to 12 hours a week finishes in roughly 27 weeks. A good week: three sessions of 2 to 3 hours writing small programs, plus one session reading and fixing your own earlier code.
• Someone working full time with about 5 hours a week should plan for around 61 weeks, a little over a year. Two weekday evenings and a weekend morning work well. The first stage alone is about 16 weeks at this pace, so do not judge your progress by the first month.

Stage by stage

1. Your first language (80 hours)

Variables, types and input, strings, conditionals and loops, functions, parameters and scope, reading tracebacks and debugging, the core collections (lists, dictionaries and sets in Python), references, mutability and copying, exceptions, and modules and files. The exact topics follow your language. Milestone: a 150-line command-line program, such as a quiz or a budget tracker, using functions, collections, file reading and error handling, written without a tutorial. The advice is blunt: pick one language and do not switch for three months.

2. Command line and Git (20 hours)

Navigating files in the shell, status, add, diff and commit, what to commit and .gitignore, branches and merging, merge conflicts, clone, fetch, pull and push, pull requests on GitHub, and stash, log and undoing mistakes. Milestone: every program you have written in a GitHub repository with meaningful commit messages, and one pull request opened, reviewed and merged from a feature branch.

3. How computers run your code (45 hours)

Enough of what happens below your code that memory and number bugs stop surprising you: binary, bits and bytes, ASCII, Unicode and UTF-8, integer overflow, floating point, how a CPU runs a program, compiled versus interpreted code, the stack and the heap, what happens when you pass a value to a function, and processes and the operating system. Milestone: explain in writing why 0.1 + 0.2 is not exactly 0.3, and what happens in memory when you pass a list to a function, and finish CS50x weeks 0 to 2 and week 4.

4. Data structures and Big-O (60 hours)

Big-O time complexity, arrays and dynamic arrays, linked lists, stacks and queues, hash maps and sets, recursion, searching and sorting, space complexity, and a first look at trees (with graphs optional). Milestone: implement a stack, a queue and a hash map from scratch, state the Big-O of each operation, and solve 30 easy array and hash map problems you can explain aloud. The roadmap is clear that 30 problems you understand beat 150 you copied.

5. Object-oriented design and clean code (40 hours)

Classes, objects and encapsulation, composition, inheritance and interfaces, naming and small functions, separation of concerns, DRY, KISS and YAGNI, unit tests and edge cases, test-driven development, code smells and refactoring, comments, docstrings and READMEs, with SOLID as optional review questions. Milestone: refactor an earlier program into separate input, logic and output modules, remove the duplication, write unit tests for the core logic first, and add a README.

6. Build and ship your first projects (60 hours)

Turning skills into finished, shareable work: scoping a small project, managing dependencies (virtual environments and pip in Python), files and JSON, calling a public API, configuration and secrets, tests, a README and a short demo, and publishing on GitHub. Milestone: two projects on GitHub that solve a problem you or someone you know actually has, each with a README, tests for the core logic, a clean commit history and a two-minute demo video or GIF.

Projects that fit

The roadmap suggests project ideas by edition. A few of them:

• Plain-text ledger with reports and tests, in any of the five languages and small enough to finish
• Adaptive study planner with spaced repetition for Python
• Household meal planner with food waste reduction for JavaScript
• Course registration engine with waitlists for Java and C#
• Interpreter and type checker for a small language, a stretch after all six stages

How it works on Sefism

Everything on Sefism is free to learn from, and this roadmap is currently free to add as well. The public page at Programming foundations shows every stage open in every language edition, with its topics, milestones and recommended material.

Adding it to your dashboard costs no credits and does not use up your free first roadmap, so that stays available for another one. Once you add it, it stays yours. On your dashboard you can:

• tick stages off and track your progress, at a pace set by the hours you have each week
• keep the companion Programming foundations cheat sheet, which comes with the roadmap
• ask Tauseef a question about any stage, or book a 1:1 session if you want to talk your plan through

If you are new, create a free account first.

Every topic comes with a short self-check question and an AI tutor prompt. The roadmap's rule for AI is consistent: use it to explain an error or quiz you, never to write the logic you are trying to learn.

The companion cheat sheet

The Programming foundations cheat sheet follows the same ground: language basics, collections and errors, a chapter of essentials for your language, the command line and Git, how computers run your code, data structures, design and clean code, testing and shipping projects. Read the matching chapter after each stage.

Related on Sefism

• Which programming language to learn first
• Should I learn Python or JavaScript first?
• I can follow tutorials but cannot build anything alone
• How to learn Git and GitHub properly
• What to do when you are stuck learning to code
• CS50: Introduction to Computer Science and The Missing Semester of Your CS Education, both recommended inside the stages
• Next roadmaps: Linux, terminal and Git for deeper tooling, and Software design and clean code for design

What you can do afterwards

You can start a program from an empty folder, keep it in Git, test the parts that matter, and explain what it costs and why it is organised the way it is. That is the base every other Sefism roadmap assumes.

Frequently asked questions

How long does it take to learn programming from scratch? This roadmap estimates about 305 hours. At 10 to 12 hours a week that is roughly 27 weeks; at 5 hours a week, a little over a year.

Which language should I learn first? Python is the default because it is the gentlest start and is used everywhere. Choose JavaScript if you want to build for the web, Java or C++ if your degree uses them, or C# for .NET and Unity.

Why does a beginner roadmap include how computers work? Because bugs about memory, copying and numbers (such as 0.1 + 0.2) stop being mysteries once you have seen what happens underneath. The stage asks for understanding, not hardware engineering.

Can I use AI tools while learning? For explaining errors and quizzing yourself, yes. The roadmap suggests keeping code completions off while you learn your first language, and turning them on for boilerplate in projects.