System Calls

Multiprocessing

execvp

Interprocess Communication

Virtual memory

Thread (computing)

Mutexes (Mutual exclusion)

Semaphores

Thread Pools

Parallel Compilation

Clients

Networking

API (Application Programming Interface)

MapReduce

Filesystems

File Descriptors

waitpid

Pipeline (Unix)

Signals

Multithreading

Race condition

Condition variables

Multithreading Patterns

Read-Write Locks

Networks

Servers

HTTP

Networking Functions

CS 110: Principles of Computer Systems Stanford University Winter 2022 CS 110 delves into advanced computer systems and program construction, focusing on designing large systems, software that spans multiple machines, and parallel computing. This course builds upon CS107 and requires good knowledge of C, C++, Unix, GDB, Valgrind, and Make. It covers Linux filesystems, multiprocessing, threading, networking, and more. CS107 took you behind the scenes:

- how things work inside C++/Python/Java, and how your programs map onto the components of computer systems
- understanding of program behavior and execution
 
CS110 uses this as a foundation to build complex programs that maximally take advantage of the hardware and operating system software available to us:

- How can we understand the designs and tradeoffs of large systems?
- How can we write software that spans multiple machines?
- How can we write software that runs tasks in parallel on a single machine? ### Course Topics Overview

1. **Overview of Linux Filesystems** - How can we design filesystems to store and manipulate files on disk?
1. **Multiprocessing and Exceptional Control Flow** - How can our program create and interact with other programs?
1. **Threading and Concurrency** - How can a single instance of our program perform multiple coordinated tasks at the same time?
1. **Networking and Distributed Computing** - How can we write programs that communicate over a network with other programs, and tackle large tasks using many machines?
1. **Additional Topics**: MapReduce, Caching, and Non-Blocking I/O **CS107 or equivalent -**

- Each of you should know C and C++ reasonably well so that you can...
    - write moderately complex programs (e.g. pointers, **malloc/realloc/free**, C strings, C++ classes, methods, references, templates, **new/delete**)
    - read and understand portions of large code bases
    - trace memory diagrams and always win!
- Each of you should be ﬂuent with **Unix, GDB, Valgrind**, and **Make** to the extent they're covered in CS107 or its equivalent.

The first assignment is meant to give you a sense of the scope of CS110 programs and refresh your memory on relevant prerequisites.  If you feel ok about it, you're all set! Second half of CS107 Textbook: *Computer Systems: A Programmer's Perspective by Bryant & O'Hallaron, 3rd Edition*

- Can purchase full copy, or Stanford Bookstore custom edition with just CS110 chapters
 
*Principles of Computer System Design: An Introduction* by Jerome H. Saltzer and M. Frans Kaashoek

- Free Stanford online access [here](https://www.sciencedirect.com/book/9780123749574/principles-of-computer-system-design)​ (also linked on course homepage)
- Fewer readings from this book vs. first one
- You're welcome to buy a physical copy if you'd like

CS 110: Principles of Computer Systems

Computer Systems

Directories

Job Control

Browser Design

Protocols

TCP (Transmission Control Protocol)

Async I/O

Large Files

Links

Process (computing)

Synchronization (computer science)

Threading

IP (Internet Protocol)

CS 110: Principles of Computer Systems Stanford University Summer 2021 Requiring familiarity with C/C++ and Unix/Linux, delves into computer systems principles. Students will engage with a blend of C and C++ to interface with system resources and manage complex projects. The course covers a broad range of topics including filesystems, multiprocessing, synchronization, networking, and MapReduce.   Formally, the prerequisite for the course is CS 107. Less formally, you need to be familiar with the C and C++ programming languages, Unix/Linux, `make`, Makefiles, `gcc`/`g++`, `valgrind`, `gdb`, and have some experience with basic computer architecture (x86 as it’s taught in CS107, or exposure to some other architecture with the confidence and ability to pick up x86 as I reference it). **If you have not taken CS 107, please email me at the beginning of the quarter to let me know.**

We’ll be coding in a mixture of C and C++ throughout the quarter. We rely on C, because the libraries needed to interface with system resources are written in C. We rely on C++, because the projects become large enough that I prefer to go with a more mature language that supports encapsulation and generic programming better than C does. You should understand pointers, dynamic memory allocation (`malloc`/`realloc`/`free`), and C strings perfectly. You should understand C++ classes, methods, references, templates, and C++'s `new`and `delete` operators. There are many C++ features you’re not expected to know, but you should have enough programming maturity to pick those features up and search the web for reference materials as needed.

The [CS 107 course website](https://web.stanford.edu/class/cs107/syllabus.html)is still up and may be a good reference. If you have not taken CS 107 and find yourself struggling, get help as soon as possible! This class moves quickly, and you will not want to fall behind. Email me and I may be able to point you to helpful resources. Readings are optional this quarter. I will post notes and slides with most lectures as reference material. However, if you would like additional readings to prepare for lecture or to reinforce concepts, I will list associated readings from the following textbooks:

- *Computer Systems: A Programmer’s Perspective* by Bryant and O’Hallaron, either the 2nd or 3rd edition. Both CS107 and CS110 teach from a subset of the B&amp;O textbook, the Stanford Bookstore carries a custom reader with just the chapters we need. Additionally, the Stanford library should have scans of this book available online in a week or two, although these are not yet available at time of writing.
- *Principles of Computer System Design: An Introduction* by Jerome H. Saltzer and M. Frans Kaashoek. The textbook should be available through the [Stanford library reserves](https://searchworks.stanford.edu/?f%5Bcourse%5D%5B%5D=CS-110-01) or [Science Direct](http://www.sciencedirect.com/science/book/9780123749574), and because it’s free, I assume most of you would just prefer to go with the free online version. Again, you’re welcome to purchase a hardcopy if you’d like. It’s available for purchase on [Amazon](http://www.amazon.com/Principles-Computer-System-Design-Introduction/dp/0123749573).

Rust

C Programming

Function (computer programming)

Pointer (computer programming)

Computer memory

Array (data structure)

Heap (data structure)

Data structure

Modules

Compilation

Debugging

Makefiles

File I/O

Buffering

POSIX I/O

C++ Programming

Introduction

References

Const

Constructors

Class (computer programming)

new/delete

Smart pointer

Casting

Client-side Networking

Templates

Inheritance (object-oriented programming)

Server-side Networking

Standard Template Library (STL)

vtables

DNS (Domain Name System)

CSE 333 Systems Programming University of Washington Summer 2022 This course provides an understanding of systems in computing, focusing on operating systems, networking, and C/C++ languages. Students learn about low-level data representation, memory management, system interactions, and efficient programming workflows. It delves into C++ idioms, network protocols, and concurrency. Prior knowledge of C programming and Linux tools is required. Systems Programming is the exploration of the composition and interface of systems in computing looking through the lens of operating systems, networking, and C/C++ languages. Through peeling levels of abstraction, students will view practices of low-level data representation (e.g. C, C++); explicit memory management; interacting with operating-system services; and cache-aware programming. Course Learning objectives are the goals that are set out for you to accomplish in this course:

- Understand system theory of how a system interacts with its environment and controlling its input and output (feedback loops, input and output, deterioration, computation)
- Unravel layers of abstraction found within systems
- Describe multiple systems throughout the computing space (e.g. HTTP, Operating Systems, Threading, and Makefiles)
- Interpret and build an efficient workflow for programming in larger sized code bases
- Debug substantial C/C++ programs using debugging tools (GDB and Valgrind) - [CSE351 (The Hardware/Software Interface)](http://www.cs.washington.edu/education/courses/cse351): CSE 351 provides students with rudimentary knowledge of C programming; the ability to write, run, and debug programs; familiarity with Linux and the use of Linux compilation, editing, and debugging tools; a solid mental model of the relationship between high-level code (C) and assembly-level compiled code.
- [CSE 143 (Intro Programming II)](http://www.cs.washington.edu/education/courses/cse143): CSE 143 is not a direct prerequisite (CSE 351 prerequisite), but some of its topics are beneficial to review for CSE 333. This includes classes, inheritance, good style practices, and simple data structures such as linked lists, trees, hash tables, and queues. Further knowledge of Java and these data structures is not required, but could be helpful! ### Textbooks

There are no strictly required texts for this course. Most people will find it useful to have both a C and a C++ reference; suggestions are given below. The C++ Primer is strongly recommended as C++ is a big, complex language and it is hard to understand how it all fits together from just Google and Stack Overflow snippets and folklore.

#### Strongly Recommended:

C++ Primer (5th Edition), Lippman, Lajoie & Moo. ISBN 0-321-71411-3.

#### Suggested:

- [*C Programming Language (2nd Edition)*](http://www.amazon.com/Programming-Language-2nd-Brian-Kernighan/dp/0131103628/), Kernighan & Ritchie. ISBN 0-13-110362-8.
    - The definitive book on C from the people who created it. You will want to use an online reference for information about the latest libraries, but every serious programmer should study this book.
- [*Computer Systems: A Programmer's Perspective (3rd Edition)*](http://csapp.cs.cmu.edu/3e/home.html), Bryant & O'Hallaron, ISBN 0-13-409266-X.
    - Useful review of CSE 351 and background for many additional topics covered more extensively in CSE333.
- [*Effective C++: 55 Specific Ways to Improve Your Programs and Designs (3rd Edition)*](http://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/tags-on-product/0321334876), Scott Meyers. ISBN 0321334879.
- [*Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14*](http://www.amazon.com/Effective-Modern-Specific-Ways-Improve/dp/1491903996), Scott Meyers. ISBN 1491903996.


### Proposed Topic List

- C Programming and idioms (Memory Management, cstdio, error handling, and structs)
- System Management Tools (Makefiles, Header Guards, GDB, and Valgrind)
- System Interfacing with Operating Systems (POSIX)
- C++ Programming and idioms (namespaces, templates, STL, smart pointers)
- C++ Classes and Inheritance (Classes, operator overloading, OOP)
- Network Programming and Protocols (POSIX, HTTP)
- Concurrency (pthreads)

CSE 333 Systems Programming

Operating Systems

Address Space

Atomic instructions

Monitors

Starvation

Address translation

Page table

TLB (Translation Lookaside Buffer)

General I/O

Queueing Theory

Reliability

Distributed Decision Making

Remote Procedure Call (RPC)

Key-Value Stores

Quantum Computing

Threads & Processes

Fork

Sockets

Lock Implementation

Scheduling (computing)

Segments

Caching

Demand Paging Policies

Performance

End-to-End Arguments

TCP/IP

NFS & AFS

DataCapsules

Device Drivers

Concurrency

Mutual Exclusion

Lock (computer science)

Readers/Writers

Deadlock

Paging

Demand Paging

Storage Devices

Filesystem Design

Transactions

Distributed Storage

Chord

Inter-Process Communication (IPC)

Input/output

CS 162: Operating Systems and Systems Programming UC Berkeley Fall 2022 This course introduces operating systems design and related concepts. It covers topics like memory allocation, file systems, basic networking, transactions, and security. The course requires foundational knowledge in data structures, assembly language, C programming, and debugging. It aims to improve students' skills in debugging large programs and computational problem solving. The purpose of this course is to teach the design of operating systems and operating systems concepts that appear in other computer systems. Topics we will cover include concepts of operating systems, systems programming, networked and distributed systems, and storage systems, including multiple-program systems (processes, interprocess communication, and synchronization), memory allocation (segmentation, paging), resource allocation and scheduling, file systems, basic networking (sockets, layering, APIs, reliability), transactions, security, and privacy.  CS 61A, CS 61B, CS 61C, and CS 70, or equivalent courses. This means that you understand:

- Data structures: arrays, linked lists, binary trees, and hashing
- Assembly language programming
- The C programming language
- Debugging C using GDB
- CPU caches and memory hierarchy
- Virtual memory as covered in CS 61C
- CPU pipelines and basic digital logic design
- Basic knowledge of random variables and probability distributions as covered in CS 70


The TAs will spend a small amount of time reviewing some of the material you are less likely to remember. We will assume that you either know the material that is supposed to be covered in those courses, or that you are willing to learn the material as necessary. We will not spend time in lecture covering any of this material. **Perhaps more important than formal prequisites, however, is experience and maturity with debugging large programs, designing and implementing useful abstractions, and computational problem solving in general. This class will exercise your skills in these areas.**

If you feel that you would benefit from additional review of these prerequisites, we recommend using the following resources:

1. For a good review of probability as you’ll need it in this class, read through CS 70 Lecture Notes [15](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n15.pdf), [16](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n16.pdf), [17](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n17.pdf), [18](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n18.pdf), and [19](https://inst.eecs.berkeley.edu/~cs70/sp14/notes/n19.pdf).

1. Hennessy, John L. and Patterson, David A. *Computer Architecture: A Quantitative Approach*. 5th edition. **Although the main content of this book goes far more in-depth into computer architecture than you are expected to know for this class, the appendices provide an excellent overview of some of the prerequisites. Focus specifically on the sections below:**

- 2.1 and B.1 - B.4 (you can skip the sixth optimization in B.3) review caching, virtual memory, and memory hierarchies.
- C.1 - C.2 review CPU pipelines at the level of CS 61C. We are using the textbook “Operating Systems: Principles and Practice” by Anderson and Dahlin (A&D). The reading from this textbook is **strongly recommended**. There will be some additional readings that are not from this textbook that are freely available online. These will be linked on the course website in the "Readings" column for your viewing.

#### Strongly Recommended
[Operating Systems: Principles and Practice (2nd Edition)](http://ospp.cs.washington.edu/)
#### Recommended
[Operating Systems: Three Easy Pieces](http://pages.cs.wisc.edu/~remzi/OSTEP/)
#### Supplemental
[Linux Kernel Development (3rd Edition)](http://www.amazon.com/Linux-Kernel-Development-3rd-Edition/dp/0672329468)

CS 162: Operating Systems and Systems Programming

System call

System Calls

4 courses cover this concept

CS 110: Principles of Computer Systems

CS 110: Principles of Computer Systems

CSE 333 Systems Programming

CS 162: Operating Systems and Systems Programming