Operating Systems Study Plan: A Practical 4-Week Method

An operating systems study plan works best when it follows your course syllabus and makes you practise explaining system behaviour, not just recalling definitions. Use the four-week schedule below as a starting point: six sessions a week, mostly one hour each. If your course covers a different set of topics, replace the examples with the corresponding syllabus sections rather than adding more study hours.

Before starting, collect your lecture slides, textbook notes, assignments and any past questions your course has released. Check the official course outline for the examinable topics and assessment requirements; operating systems courses differ in coverage and assessment format. Keep one list of topics, one list of errors from practice, and a short queue of facts or explanations to revisit.

Set up a weekly routine

Aim for six sessions of 60 minutes each. That is six hours per week, including practice and review. If you can only study three hours, keep the same sequence and use three 60-minute sessions; do not try to compress six sessions into one long sitting.

Use a consistent structure for most sessions:

• 5 minutes: retrieve what you remember from the previous session without looking at notes.
• 20 minutes: study one small section from your own course material.
• 25 minutes: answer a problem, draw a system diagram, or explain a mechanism from memory.
• 10 minutes: check against your notes, correct errors and schedule what to review.

For calculation or tracing topics, spend more of the practice block working through a problem. For conceptual topics, write a short explanation with a concrete example. Record an error precisely: “I confused waiting time with turnaround time” is more useful than “scheduling is weak.”

A due queue makes the review workload visible across several topic boards. In MySummaries, a queue for an operating systems course could look like this:

Do the due reviews before starting new material, but set a time limit: around 10–15 minutes is enough for this sample workload. If the queue regularly takes longer, reduce the number of new cards you create or split a large topic into smaller boards.

Build one board from your course material

Make a board for each major syllabus area, not one board for every lecture. Put the key explanations, diagrams, formulas and distinctions from your own notes on it. A useful section should help answer a question such as “How does a context switch affect process state?” or “What changes when a page fault occurs?”

Keep the source material close. When a diagram or definition is important, include enough detail to explain it without relying on a vague heading. For each section, check that you can state the mechanism, identify the relevant trade-off, and work through a small example. In MySummaries, a board on processes and scheduling might contain sections like these:

After each session, add only the details you missed or could not explain. Then create a small number of questions from those details. For example, a card should ask for one scheduling measure or one consequence of changing the time quantum, not “Explain scheduling.”

Week 1: Processes, threads and scheduling

The aim this week is to explain how execution is represented and compare basic scheduling choices. Use the first session to map your syllabus and diagnose your starting point: list the topics, then try a short question or explain a process state diagram without notes.

1. Session 1 — 60 minutes: make the topic list; test your recall of process states, processes and threads.
2. Session 2 — 60 minutes: study process creation, termination, system calls and context switching as covered in your course.
3. Session 3 — 60 minutes: compare FCFS, shortest-job-first or shortest-remaining-time, priority scheduling and round robin where these appear in your syllabus. Work through a scheduling trace and calculate waiting and turnaround times.
4. Session 4 — 60 minutes: study threads and the distinction between user-level and kernel-level threads if taught. Explain what is shared between threads in one process.
5. Session 5 — 60 minutes: answer a mixed set of scheduling and process questions. Show the steps in any calculations.
6. Session 6 — 60 minutes: review due cards and rewrite your two least clear explanations from memory, then check them against your notes.

For a trace, make a table with arrival time, burst time, queue or priority, and completion time as applicable. State the scheduling assumptions you use. This prevents a correct method from producing an unclear answer.

Week 2: Synchronisation and deadlocks

The goal is to reason about shared state and explain why a particular operation is safe or unsafe. Don’t stop at naming a semaphore or mutex: trace what happens when two threads interleave.

1. Session 1 — 60 minutes: identify race conditions, critical sections and the requirements for mutual exclusion, progress and bounded waiting as defined in your course.
2. Session 2 — 60 minutes: trace mutex or semaphore operations through a short producer–consumer or readers–writers example from your notes.
3. Session 3 — 60 minutes: practise interleavings. Write down the shared variables and show how each thread changes them.
4. Session 4 — 60 minutes: learn the four deadlock conditions: mutual exclusion, hold and wait, no pre-emption and circular wait. For each, give a concrete example or prevention strategy.
5. Session 5 — 60 minutes: distinguish deadlock prevention, avoidance, detection and recovery using the terminology in your course material.
6. Session 6 — 60 minutes: answer one unfamiliar concurrency problem, then review and correct the exact step where your reasoning failed.

Use a short trace rather than a long summary to check understanding. If you cannot explain why a particular interleaving causes lost updates or deadlock, return to the relevant lecture example and annotate each operation.

Week 3: Memory and virtual memory

Focus on translating addresses and tracing what the operating system does when memory is not immediately available. Follow your course’s model: address translation details vary between systems and syllabuses.

1. Session 1 — 60 minutes: distinguish logical or virtual addresses from physical addresses; review address spaces and protection.
2. Session 2 — 60 minutes: practise paging calculations from your course. Label page number, offset, frame number and any address-width assumptions.
3. Session 3 — 60 minutes: trace a page-table lookup and explain the role of a translation lookaside buffer (TLB), if included in your material.
4. Session 4 — 60 minutes: trace a page fault from detection through handling and resumption, using the sequence taught in your course.
5. Session 5 — 60 minutes: compare the page-replacement algorithms in your syllabus by running them on the same reference string and counting faults.
6. Session 6 — 60 minutes: complete a timed mixed set on translation, paging and replacement; check units and intermediate steps.

For each calculation, write the rule before substituting values. For each page-replacement trace, show the frame contents after every reference. This makes it easier to spot whether an error came from the algorithm or from arithmetic.

Week 4: Storage, file systems and course-wide practice

Use this week to connect mechanisms and find gaps. The exact storage and file-system topics depend on your course, so follow its outline rather than assuming every listed topic is examinable.

1. Session 1 — 60 minutes: review file names, metadata, directories and file allocation methods that appear in your notes.
2. Session 2 — 60 minutes: trace a file operation through the interfaces and data structures covered by your course; distinguish file-system work from device-level I/O where relevant.
3. Session 3 — 60 minutes: study disk scheduling, RAID or journalling only if they are on your syllabus. Practise the specific comparisons or traces your course uses.
4. Session 4 — 60 minutes: complete a mixed practice set under a time limit you choose. Include questions from at least three topic areas.
5. Session 5 — 60 minutes: review every lost mark. Sort errors into missing knowledge, incorrect tracing or calculation, and incomplete explanation.
6. Session 6 — 60 minutes: revisit the weakest two sections, then explain one mechanism from each without notes.

Use a picker to choose the next short lecture or review activity based on weak cards and practice results. In MySummaries, an operating systems picker could prioritise a difficult memory section over one you already recall reliably:

Treat the heat as a prompt to investigate, not a verdict. If a section is marked weak, identify the underlying error and attempt a fresh problem after reviewing it. If you get a card right by guessing, keep it in rotation until you can explain the answer.

Use results to choose what to study next

At the end of each week, rank your sections by accuracy and by how often errors recur. A low score in a topic you have practised several times needs focused work; a single mistake in a new section may simply need another attempt. Track your own practice data, not presumed exam weighting.

In MySummaries, a weak-section report for one candidate’s practice could look like this:

Use the report to choose one weak section for the next week’s first session. Relearn the relevant part of your notes, solve a new example without looking, and record whether the same error returns. Keep the other sessions moving through the syllabus so that one difficult topic does not displace everything else.

How MySummaries helps

MySummaries turns your PDFs, slides and photographed notes into topic boards, then uses those boards for spaced-repetition cards, written practice and short audio reviews. For this plan, the practical use is to keep course material, due reviews and weak-section practice connected, while you decide which syllabus topic to work on next.