Modules & lessons
Five modules, thirteen units, and eighty-one lessons. Every lesson follows the same eleven-part structure so the format is always predictable.
Third-Year Core · Asynchronous · Self-Paced
COMP 3150 / CMIS 3150 Operating Systems
Principles, design, implementation, and evaluation of modern operating systems. Examine process and thread management, scheduling, synchronization, deadlocks, memory and virtual memory, file systems, storage, security, virtualization, and cloud operating systems — then build and measure these mechanisms yourself in Linux-based laboratories.
5
ModulesFoundations to cloud
13
UnitsMeasurable outcomes
81
Lessons11-part structure
12
LaboratoriesLinux systems programming
13
QuizzesOne per unit
2
AssignmentsApplied programming
2
ExaminationsMidterm & final
13
DiscussionsUnit-level prompts
Course components
What the course consists of
Seven kinds of component work together. Each has its own page in the course hierarchy, and each is aligned to one or more of the eight course learning outcomes.
Laboratories
Twelve hands-on laboratories, one per major topic area, run in the supplied Linux VM. Each combines implementation, measurement, and analysis.
Quizzes
Thirteen unit-level quizzes, one per unit. Every quiz is available now, with full model answers for self-assessment.
Assignments
Two substantial programming assignments. Assignment 1 focuses on processes, threads, and synchronization; Assignment 2 builds an operating-system simulator.
Examinations
A midterm covering Modules 1–3, and a comprehensive final covering all thirteen units. Both papers include full instructor answer keys.
Final project
A substantial operating-system component with five project options, evaluated on design, functionality, depth, validation, documentation, and demonstration.
Discussions
Thirteen unit-level discussion activities with applied prompts. Each requires a substantive original post and replies to two classmates.
Getting started
Three starting paths
The course is complete: every module, laboratory, quiz, assignment, examination, project specification, and discussion is available now. Where you begin depends on your goals.
Path A · New student
- Lesson 1.0 — Set up the course VM
- Lesson 1.1 — What is an operating system?
- Work through Unit 1 and Unit 2 lessons in order
- Lab 1 — Linux Fundamentals
- Quiz — Unit 1 · Quiz — Unit 2
- Discussion 1 — What Is an OS?
Path B · Mid-course student
- Lesson 3.1 — Process Concept
- Complete the five lessons of Unit 3, then Units 4–7
- Labs 2–6 in sequence
- Assignment 1 — Parallel Log Analyzer
- Midterm Examination after Unit 9
Path C · Completing the course
- Finish Units 10–13 and Labs 9–12
- Assignment 2 — OS Simulator
- Final Project — proposal to demonstration
- Final Examination — comprehensive
- Complete all 13 discussion activities
The first thing to do
Whether you are new to the course or returning to it, complete Lesson 1.0 — Setting Up Your Course VM. It walks you through installing Ubuntu in a virtual machine, configuring the development toolchain, verifying the setup, and taking a baseline snapshot. Every other component in the course assumes you have completed it.
Course overview
What this course is about
An operating system is the layer of software that turns raw hardware into a usable, safe, and efficient machine. This course examines how that layer is designed, how its algorithms behave under load, and how its abstractions are implemented in a real kernel.
Description
This course introduces the principles, design, implementation, and evaluation of modern operating systems. Students examine process and thread management, scheduling, synchronization, deadlocks, memory management, virtual memory, file systems, storage management, security, virtualization, and cloud operating systems.
Through Linux-based laboratories and programming assignments, students gain practical experience implementing and analyzing operating-system mechanisms.
Prerequisites
- Introduction to Programming
- Object-Oriented Programming
- Data Structures and Algorithms
- Computer Organization and Architecture
Expected background
You should be comfortable writing and debugging programs in C or C++, reading assembly-level explanations of hardware behaviour, and working from the command line.
Delivery & workload
Fully online, asynchronous, and self-paced. All content — readings, worked examples, interactive activities, knowledge checks, laboratories, and assessments — is available from day one.
- 13 units across 5 modules
- 81 lessons with objectives and knowledge checks
- 12 laboratories using a supplied Linux VM
- 43 assessment components in total
- Estimated 8–10 hours per week over a 13-week term
Course learning outcomes
What you will be able to do
Every unit, lesson, laboratory, and assessment in this course maps back to one or more of the eight course learning outcomes below.
Foundations
- CLO1 — Explain operating-system concepts, services, and architectures.
- CLO2 — Explain process and thread management principles and mechanisms.
Mechanisms & analysis
- CLO3 — Analyze scheduling, synchronization, and deadlock solutions.
- CLO4 — Explain memory and virtual-memory management techniques.
- CLO5 — Explain file systems, storage systems, and I/O management.
Practice & modern systems
- CLO6 — Apply Linux systems-programming techniques and operating-system tools.
- CLO7 — Evaluate operating-system security, protection, virtualization, and cloud technologies.
- CLO8 — Design and implement software components related to operating-system functionality.
Curriculum
Five modules, thirteen units
The course moves from foundations, through the concurrency and memory core of operating systems, into storage, security, and modern virtualized and cloud environments.
01
2 Units · 10 Lessons
Operating System Foundations
What an operating system is, how it evolved, what services it provides, and how its architecture shapes everything above it.
Open Module 1
CLO1 · CLO6
02
5 Units · 30 Lessons
Processes and Concurrency
The heart of the course: process and thread abstractions, CPU scheduling, synchronization, and the deadlock problem.
Open Module 2
CLO2 · CLO3 · CLO6
03
2 Units · 13 Lessons
Memory Management
From the memory hierarchy and address binding to paging, page replacement, and the control of thrashing.
Open Module 3
CLO4 · CLO8
04
2 Units · 14 Lessons
Storage and I/O Systems
How persistent data and devices are organised: files, inodes, journaling, drivers, interrupts, DMA, RAID, and SSDs.
Open Module 4
CLO5 · CLO6
05
2 Units · 14 Lessons
Security, Virtualization & Modern Systems
Protection and access control, OS hardening, hypervisors, containers, orchestration, and cloud operating systems.
Open Module 5
CLO7 · CLO8
Laboratories
Twelve laboratories, one toolchain
Every laboratory runs in the supplied Linux virtual machine using GCC, Make, Git, GDB, and the POSIX API. Each laboratory combines implementation, measurement, and analysis, and produces source code plus a written report. All twelve are available now.
How the laboratories work
- Setup: each laboratory begins from a fresh checkout of its own Git repository under
~/comp3150/labs/. - Submission: source code, a lab report, and any captured output. Code must build with
gcc -Wall -Wextra -g. - Grading: each laboratory is graded on correctness, analysis, and write-up quality. The laboratory component is 15% of the final grade, distributed evenly across the twelve laboratories.
- Time budget: 3–5 hours per laboratory. Each is completed in the week following the related unit's lessons.
Before you begin any laboratory
Complete Lesson 1.0 — Setting
Up Your Course VM and Lesson
2.5 — Development Environment first. The laboratories assume the
toolchain is installed and that the workspace directory
~/comp3150/ exists.
Snapshot before each lab
Take a snapshot named before-lab-n before starting
each laboratory. If the lab goes badly, revert to the snapshot
and start over with a clean environment.
| Lab | Topic | Related unit | Status | Link |
|---|---|---|---|---|
| Lab 1 | Linux Fundamentals | Unit 2 | Available | Open Lab 1 → |
| Lab 2 | Process Management | Unit 3 | Available | Open Lab 2 → |
| Lab 3 | POSIX Threads | Unit 4 | Available | Open Lab 3 → |
| Lab 4 | Scheduling Simulation | Unit 5 | Available | Open Lab 4 → |
| Lab 5 | Synchronization | Unit 6 | Available | Open Lab 5 → |
| Lab 6 | Deadlock Analysis | Unit 7 | Available | Open Lab 6 → |
| Lab 7 | Memory Management | Unit 8 | Available | Open Lab 7 → |
| Lab 8 | Virtual Memory | Unit 9 | Available | Open Lab 8 → |
| Lab 9 | File Systems | Unit 10 | Available | Open Lab 9 → |
| Lab 10 | Storage Systems | Unit 11 | Available | Open Lab 10 → |
| Lab 11 | Security | Unit 12 | Available | Open Lab 11 → |
| Lab 12 | Containers and Virtualization | Unit 13 | Available | Open Lab 12 → |
Laboratory directory
The full laboratory directory, with all instructions, submission requirements, and grading rubrics, is at labs/index.html.
Assignments · 35%
Two substantial programming assignments
The two assignments are the largest individual programming tasks in the course before the final project. Each spans multiple weeks and draws on several units.
Assignment 1 — Parallel Log Analyzer
Design and implement a complete, concurrent log-analysis system that uses both processes and threads, communicates through pipes and shared memory, synchronises access to a bounded buffer with mutexes and condition variables, and shuts down gracefully on a signal. The assignment draws on every unit of Module 2.
- Weight: 15% of the final grade
- Issued: Week 5 · Due: Week 9
- Effort: 20–25 hours over 4 weeks
- CLOs: CLO2, CLO3, CLO6, CLO8
| Criterion | Weight |
|---|---|
| Process implementation | 15% |
| Thread implementation | 20% |
| Synchronization design | 25% |
| Correctness | 20% |
| Code quality | 10% |
| Technical report | 10% |
Assignment 2 — Operating-System Simulator
Design, implement, test, and analyse a discrete-event simulator for one operating-system subsystem. Choose from three options — CPU scheduler, virtual-memory manager, or file system — and build it end to end with rigorous testing and quantitative analysis.
- Weight: 20% of the final grade
- Issued: Week 9 · Due: Week 14
- Effort: 25–30 hours over 5 weeks
- CLOs: CLO3, CLO4, CLO5, CLO6, CLO8
| Criterion | Weight |
|---|---|
| Requirements coverage | 20% |
| Algorithm correctness | 25% |
| System design | 20% |
| Testing and validation | 15% |
| Documentation | 10% |
| Code quality | 10% |
Examinations
Midterm and comprehensive final
Both examination papers are complete, with full instructor answer keys, model answers, marking guides, and formula sheets. They may be used for proctored assessment or for self-study and review.
Midterm Examination
A two-hour, closed-book examination covering Modules 1–3 — foundations, concurrency, and memory. Four parts: multiple choice, short answer, problems, and design/analysis. Includes a full instructor answer key with model answers and a marking guide.
- Weight: 15% of the final grade
- Coverage: Modules 1–3 (Units 1–9)
- Duration: 2 hours · 100 marks
- CLOs: CLO1, CLO2, CLO3, CLO4
Final Examination
A three-hour comprehensive examination covering all thirteen units, with emphasis on Modules 4–5 — file systems, storage, security, and virtualization. Same four-part structure as the midterm, with a full instructor answer key.
- Coverage: All units (1–13), emphasis on 10–13
- Duration: 3 hours · 100 marks
- CLOs: All eight course learning outcomes
- Note: Use as a final exam in an assessment-plan variant, or as a capstone review for the final project.
Final Project · 20%
The capstone of the course
A substantial operating-system component, evaluated on design, functionality, depth, validation, documentation, demonstration, and professional quality. Choose from five project options, each integrating multiple course topics.
Option A — Educational OS Kernel
Build a small but complete operating-system kernel for x86-64 that boots, manages memory, schedules processes, handles interrupts, and runs a simple user-space program.
Boot, paging, scheduling, syscallsOption B — Container Runtime
Build a container runtime from scratch — image pulling, root file-system assembly, namespace and cgroup configuration, and container lifecycle management.
Namespaces, cgroups, seccompOption C — Type-2 Hypervisor
Build a type-2 hypervisor that uses KVM to run a guest virtual machine, including VM creation, memory mapping, virtual CPU management, and virtio-based I/O.
KVM, virtio, virtual CPUsOption D — Distributed/Cloud OS Component
Build a component of a distributed operating system — a replicated key-value store, a cluster scheduler, or a distributed file system — with fault tolerance and consistency.
Replication, consensus, fault toleranceOption E — OS Observability Suite
Build a suite of tools that observe and diagnose a running Linux system: system-call tracer, scheduler analyser, memory profiler, I/O observer, integrated into a single dashboard.
ptrace, eBPF, /proc, perfThe project is worth 20% of the final grade and is assessed on seven criteria: technical design (20%), functionality (25%), complexity and depth (15%), testing and validation (15%), documentation (10%), demonstration (10%), and professional quality (5%). The demonstration is a required component.
Discussion activities · 5%
Thirteen unit-level discussions
Every unit includes a graded discussion activity. Each requires a substantive original post plus replies to at least two classmates. All thirteen are available now, and each is tailored to the content of its unit.
- Unit 1 What Is an Operating System? — resource manager vs. extended machine Open →
- Unit 2 The UNIX Philosophy and Modern Linux — evaluating the design principles Open →
- Unit 3 The Cost of a Process — measuring creation, context switching, termination Open →
- Unit 4 How Far Does Parallelism Scale? — Amdahl's Law and its limits Open →
- Unit 5 Scheduling a Mixed Workload — policy choice for interactive and batch Open →
- Unit 6 Anatomy of a Race Condition — analysing a real synchronization bug Open →
- Unit 7 Designing a Deadlock-Free Protocol — lock ordering for a caching subsystem Open →
- Unit 8 Measuring Fragmentation — internal, external, and compaction Open →
- Unit 9 Diagnosing a Page-Fault Storm — thrashing and its mitigation Open →
- Unit 10 Anatomy of a File-System Failure — the broken assumption Open →
- Unit 11 Designing Storage for a Workload — media, RAID, scheduler, caching Open →
- Unit 12 Threat Modelling a Service — STRIDE, priorities, layered defences Open →
- Unit 13 The Future of Virtualization — arguing for an isolation technology Open →
Assessment
How you will be graded
Assessment is continuous and applied. Roughly half of the final grade comes from laboratory and project work that you build and test yourself; the other half comes from quizzes, two assignments, and the midterm exam.
10%
Quizzes
Thirteen unit-level quizzes with immediate feedback.
15%
Laboratories
Twelve Linux laboratories, one per major topic area.
15%
Assignment 1
Processes, threads, and synchronization.
20%
Assignment 2
An operating-system simulator of your choosing.
15%
Midterm Exam
Covers Modules 1–3: foundations, concurrency, memory.
20%
Final Project
Design, build, test, document, and demonstrate a system.
5%
Participation
Thirteen unit discussion activities and peer engagement.
| Assessment | Weight | Primary outcomes |
|---|---|---|
| Quizzes (13) | 10% | CLO1–CLO5, CLO7 |
| Laboratories (12) | 15% | CLO2–CLO7 |
| Assignment 1 — Parallel Log Analyzer | 15% | CLO2, CLO3, CLO6, CLO8 |
| Assignment 2 — Operating-System Simulator | 20% | CLO3, CLO4, CLO5, CLO6, CLO8 |
| Midterm Exam | 15% | CLO1–CLO4 |
| Final Project | 20% | CLO2–CLO6, CLO8 |
| Participation (13 discussions) | 5% | CLO1, CLO3, CLO7 |
| Total | 100% |
Quizzes · 10%
Each unit ends with a quiz that covers that unit's lessons. All thirteen self-check quizzes are available now; each is ungraded and can be attempted repeatedly.
- Unit 1 Introduction to Operating Systems Open self-check →
- Unit 2 Linux and UNIX Fundamentals Open self-check →
- Unit 3 Processes Open self-check →
- Unit 4 Threads Open self-check →
- Unit 5 CPU Scheduling Open self-check →
- Unit 6 Synchronization Open self-check →
- Unit 7 Deadlocks Open self-check →
- Unit 8 Main Memory Management Open self-check →
- Unit 9 Virtual Memory Open self-check →
- Unit 10 File Systems Open self-check →
- Unit 11 I/O and Storage Management Open self-check →
- Unit 12 Security and Protection Open self-check →
- Unit 13 Virtualization and Cloud Operating Systems Open self-check →
Alignment
Outcome-to-assessment map
Every course learning outcome is assessed in more than one way, so no single artefact carries the whole weight of an outcome.
| CLO | Quiz | Lab | A1 | A2 | Midterm | Final | Project | Discussion |
|---|---|---|---|---|---|---|---|---|
| CLO1 | ✓ | — | — | — | ✓ | ✓ | — | ✓ |
| CLO2 | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | — |
| CLO3 | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| CLO4 | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | — |
| CLO5 | ✓ | ✓ | — | ✓ | — | ✓ | ✓ | — |
| CLO6 | — | ✓ | ✓ | ✓ | — | — | ✓ | — |
| CLO7 | ✓ | ✓ | — | — | — | ✓ | — | ✓ |
| CLO8 | — | — | ✓ | ✓ | — | — | ✓ | — |
Resources
Textbooks, tools, and environment
The primary textbook is an open educational resource and is freely available online. Secondary references are optional but recommended.
Primary textbook
Arpaci-Dusseau, R. H., & Arpaci-Dusseau, A. C.
Operating Systems: Three Easy Pieces (OSTEP) — Open Educational Resource.
Open access Required readingSecondary references
Silberschatz, Galvin & Gagne
Operating System Concepts — classic reference for OS theory and structure.
Tanenbaum & Bos
Modern Operating Systems — broad comparative survey of OS design.
Love, R.
Linux System Programming — practical Linux API reference.
Stevens & Rago
Advanced Programming in the UNIX Environment — definitive UNIX systems programming text.
Course environment & tools
Linux virtual machine
Preconfigured Ubuntu environment with all required tooling installed.
Git repository templates
Starter repositories for every laboratory and assignment.
Docker environment
Reproducible container images for builds and container-based labs.
Sample code base
Annotated reference implementations for core OS mechanisms.
Auto-grading infrastructure
Automated correctness checks with immediate feedback.
GCC · Make · GDB · Git
The standard Linux systems-programming toolchain used throughout.
Accreditation & design
Standards alignment
This course is designed to satisfy the requirements of a required third-year operating systems course in Computer Science, Computing and Information Systems, Software Engineering, or Information Technology programs.
ACM CS2023 ABET Student Outcomes CEAB Graduate Attributes Canadian Degree Qualifications Framework Quality Matters Standards
Course development deliverables
- Content: 13 units, 81 lessons, approximately 300–400 LMS pages
- Laboratories: 12 Linux laboratories
- Quizzes: 13 unit-level self-check quizzes
- Assignments: 2 substantial programming assignments
- Examinations: Midterm and comprehensive final
- Final project: 5 project options with full rubric
- Discussions: 13 unit-level discussion activities
- Resources: Linux VM, Git templates, Docker environment, sample code base, auto-grading infrastructure
Common questions
Where do I start?
Begin with Lesson 1.0 — Setting Up Your Course VM, then work through Lesson 1.1 and the rest of Unit 1 in order.
Do I need prior Linux experience?
No. Unit 2 covers Linux architecture, the shell, users and groups, permissions, and the development environment before any systems programming begins.
What programming language is used?
Primarily C, with POSIX threads and the Linux system-call interface. Shell scripting is used for laboratory workflows.
Is every component available now?
Yes. All twelve laboratories, thirteen quizzes, two assignments, both examinations, the final project specification, and all thirteen discussion activities are available. The course is complete and can be taken in full.
How is the course paced?
The course is asynchronous and self-paced. Content is released in full, and the recommended schedule completes one unit per week across a thirteen-week term, with one laboratory every one to two weeks and the midterm after Lesson 9.7.
Is the laboratory version worth 4 credits?
Yes — the laboratory-intensive variant carries an additional credit and expands the twelve laboratories with extended implementation work and additional validation requirements.
How does the final examination fit into the assessment plan?
The course development plan specifies a midterm (15%) and a final project (20%), but no separate final examination. The comprehensive final examination is provided for assessment-plan variants that include it, or as a capstone review resource for the final project. Instructors should confirm the weighting in the course syllabus.
Ready to begin?
Start with Lesson 1.0 — Setting Up Your Course VM, then work through Module 1. Everything you need is already available.