55AA-004

Operating Systems

Level
Undergraduate
Status
Under development

Note: this course is still being designed and calibrated; the page content is for reference and does not represent the final teaching version.

Syllabus

Course Overview

Operating Systems combines abstractions with runnable kernel experiments: processes, threads, memory, file systems, devices, interrupts, concurrency, and virtualization are learned through implementation and debugging. The course emphasizes isolation, privilege, resource control, and failure boundaries in security contexts.

This is a core systems foundation for system security, virtualization, forensics, and embedded security.

Prerequisites

  • Computer organization, assembly language, and systems programming.
  • Familiarity with C or Rust, debuggers, and command-line tools.
  • Understanding of basic data structures and concurrency issues.

Learning Outcomes

  • Implement or modify key OS subsystems.
  • Explain process, virtual memory, file-system, and device abstractions.
  • Debug concurrency, memory, and performance problems.
  • Analyze security implications of isolation, privilege, and resource control.
  • Present design, bugs, and performance evidence clearly in lab reports.

Course Format

  • Two meetings per week: one for core concepts and one for labs, paper discussion, or project review.
  • The course proceeds over 16 weeks, each with a checkable assignment, lab, or project milestone.
  • Reproducibility is required: code, configuration, data, lab logs, and reports must be reviewable by staff or peers.

Weekly Plan

Week 1

Kernel structure, boot, and debugging

Boot the teaching kernel, set up debugging, and implement the first syscall.

Week 2

Kernel structure, boot, and debugging: lab and review

Boot the teaching kernel, set up debugging, and implement the first syscall. Complete the paired lab, record issues, and explain design tradeoffs in class review.

Week 4

Processes, threads, and scheduling: lab and review

Implement a scheduling or synchronization lab. Complete the paired lab, record issues, and explain design tradeoffs in class review.

Week 6

Virtual memory and address spaces: lab and review

Complete a page-table, page-fault, or memory-mapping lab. Complete the paired lab, record issues, and explain design tradeoffs in class review.

Week 8

Concurrency, locks, and deadlock: lab and review

Locate and fix a kernel concurrency bug. Complete the paired lab, record issues, and explain design tradeoffs in class review.

Week 9
Week 10

File systems and persistence: lab and review

Implement file-system functionality and test crash consistency. Complete the paired lab, record issues, and explain design tradeoffs in class review.

Week 12

Devices, interrupts, and I/O: lab and review

Analyze performance and failure modes of a driver path. Complete the paired lab, record issues, and explain design tradeoffs in class review.

Week 14

Isolation, privilege, and container basics: lab and review

Experiment with namespaces, cgroups, or capabilities. Complete the paired lab, record issues, and explain design tradeoffs in class review.

Week 16

OS design review and security boundaries: lab and review

Submit the final kernel lab, tests, and design document. Complete the paired lab, record issues, and explain design tradeoffs in class review.

Assessment

Individual assignments

Concept questions, reading responses, design tasks, and small programming or lab exercises.

25%
Labs and project

Kernel labs, debugging records, tests, and design notes.

40%
Participation and review

Participation in discussions, demos, code or paper reviews, and peer feedback.

10%
Final report and defense

Submit reproducible artifacts, a technical report, and a demo explaining methods, results, limitations, and future work.

25%

Course Project

The project extends a teaching kernel or small systems component. Students implement a clear subsystem and provide design notes, tests, and performance or security analysis.

Policies

  • AI tools are allowed, but generated code, lab notes, and design suggestions must be reviewed by the student and disclosed in the report.
  • Students may not submit code, proofs, configuration, or experimental results they cannot explain; each member must defend their own design, tests, and tradeoffs.
  • Late work affects iteration grades, but the course values reproducible, auditable, and maintainable results over last-minute accumulation.

Reference Courses

China 985 Universities