# Where to Find Computer Architecture and Operating Systems Courses: The Complete CS Self-Learning Guide

> Discover free Computer Architecture and Operating Systems courses from top universities like MIT and UC Berkeley. Access syllabi, videos, and labs via the PKUFlyingPig/cs-self-learning guide for effective self-study.

- Repository: [Yinmin Zhong/cs-self-learning](https://github.com/PKUFlyingPig/cs-self-learning)
- Tags: guide
- Published: 2026-03-02

---

**The PKUFlyingPig/cs-self-learning repository curates a comprehensive collection of free, university-level Computer Architecture and Operating Systems courses from institutions like MIT, UC Berkeley, and ETH Zurich, complete with direct links to syllabi, video playlists, and hands-on lab assignments.**

The PKUFlyingPig/cs-self-learning repository serves as a centralized roadmap for self-taught computer science students seeking high-quality academic resources. Whether you are building your first CPU from logic gates or implementing a Unix-like kernel, this curated collection provides structured learning paths through markdown documentation and external course links. This guide explores the specific Computer Architecture and Operating Systems courses available in the repository and how to navigate their documentation to start coding immediately.

## Computer Architecture Courses

The repository organizes Computer Architecture resources under the `docs/体系结构/` directory, featuring three complementary courses that progress from digital logic to modern processor design.

### UC Berkeley CS61C: Great Ideas in Computer Architecture

**CS61C** provides a comprehensive introduction to computer architecture using the **RISC-V ISA**. The course covers pipelining, cache hierarchies, virtual memory, and parallelism through hands-on projects.

Key components include:
- **Game of Life** implementation in C
- **MNIST-recognizing neural network** written in RISC-V assembly
- **2-stage pipeline CPU** built in Logisim
- **SIMD-optimized matrix operations** using vector instructions

According to the repository source code in `docs/体系结构/CS61C.md`, the course provides syllabi, video playlists (Bilibili/YouTube), assignment repositories, and archival WayBack links under the "课程资源" section. The recommended toolchain includes the RISC-V GCC compiler and the Spike simulator for running assembly code.

### ETH Zurich Computer Architecture (CA)

The **ETH Computer Architecture** course advances into superscalar execution and modern memory systems using a MIPS-style pipeline. Students implement a **pipelined CPU in Verilog** and develop a **cycle-accurate C simulator** to model processor behavior.

The repository file `docs/体系结构/CA.md` contains the full syllabus and links to lecture materials covering advanced micro-architecture concepts including out-of-order execution and cache coherence protocols.

### Nand2Tetris (N2T)

**Nand2Tetris** offers a bottom-up approach, teaching hardware construction from Boolean gates to a functioning 16-bit CPU. This Stanford/MIT-style course serves as an ideal prerequisite before tackling CS61C or ETH CA.

The documentation in `docs/体系结构/N2T.md` provides project files and HDL (Hardware Description Language) specifications for building the Hack computer platform from fundamental logic gates.

## Operating Systems Courses

The Operating Systems curriculum resides in `docs/操作系统/` and emphasizes kernel implementation through progressive lab assignments.

### MIT 6.S081: Operating System Engineering

**MIT 6.S081** (formerly 6.828) is the repository's recommended starting point for OS study. Students implement a Unix-like operating system called **xv6** on the RISC-V architecture through 11 labs covering:
- System calls and process management
- Scheduling algorithms and context switching
- File system implementation
- Virtual memory and page tables

The course emphasizes low-level C programming and RISC-V assembly. The repository's `docs/操作系统/MIT6.S081.md` file links to the official xv6 source tree, which uses a standard Makefile for compilation. Students modify kernel source files such as [`proc.c`](https://github.com/PKUFlyingPig/cs-self-learning/blob/main/proc.c) for process management and [`sysfile.c`](https://github.com/PKUFlyingPig/cs-self-learning/blob/main/sysfile.c) for file system operations.

### UC Berkeley CS162: Operating Systems and Systems Programming

**CS162** utilizes the **Pintos** educational operating system running on x86 architecture. Unlike xv6's RISC-V foundation, Pintos provides experience with legacy x86 segmentation and paging mechanisms.

The course project pipeline guides students from skeleton code to a functional OS implementing threading, user program loading, and a hierarchical file system. Reference `docs/操作系统/CS162.md` for the full project specification and starter code repository.

### Nanjing University OS (NJU OS)

**NJU OS** bridges computer architecture and operating systems through unique **Verilog-based CPU design labs** integrated with OS concepts. This Chinese-language course requires students to understand memory-cache interactions before implementing OS memory management.

Documentation in `docs/操作系统/NJUOS.md` contains bilingual resources and links to the course's custom simulator environment.

### Harbin Institute of Technology OS (HIT OS)

**HIT OS** focuses on classic Unix kernel internals by studying **Linux 0.11 source code**. Students learn device driver development, kernel synchronization primitives, and the Minix-style file system through direct modification of historical kernel code.

The file `docs/操作系统/HITOS.md` provides the Linux 0.11 source annotations and experimental guidelines for setting up the ancient but pedagogically valuable codebase.

## How to Navigate the Repository Resources

Each course markdown file follows a consistent structure to accelerate your learning:

1. **Locate the course file** – Architecture courses are in `docs/体系结构/` while OS courses reside in `docs/操作系统/`.

2. **Check the "课程资源" section** – This section contains direct hyperlinks to official course websites, video playlists, and GitHub assignment repositories (e.g., `git clone https://github.com/InsideEmpire/CS61C-Assignment` for CS61C labs).

3. **Set up your environment** – The repository includes `docs/必学工具/Docker.md` for containerized development environments, ensuring consistent toolchains across different courses without polluting your host system.

4. **Cross-reference topics** – Use CS61C's cache labs to understand the hardware mechanisms that MIT 6.S081's virtual memory labs rely on, creating a cohesive understanding of the hardware-software interface.

## Practical Code Examples

The following snippets illustrate typical tasks from the curated courses, demonstrating the hands-on style that defines these resources.

### RISC-V Assembly "Hello, World" (CS61C)

This assembly program demonstrates system calls in the RISC-V environment used throughout CS61C labs:

```asm
    .section .text
    .globl _start
_start:
    # write(1, msg, msg_len)

    li a7, 64          # syscall: write

    li a0, 1           # fd = stdout

    la a1, msg
    li a2, msg_len
    ecall

    # exit(0)

    li a7, 93          # syscall: exit

    li a0, 0
    ecall

msg:
    .asciz "Hello, CS61C!\n"
msg_len = . - msg

```

Compile with: `riscv64-unknown-elf-gcc -nostdlib -static -T link.ld hello.S -o hello`

Run with: `spike pk hello` (using the Spike RISC-V simulator referenced in the course toolchain setup).

### xv6 System Call Implementation (MIT 6.S081)

This example shows the three-layer system call structure required in MIT 6.S081 labs:

```c
// user.h - user-space declaration
int getpid(void);

```

```asm

# usys.S - system call stub generation

#include "syscall.h"
.global getpid
getpid:
    li a7, SYS_getpid
    ecall
    ret

```

```c
// proc.c - kernel implementation
int
sys_getpid(void)
{
  return myproc()->pid;
}

```

After adding the system call to the xv6 source tree, compile with `make` and test by creating a user program that calls `getpid()`.

## Summary

- **PKUFlyingPig/cs-self-learning** provides curated paths for both Computer Architecture (`docs/体系结构/`) and Operating Systems (`docs/操作系统/`) through university-level courses.
- **Computer Architecture progression**: Start with *Nand2Tetris* for digital logic fundamentals, advance to *UC Berkeley CS61C* for RISC-V and modern architecture, then tackle *ETH CA* for superscalar and advanced micro-architecture.
- **Operating Systems progression**: Begin with *MIT 6.S081* (xv6-RISC-V) for modern kernel implementation, explore *UC Berkeley CS162* (Pintos-x86) for alternative architecture experience, then investigate *NJU OS* or *HIT OS* for specialized perspectives.
- **All course materials** including syllabi, video lectures, and assignment repositories are directly linked from the markdown files, with Docker containerization support available in `docs/必学工具/Docker.md`.

## Frequently Asked Questions

### Which Computer Architecture course should I start with as a beginner?

Start with **Nand2Tetris** as documented in `docs/体系结构/N2T.md`. This course requires no prior hardware knowledge and teaches computer architecture from first principles (Boolean gates) upward. After completing N2T, proceed to **CS61C** (`docs/体系结构/CS61C.md`) to study modern RISC-V processors and memory hierarchies.

### What is the difference between MIT 6.S081 and Berkeley CS162 for learning Operating Systems?

**MIT 6.S081** uses the xv6 kernel on RISC-V architecture, offering a cleaner, modern instruction set and simpler codebase ideal for understanding core OS concepts. **Berkeley CS162** uses Pintos on x86, exposing students to legacy segmentation, BIOS boot processes, and more complex memory management. According to the repository structure in `docs/操作系统/`, MIT 6.S081 is recommended for beginners while CS162 provides valuable x86-specific knowledge.

### Do I need special hardware to complete these labs?

No physical hardware is required. All courses provide simulators and emulators: CS61C uses the **Spike RISC-V simulator** and QEMU, MIT 6.S081 uses **QEMU RISC-V**, and CS162 uses **Bochs** or QEMU for x86 emulation. The repository's `docs/必学工具/Docker.md` provides containerized environments pre-configured with these tools.

### Are these Computer Architecture and Operating Systems courses completely free?

Yes. As curated in the PKUFlyingPig/cs-self-learning repository, all listed courses offer free access to lecture videos, assignments, and source code. Some courses like MIT 6.S081 and CS61C use open-source educational software (xv6, RISC-V tools) released under permissive licenses, allowing unlimited personal and educational use without registration fees.