Sefism CS Core Subjects Roadmap

What this roadmap is

CS core subjects is Sefism's roadmap through the subjects a computer science degree examines and a software job quietly depends on: how a computer runs a program, object-oriented programming and design, operating systems, computer networks, databases, software engineering and the theory worth knowing, finished with a systems project that ties them together.

Its aim is understanding you can show in working code, not memorised answers. By the end you should be able to:

• explain what happens from source code to a running process: compilation, memory layout, the CPU cycle and the operating system calls in between
• design a small program with classes, interfaces and composition, and justify each choice with a named principle
• trace a web request through DNS, TCP, TLS and HTTP, and a database write through a transaction, an index and a commit
• build a shell, a socket server or a tiny database that shows your understanding

Who it suits, and who should start elsewhere

It suits CS and software engineering students taking these courses, students who passed them but never really understood them, and self-taught developers filling the same gaps.

If you cannot yet write a small program comfortably, do Programming foundations first. If you want the whole university journey, including projects, experience and applications, University to job-ready is the broader plan and points here for depth. If databases are your main interest, the SQL and databases roadmap covers queries in far more depth than stage 5 here.

Prerequisites and time

You should be able to write and run small programs in at least one language. Some stages use C or Python for their exercises.

The estimate is about 216 hours across 8 stages. There is one edition for everyone:

• A student with 10 to 12 hours a week finishes in roughly 22 weeks. The best rhythm is to follow the stage that matches the course you are taking this semester: read the book chapter, then run the idea in code the same week.
• Someone working full time with about 5 hours a week should plan for around 46 weeks. One evening for reading, one for running the idea in code, and a weekend session for the checklist.

Stage by stage

1. How a computer runs a program (20 hours)

Binary, hexadecimal and integers, text encodings and floating point, from logic gates to a CPU, the fetch, decode, execute cycle, the memory hierarchy and caches, the stack and the heap, and compilers, interpreters and bytecode. Milestone: a one-page diagram, in your own words, that follows a small C or Python program from source file to running process. The advice suggests building a few chips in Nand2Tetris, because nothing else makes the layers click as fast.

2. Object-oriented programming and design (24 hours)

Classes, objects and responsibilities, encapsulation, inheritance and when not to use it, polymorphism, abstraction, interfaces and abstract classes, composition over inheritance, SOLID at an introductory level, and a first handful of design patterns. Milestone: a small console program, such as a library or parking lot system, with a class diagram and a note pointing to where you used encapsulation, polymorphism, composition and at least two SOLID principles.

3. Operating systems (32 hours)

What an operating system does, processes, threads, concurrency versus parallelism, CPU scheduling, memory management and virtual memory, race conditions, locks and semaphores, deadlock, and file systems. Milestone: a tested C or Python program that starts processes, shares a counter between threads, shows a race condition, fixes it with a lock, and explains each result. The stage recommends reading OSTEP chapter by chapter alongside your course.

4. Computer networks (28 hours)

The OSI and TCP/IP models, IP addresses, subnets, routing and NAT, TCP and UDP, ports and sockets, DNS, HTTP, HTTPS and TLS, and what happens when you type a URL. Milestone: a TCP echo server and client written with sockets, plus a written walkthrough of loading one real HTTPS page, backed by dig and curl -v output you captured yourself.

5. Databases: theory and internals (26 hours)

The relational model, keys and constraints, entity relationship modelling, normalisation, transactions and ACID, isolation levels and concurrency control, indexes and B-trees, and how a query runs. Milestone: a normalised schema for a real system with an ER diagram and constraints, one transaction that must be atomic, and one slow query sped up with an index, shown with before and after EXPLAIN output.

6. Software engineering (20 hours)

Life cycles, requirements, the UML diagrams that matter, version control concepts, testing levels, designing test cases, and code review, refactoring and technical debt. Milestone: a small project with a requirements page, a use case, class and sequence diagram in its README, a clean Git history with pull requests, and unit and integration tests that run with one command.

7. Theory worth knowing (26 hours)

Complexity and Big O, logic and proofs, sets, functions and relations, graphs and trees, counting and probability, finite automata and regular expressions, grammars and how compilers work, and the limits of computation. Milestone: a notebook of worked problems: ten complexity analyses, three induction proofs, five counting problems, two automata with test strings, and a one-page explanation of the compiler pipeline and the halting problem.

8. Tie it together with projects (40 hours)

Learning a subject by building it, with three project options: a Unix shell, an HTTP server from sockets, or a tiny database. Also tracing one request end to end, reading man pages, RFCs and documentation, and using past exams to check understanding. Milestone: one finished systems project in a public repository with a README explaining the design, the concepts it uses and its limits, plus an end-to-end trace of one request in your own app. Pick the shell if operating systems was hardest, the server if networks was, the database if transactions and indexes were.

Projects that fit

• Unix shell with pipes, redirection and job control: fork, exec, pipes, file descriptors and signals
• HTTP server from raw sockets with a load test report: networks and concurrency together
• Crash-safe key-value store with a write-ahead log: indexes, transactions and crash recovery made concrete
• Course registration engine with waitlists: object-oriented design and testing with real rules

How it works on Sefism

Everything on Sefism is free to learn from. The public page at CS core subjects shows the full stage list for the whole roadmap, with the first two stages open: their topics, milestones and recommended material. Later stages show their title, summary, hours and topic count.

To open every stage, add the roadmap to your dashboard. Adding a roadmap uses credits, new members get starting credits when they join, and your first roadmap is free. Once it is on your dashboard you can:

• open every stage, its topics, checks and recommended material
• tick stages off and track your progress, at a pace set by the hours you have each week
• keep the companion CS core subjects 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. Credits are there so the platform goes to people who are actually learning, and if you run out while learning seriously, you can ask for more.

Every topic has a short check question and an AI tutor prompt. The roadmap's tools section recommends pasting those prompts to be quizzed one question at a time, never to have answers written for you, and checking any AI answer against your textbook.

The companion cheat sheet

The CS core subjects cheat sheet has one chapter per stage and 72 concepts. Use it the night before an exam to check you can explain each idea in your own words, then go back to the roadmap topic for anything you cannot.

Related on Sefism

• Graduating with theory but cannot build software
• BSCS vs BSSE vs BS AI
• Ten books that fill the gap a CS degree leaves
• Operating Systems: Three Easy Pieces, Nand to Tetris and Beej's Guide to Network Programming, all recommended in the stages
• Crafting Interpreters, for anyone who enjoyed the theory stage

What you can do afterwards

Explain how your code actually runs, from the CPU to the network to the database, and back that up with a working systems project. That understanding is what makes later roadmaps such as Backend development and DevOps and cloud easier to follow.

Frequently asked questions

Which CS subjects matter most for a software job? All of them show up somewhere. The roadmap is direct about networks: every web, mobile and backend job depends on that stage. Operating systems explains slow programs and concurrency bugs, and databases explain why data stays correct under real use.

Do I need to know C? Stage 1 and stage 3 use C or Python for their exercises. You can follow most of the roadmap in Python, though reading a little C helps with memory.

How long does it take to learn the CS fundamentals? About 216 hours: roughly 22 weeks at 10 to 12 hours a week, or around 46 weeks at 5.

I have exams soon. Is this the right tool? Use the cheat sheet for short-term revision. The roadmap is for understanding the subjects properly over a semester.