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

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 for process management and 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:

    .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:

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

# usys.S - system call stub generation

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

// 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}