Condition variables

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

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

Concurrent Threads

Scheduling (computing)

Linkers

File system

File System Crash Recovery

Virtual Machine (VM)

Lock (computer science)

Locks Implementation

Dynamic Linking

Demand Paging

Protection

Dispatching

Deadlock

Dynamic Storage Management

Disk Devices

Flash Memory

Threads & Processes

CS 140: Operating Systems Stanford University Spring 2020 This course provides an in-depth understanding of the basic facilities provided by modern operating systems. It's structured into three major sections: concurrency, memory management, and file systems, followed by some smaller topics like virtual machines. The class includes one problem set and four programming projects based on the Pintos kernel, requiring a significant commitment of time. This class introduces the basic facilities provided by modern operating systems. The course divides into three major sections. The first part of the course discusses concurrency: how to manage multiple tasks that execute at the same time and share resources. Topics in this section include processes and threads, context switching, synchronization, scheduling, and deadlock. The second part of the course addresses the problem of memory management; it will cover topics such as linking, dynamic memory allocation, dynamic address translation, virtual memory, and demand paging. The third major part of the course concerns file systems, including topics such as storage devices, disk management and scheduling, directories, protection, and crash recovery. After these three major topics, the class will conclude with a few smaller topics such as virtual machines.

The class work consists of one problem set and a series of four programming projects based on the Pintos kernel. You will learn a lot from these projects, but be prepared to spend a significant amount of time working on them.   There is no required textbook for this class: the material of the course is defined by the lectures and does not exactly correspond to any existing book. However, I recommend the following book if you would like an additional source of material to supplement lectures:

- [Operating Systems: Principles and Practice (2nd Edition)](http://www.amazon.com/Operating-Systems-Principles-Thomas-Anderson/dp/0985673524/ref=pd_sim_14_2?ie=UTF8&dpID=51SFTQvZ7zL&dpSrc=sims&preST=_AC_UL160_SR123%2C160_&refRID=0ZR0KTC2DWEZCFFVAR26), by Thomas Anderson and Michael Dahlin.

Each page of lecture notes lists related readings in this book at the front of the notes page. Most students find that the material from lecture is sufficient for their course needs, so I recommend that you start the course without the book and only purchase the book if you are having difficulties understanding the lectures.

CS 140: Operating Systems

Operating Systems

Concurrency

Magnetic Disks

Virtual Machine Monitors

Lock Implementation

CS 111 Operating Systems Principles Stanford University Autumn 2022 An introductory course to operating systems, CS 111 builds upon programming experience to explore how operating systems function. The course provides an understanding of OS design challenges, such as filesystems, system calls, concurrency, virtual memory, demand paging, and others. Knowledge in C/C++ and Unix/Linux environment is prerequisite. CS111 is Stanford's introductory operating systems course. The CS106 courses provide you with a solid foundation in programming methodology and abstractions, and CS107 builds up and expands your breadth and depth of programming experience and techniques, working from the C programming language down to the microprocessor to de-mystify the machine. CS111 leverages this programming experience to introduce operating systems and how they work. With an understanding of both how to leverage operating system functionality in your own programs as well as how operating systems manage tasks behind the scenes, you will have a better understanding of how operating systems work, the kinds of design challenges present in operating systems and other large systems, and key computing ideas such as virtualization that are applicable in many different areas. Topics covered include: filesystems, system calls, concurrency, multiprocessing, multithreading, race conditions, synchronization primitives, virtual memory, demand paging and operating system design challenges.  The prerequisite for CS111 is CS107 (or equivalent). You should have practical C/C++ skills and be able to write programs with complex use of memory and pointers and dynamic memory allocation (`malloc`/`realloc`/`free`/`new`/`delete`). You should understand C++ classes, methods, and be able to work with appropriate data structures (arrays, maps, etc.) and standard algorithms (searching, sorting, hashing). (There are C++ features you're not expected to know, but you should be comfortable picking those features up and consulting references as needed). You should be familiar with programming in a Unix/Linux environment using tools such as `make`, `gcc/g++`, `valgrind`, `gdb`, etc. and have a working understanding of the basics of computer architecture (x86-64 as it’s taught in CS107, or exposure to some other architecture and the ability to pick up x86-64 as we reference it). Come talk with us if you need help determining the right placement for you. ### CS111A

CS111A, also called Pathfinders (or ACE), is a supplementary instruction program that meets for a weekly section and holds Pathfinders-specific review sessions. CS111A is application-only; CS111A is done in addition to all the normal requirements for CS111. You will receive an extra unit of course credit for the work you do in this program. Enrollment in CS111A is by application, and you can find more information at this link: [click here](https://engineering.stanford.edu/students-academics/equity-and-inclusion-initiatives/undergraduate-programs/additional-calculus). Once enrollment decisions are made, students who are accepted will then be given a permission number to enroll in CS111A on Axess. If you have questions about CS111A, please email the ACE CA (contact information listed on the course homepage).

### Textbook

There is no required textbook for CS111: the material of the course is defined by the lectures and does not exactly correspond to any existing book. However, we recommend the following book if you would like an additional source of material to supplement lectures:

*Operating Systems: Principles and Practice (2nd Edition), by Thomas Anderson and Michael Dahlin.*

Each lecture lists related readings in this book on the first slide, where applicable. Most students find that the material from lecture is sufficient for their course needs, so we recommend that you start the course without the book and only purchase the book if you decide you would like additional material and explanations beyond what is in lecture.

CS 111 Operating Systems Principles

Machine organization

C Programming

Pointer (computer programming)

String (computer science)

Memory representation

Memory allocation

Array (data structure)

struct (C programming language)

Signed number representations

Data structure alignment

Assembly language

Control flow

Call stack

Buffer overflow

Caching

Privilege separation

Memory protection

Page table

Address translation

Inter-process communication

Atomic instructions

Bounded-buffer problem

CSCI 0300: Fundamentals of Computer Systems Brown University Spring 2023 Introductory course covering computer system fundamentals including machine organization, systems programming in C/C++, operating systems concepts, isolation, security, virtualization, concurrency, and distributed systems. Projects involve implementing core OS functionality. CSCI 0300 covers fundamental concepts, principles, and abstractions that underlie the design and engineering of computer systems. You will learn how a computer works, how to write safe and performant systems software, and what systems abstractions support today's complex, high-performance systems developed in industry. Specific topics include machine organization, systems programming and performance, key concepts of operating systems, isolation, security, virtualization, concurrent programming, and the basics of distributed systems.

The course format is a combination of lectures, labs, and several hands-on projects involving programming exercises in C/C++. The goal of CSCI 0300/CS 300 is to teach the fundamentals behind the "magic" of computer systems from the hardware level to the global internet. We'll cover the ideas, principles and abstractions that unify computer systems design – from how your laptop runs multiple programs at the same time, to how companies like Instagram, Airbnb, and Google operate large websites, to how easy it is to exploit security vulnerabilities on badly designed systems. This is a great class for students who are interested in learning what systems programming is, how systems work, and why these systems are so critical to modern technology. This is an introductory computer systems course, designed to expose students to a broad set of fundamental concepts in computer systems and their practical applications. It is best suited for students who have completed the intro sequence, and to those who may want to deepen their understanding of systems concepts. Programming languages used in assignments include C and C++. ## CSCI 0300 highlights

- *Learn how a computer really works:* we'll look into what happens when a program runs, from the basics to high-level concepts!
- *Use industry-strength tools:* CSCI 0300 teaches you modern C/C++ programming with the tools that professional software engineers use!
- *Two programming languages for the price of one:* learn C and C++, two widely-used systems programming languages for high-performance software!
- *Real-world inspired projects:* in CSCI 0300's projects, you'll implement the core of your own operating system, and learn to build scalable infrastructure such as a distributed data store and a multi-threaded server similar to those companies use to run web services you use every day!

CSCI 0300: Fundamentals of Computer Systems

Condition variables

5 courses cover this concept

CS 110: Principles of Computer Systems

CS 110: Principles of Computer Systems

CS 140: Operating Systems

CS 111 Operating Systems Principles

CSCI 0300: Fundamentals of Computer Systems