Interrupts

ARM processor and architecture

C Functions

C Mastery

From Assembly to C

Libraries

PS/2 Protocol

Computer Arithmetic

C Pointers

Linking

Graphics

Multithreading

C Arrays

Framebuffer

Memory Systems

ARM assembly and machine code

Modules

Keyboards

Sensors

Memory management

CS 107e Computer Systems from the Ground Up Stanford University Winter 2023 CS 107e focuses on bare metal programming on the Raspberry Pi, serving as an introduction to embedded systems. It covers the entire process from the microprocessor to the C programming language. The course aims to build a solid understanding of how modern computers execute programs and how program development tools work.  CS107 is the third course in Stanford's introductory programming sequence. The CS106A/B courses provide students with a solid foundation in programming methodology and abstractions, and CS107 follows on to develop the skills needed to build computer systems.

**CS107e: Computer Systems from the Ground Up** is a variant of CS107 that teaches the fundamental concepts of computer systems through bare metal programming on the Raspberry Pi. Bare metal programming means you will not run an operating system on the Raspberry Pi and will make minimal use of libraries. This course also serves as an introduction to embedded systems. The course starts with the microprocessor and moves up to the C programming language, without skipping anything in between. The goal is to build a solid understanding of all aspects of how modern computers execute programs and how program development tools work. The major learning goals for the course are:

- To understand how computers represent information, execute programs, and control peripherals.
- To master command-line programming tools and the C programming language.

Topics covered include:

- the ARM architecture
- assembly language and machine-level code
- the C programming language
- compilation, linking and loading
- debugging
- memory organization and management
- controlling peripherals: GPIO, graphics, sound, and keyboards  

CS 107e Computer Systems from the Ground Up

Computer Systems

Observability

Registers

Exception handling

Makefiles

Devices

Thread (computing)

Networking

Compiler Optimization

File system

CS 140E: embedded operating systems Stanford University Winter 2023 This course focuses on providing an introduction to operating systems with a specific emphasis on embedded systems, interacting with hardware, and verification. Students will have hands-on experience through labs and will build their own simple, clean operating system for an ARM-based Raspberry Pi. The course offers opportunities to work with real hardware and primary-source documents, encouraging a deeper understanding of computation on real hardware. Tl;dr:

- It's a lab class, so jump right to the labs.
- If you find the material useful, please consider donating --- all donated funds go entirely to buy food and equipment for the 2023 lab students.

CS140E is an introductory operating systems course. It roughly covers the same high-level material as [CS 212](https://cs212.stanford.edu/) (formerly CS 140), but with a focus on embedded systems, interacting directly with hardware, and verification. Both courses cover concepts such as virtual memory, filesystems, networking, and scheduling, but take different approaches to doing so. By the end of 140E, you will have (hopefully) built your own simple, clean operating system for the widely-used, [ARM-based Raspberry Pi](https://www.raspberrypi.org/). ## Details

140e is a lab-based class with no explicit lectures. We will do two three-to-five hour labs each week. You should be able to complete almost all of the lab in one sitting. There will be several homeworks, that act as mini-capstone projects tying together the preceding labs. Since we are breaking new ground by having the class virtual only, we may add an additional discussion section to help people that need it.

By the end of the class you will have built your own simple, clean OS for the widely-used, ARM-based raspberry pi --- including interrupts, threads, virtual memory, and a simple file system. Your OS should serve as a good base for interesting, real, sensor-based / embedded projects.

We try to work directly with primary-sources (the Broadcom and ARM6 manuals, various datasheets) since learning to understand such prose is one of the super-powers of good systems hackers. It will also give you the tools to go off on your own after the course and fearlessly build sensor-based devices using only their datasheets.

This course differs from most OS courses in that it uses real hardware instead of a fake simulator, and almost all of the code will be written by you.

After this quarter, you'll know/enact many cool things your peers do not. You will also have a too-rare concrete understanding of how computation works on real hardware. This understanding will serve you in many other contexts. For what it is worth, everything you build will be stuff we found personally useful. There will be zero (intentional) busy-work.

### Who should take this class.

The goal of the class is to help students who are very motivated and/or very good to go far, quickly. We focus on building small, simple but real OS subsystems --- threading, virtual memory, etc --- that can be used to build many other things.

You should take this class if:

You write code well OR (you don't yet write code well AND have a lot of time to devote to the class);

AND you find these systems topics interesting.

The people that found the class valuable in the past were entirely drawn from this demographic. I would say that if you struggle building stuff and are not already interested in the topic, then it's probably better to take a different class. I would particularly advise against taking this class if you were looking for an easier way to satisfy a cs140 requirement.

It always helps, but you do not need any background in hardware or OS stuff to do well in the class. In fact, you don't even need to have been trained in CS: one of the best students from last year was a physics PhD student with fairly minimal background in coding, so we've had fantastic luck with non-CS folks :) With that said, the less background you have, the more motivation you might need.

By the end of the class you'll have learned how to comfortably do many things that may well seem like superpowers and could easily serve you well for the next few decades.

If you have background in the "embedded" space, it's worth taking b/c you'll learn a bunch of useful but not widely-known tricks (I'll pay for your supplies and a pitcher of beer if this claim turns out to be false!)

It's also super fun. The code you'll write can be used to as a basis for building many interesting systems.

As one measure: Last year, I taught two extra follow-on classes (cs240lx and cs340lx) ``for free'' because of all the interesting things that came up from cs140e. In addition, it's caused me to write more code than I have since grad school. At my age, that's an unusual result :)

### What this class is not

A quick skim might falsely pattern-match on a couple of things:

1. cs140e is NOT an easier version of cs140. In fact, it can be quite a bit harder, since we work with raw hardware, and primarily use raw datasheets and ARMv6 architecture manuals rather than pre-digested text books or simulators.

    I'd say about 1/3 of the teaching evals from last year explicitly stated "do not take cs140e as an easier cs140".

    On the plus side, this approach is the adult way to do things, so you will be better prepared after the class for operating autonomously in the real world without safety nets or help. Everything you'll build will be stuff we personally found useful. There is no (intentional) busywork.

1. Similarly, while we do use a raspberry pi for this class, and there are tons of blog posts/instructables/classes for novices showing how to use the r/pi to do simple things, this class is not that.

    You'll be writing virtual memory systems, SD card file systems, threads, i2c device drivers on raw hardware rather than cut-and-pasting some python on a library to blinky a light.

    We use the r/pi because its fairly cheap, holds up to electrical mistakes pretty well, runs a legit processor with legit hardware and is small enough to carry around easily.

With that said, I set aside the entire quarter to work on this course, so am happy to help people that need it --- some of the biggest success stories last year were from students that had an initially large gap between their understanding and the topic but started to really "get it" after some weeks of struggle.
 Note that nothing here is strictly required, as long as you're willing to learn it on-the-fly. However, the course material is designed assuming most students will have the following:

- CS 110 or CS 111
- Some knowledge of C and UNIX

No previous experience with operating systems, raspberry pis, or embedded programming is required.

If you want to take the course but are worried about any of these, talk to us! We can point you to resources to help catch up, should you need them. ## Why should I take CS 140E?

CS 140E is unlike many other Stanford CS classes in one major way: it isn't
simplified for a classroom setting. The hardware you're interacting with is the
same hardware the Linux kernel interacts with. When there's a bug in the
hardware, we have to work around it. When the documents are wrong, we have to
find the errors.

- If the freedom to design any embedded system you can imagine excites you, CS
  140E is one of the only places you can do it in a classroom setting.
- If you've never programmed in a completely baremetal system before, CS 140E
  will give you a taste of what it's like.
- If you want to get better at debugging, CS 140E will give you plenty of
  opportunities to do so.
- If you want to get better at real-world systems programming, CS 140E gives
  you the chance to work on raw hardware and documents, rather than
  a simplified simulation.

## Who should take CS 140E?

This is a tricky question, since there's no one particular set of factors which
is correlated with success in this class. There's a subset of people who love
it, and a subset who don't.

In general, the people who enjoy CS 140E tend to fit the following:

1.  One of:
    - You write code well
    - You want to learn to write code well, and have a lot of time to devote to
      the class
2.  You find systems topics interesting

However, since the class is fairly unusual in a lot of ways, it also tends to
appeal to people from atypical backgrounds. Some of our most successful
students in the past have been from non-CS majors. As mentioned below, we don't
have any hard prerequisites; this is specifically because we want the course to
be accessible to anyone who's interested in learning the material, regardless
of background.

## What are the differences between CS 212 and CS 140E?

CS 140E can count as a substitute for CS 212 (including for PhD students who
need to fulfill an OS breadth requirement). It is approximately 80% of the
_coding_ work of CS 212, but will probably require a more strenuous type of
thinking at some points. The main differences are:

1.  We work with raw hardware (the Raspberry Pi A+), not a simulator.
2.  Most of the reading involves primary hardware documents, rather than
    high-level discussions.
3.  Most of the code at the end will (hopefully) be written by you, rather than
    you having to deal with a large, complicated codebase.
4.  We focus much more on checking and somewhat-verifying your code,
    rather than passing an autograder.

With that said, you are strongly encouraged to sit in on the CS 212 lectures if
you can; Mazières is incredibly knowledgable, and will serve as a great
counterpoint to what we do.

The flip side of working with raw hardware and documentation is that this class
is much less structured than other CS classes you might have taken before. If
you're the kind of person who loves figuring things out and exploring, great!
If you prefer more structured assignments and lectures, you might want to
consider CS 212 instead.

CS 140E: embedded operating systems

Operating Systems

Floating Point

RISC-V Procedures

Loader

RISC-V Single-Cycle Datapath

Caches - Multilevel

Parallelism

Translation Lookaside Buffer (TLB)

Amdahl's law

RAID (Redundant Array of Inexpensive Disks)

Virtual memory

RISC-V Instruction Formats

Combinational Logic

RISC-V Single-Cycle Control

Caches - Set-associative

Thread-level Parallelism

Page faults

Virtual memory performance

Data-level parallelism

Data center

Assembly language

Number Representation

RISC-V

Compiler

Synchronous Digital Systems (SDS) State

RISC-V 5-Stage Pipeline

Performance with Caches

OpenMP

Multilevel

Dependability

Warehouse-scale Computing

Input/output

C (programming language)

RISC-V Data Transfer

Assembler

Finite State Machine (FSM)

Hazards

Flynn taxonomy

Cache coherence

MapReduce

Parity

C Memory (Mis)Management

RISC-V Decision Making Logical Ops

Linker

Combinational Logic Blocks

Caches - Direct Mapped

Single instruction, multiple data (SIMD)

Performance

Apache Spark

Error-correcting Codes (ECC)

CS 61C Great Ideas in Computer Architecture (Machine Structures) UC Berkeley Fall 2022 This course deepens students' understanding of computer architecture and the translation of high-level programs into machine language. Emphasis is on C and assembly language programming, computer organization, parallelism, CPU design, and warehouse-scale computing. Prerequisites include CS61A and CS61B or equivalent C-based programming experience. [Official Academic Guide course description](https://classes.berkeley.edu/content/2022-fall-compsci-61c-001-lec-001)

The subjects covered in this course include C and assembly language programming, translation of high-level programs into machine language, computer organization, caches, performance measurement, parallelism, CPU design, warehouse-scale computing, and related topics.  CS61A and CS61B (or equivalents) or experience with a C-based programming language (e.g. Java, C++). There is no official textbook for this class. However, there are three optional textbooks as additional references:

- **P&H**: Second edition of Patterson and Hennessy's *Computer Organization and Design RISC-V Edition* book ("P&H"), ISBN 0128122757.
- **K&R**: *The C Programming Language, Second Edition* by Kernighan and Ritchie. Other C programming books are also suitable if you are already comfortable with them, but our lectures will be based on K&R.
- **WSC**: *The Datacenter as a Computer: An Introduction to the Design of Warehouse-Scale Machines*, which is freely available [on our website](https://inst.eecs.berkeley.edu/~cs61c/resources/WSCBarrosoHolzle.pdf).

Please contact staff on Ed if you have trouble finding or paying for these textbooks.

CS 61C Great Ideas in Computer Architecture (Machine Structures)

Booting

Unix

Operating System Structure

Virtual Machine (VM)

Operating System Design

Microkernels

Scheduling (computing)

Operating System Security

Communication protocol

Remote Procedure Call (RPC)

Distributed File Systems

Avoiding Operating Systems

CS167 Operating Systems Brown University Spring 2023 CS167 offers comprehensive insights into the principles and intricacies of operating systems. Topics range from multithreaded programming to file system designs. Students will not only grasp theoretical knowledge but also get hands-on experience, particularly through the optional lab CS169, where they can develop an operating system called Weenix. In this class, you'll have the opportunity to learn both the overarching principles of operating systems as well as the intricacies of how they work.

We'll cover topics including multithreaded programming; managing threads, interrupts, and storage; processor scheduling; operating system structure; virtualization; security; and the design of both local and distributed file systems. You'll develop your skill as a C programmer while simultaneously learning what goes on inside your computer from the moment you power it on.

As part of the class, if you are enrolled in CS167, you may choose to take the (optional) half-credit lab, CS169. If you do so, you will attend the same lectures and complete the written assignments as usual. However, you will only complete the first two programming assignments from CS167, before embarking on an in-depth project wherein you build much of the functionality of a small operating system called Weenix. It is a significant time investment, and you'll still get a lot from the class if you don't take the lab. Some thoughts on taking CS169 from previous students can be found [here](). CS267 covers the material of both CS167 and 169; it is for graduate students only. ### The Course

- Implement threads
- Learn about operating systems
- Implement one (Weenix)
    - file-system-related components (1670)
    - most of the rest of it (1690, 2670) ### Skills Needed

- Ability to write and debug largish programs in C with POSIX threads
    - CSCI 330/1330 or CSCI 300/1310 (you may want to review POSIX threads material from 330 lectures)
- Basic computer architecture
    - CSCI 330/1330 or CSCI 300/1310 ### Workload Components

- Four moderate programming assignments
    - UThreads: simple user-level threads package
    - MThreads: more sophisticated user-level threads package
    - VFS: system calls and high-level file system
    - S5FS: low-level file system
- One large programming assignment: Weenix
- combines VFS and S5FS, as well as Processes, Drivers, and Virtual Memory
- Four homeworks
- In-class TopHat questions

### Textbook

Operating Systems In Depth: Design and Programming, 1st Edition

CS167 Operating Systems

Interrupt

Interrupts

4 courses cover this concept

CS 107e Computer Systems from the Ground Up

CS 140E: embedded operating systems

CS 61C Great Ideas in Computer Architecture (Machine Structures)

CS167 Operating Systems