Module 1
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.
Course
COMP3150Operating Systems
intermediate
active
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.
Operating Systems
intermediate
active
Also known as: CMIS 3150
Canonical ID:
urn:taxonomy:cip-aligned:course:COMP3150
| Course name | Operating Systems |
|---|---|
| Course code | COMP3150 |
| Level | intermediate |
| Status | active |
| Subject | Programming (SUB-0101-01) |
| Discipline | Computer Science |
| Category | Computing and Information Sciences |
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.
5
Modules
13
Units
81
Lessons
12
Laboratories
13
Quizzes
8
Learning outcomes
Credit hours
| Min | 3 |
|---|---|
| Max | 4 |
| Type | semester |
Delivery modes
Asynchronous, self-paced.
Learning outcomes
- Explain operating-system concepts, services, and architectures.
- Explain process and thread management principles and mechanisms.
- Analyze scheduling, synchronization, and deadlock solutions.
- Explain memory and virtual-memory management techniques.
- Explain file systems, storage systems, and I/O management.
- Apply Linux systems-programming techniques and operating-system tools.
- Evaluate operating-system security, protection, virtualization, and cloud technologies.
- Design and implement software components related to operating-system functionality.
Topics
Assessments
Prerequisites
Introduction to Programming, Object-Oriented Programming, Data Structures and Algorithms, Computer Organization and Architecture
Corequisites
None
Equivalent courses
None
Cross-listed courses
Explore
Course components
Five modules, thirteen units, and eighty-one lessons make up the course. Every lesson follows the same eleven-part structure.
Module 2
5 units · 30 lessons
Processes and Concurrency
The heart of the course: process and thread abstractions, CPU scheduling, synchronization, and the deadlock problem.
Module 3
2 units · 13 lessons
Memory Management
From the memory hierarchy and address binding to paging, page replacement, and the control of thrashing.
Module 4
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.
Module 5
2 units · 14 lessons
Security, Virtualization & Modern Systems
Protection and access control, OS hardening, hypervisors, containers, orchestration, and cloud operating systems.
Laboratories
Twelve Linux laboratories
Every laboratory runs in the supplied Linux virtual machine using GCC, Make, Git, GDB, and the POSIX API. Each combines implementation, measurement, and analysis.
| Lab | Topic | Related unit |
|---|---|---|
| Lab 1 | Linux Fundamentals | Unit 2 |
| Lab 2 | Process Management | Unit 3 |
| Lab 3 | POSIX Threads | Unit 4 |
| Lab 4 | Scheduling Simulation | Unit 5 |
| Lab 5 | Synchronization | Unit 6 |
| Lab 6 | Deadlock Analysis | Unit 7 |
| Lab 7 | Memory Management | Unit 8 |
| Lab 8 | Virtual Memory | Unit 9 |
| Lab 9 | File Systems | Unit 10 |
| Lab 10 | Storage Systems | Unit 11 |
| Lab 11 | Security | Unit 12 |
| Lab 12 | Containers and Virtualization | Unit 13 |
Assignments
Two substantial programming assignments
Each assignment spans multiple weeks and draws on several units. Together they account for 35% of the final grade.
Assignment 1 — Parallel Log Analyzer
Design and implement a concurrent log-analysis system that uses both processes and threads, communicates through pipes and shared memory, synchronises access to a bounded buffer, and shuts down gracefully on a signal.
- Weight: 15% of final grade
- CLOs: CLO2, CLO3, CLO6, CLO8
- Criteria: 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 OS subsystem. Choose from a CPU scheduler, virtual-memory manager, or file system, and build it end to end with rigorous testing and quantitative analysis.
- Weight: 20% of final grade
- CLOs: CLO3, CLO4, CLO5, CLO6, CLO8
- Criteria: requirements coverage 20%, algorithm correctness 25%, system design 20%, testing and validation 15%, documentation 10%, code quality 10%.
Examinations
Midterm and comprehensive final
Both papers include full instructor answer keys with model answers and marking guides.
Midterm Examination
A two-hour, closed-book examination covering Modules 1–3. Four parts: multiple choice, short answer, problems, and design/analysis.
- Weight: 15% of final grade
- Coverage: Units 1–9
- CLOs: CLO1, CLO2, CLO3, CLO4
Final Examination
A three-hour comprehensive examination covering all thirteen units, with emphasis on Modules 4–5. Same four-part structure as the midterm.
- Coverage: Units 1–13 (emphasis 10–13)
- CLOs: All eight course learning outcomes
- Use: assessment-plan variants or capstone review for the final project.
Final Project
The capstone of the course
A substantial operating-system component, worth 20% of the final grade, evaluated on design, functionality, depth, validation, documentation, demonstration, and professional quality.
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, syscalls
Option 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, seccomp
Option 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 CPUs
Option 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 tolerance
Option 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, perf
Discussions
Thirteen unit-level discussion activities
Every unit includes a graded discussion worth 5% of the final grade in total. Each requires a substantive original post and replies to two classmates.
- Unit 1 — What Is an Operating System? resource manager vs. extended machine
- Unit 2 — The UNIX Philosophy and Modern Linux: evaluating the design principles
- Unit 3 — The Cost of a Process: measuring creation, context switching, termination
- Unit 4 — How Far Does Parallelism Scale? Amdahl's Law and its limits
- Unit 5 — Scheduling a Mixed Workload: policy choice for interactive and batch
- Unit 6 — Anatomy of a Race Condition: analysing a real synchronization bug
- Unit 7 — Designing a Deadlock-Free Protocol: lock ordering for a caching subsystem
- Unit 8 — Measuring Fragmentation: internal, external, and compaction
- Unit 9 — Diagnosing a Page-Fault Storm: thrashing and its mitigation
- Unit 10 — Anatomy of a File-System Failure: the broken assumption
- Unit 11 — Designing Storage for a Workload: media, RAID, scheduler, caching
- Unit 12 — Threat Modelling a Service: STRIDE, priorities, layered defences
- Unit 13 — The Future of Virtualization: arguing for an isolation technology
Assessment
How you will be graded
Roughly half of the final grade comes from laboratory and project work; the other half comes from quizzes, two assignments, and the midterm exam.
| 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% |
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
Primary textbook
Arpaci-Dusseau, R. H., & Arpaci-Dusseau, A. C. Operating Systems: Three Easy Pieces (OSTEP) — Open Educational Resource.
Open access Required reading
Secondary references
- Silberschatz, Galvin & Gagne — Operating System Concepts
- Tanenbaum & Bos — Modern Operating Systems
- Love, R. — Linux System Programming
- Stevens & Rago — Advanced Programming in the UNIX Environment
Course environment & tools
- Linux virtual machine — preconfigured Ubuntu environment with all required tooling.
- 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
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.
Ready to begin?
Start with Lesson 1.0 — Setting Up Your Course VM, then work through Module 1. Everything you need is already available.