Caching

Machine organization

String (computer science)

Vector (C++)

System Programming

Memory allocation

Array (data structure)

Pointer (computer programming)

struct (C programming language)

Data structure alignment

Collection Summary

Signed number representations

Assembly language

Calling Conventions

Stack (abstract data type)

Operating system

Privilege separation

Memory protection

Virtual memory

Page table

Process Control

Process (computing)

Inter-Process Communication (IPC)

Thread (computing)

Race condition

Synchronization (computer science)

Synchronization Patterns

Deadlock

Networking

Scalability

Distributed Scalability

Failures

Consistency (database systems)

Real-world Distributed Systems

CS 131: Fundamentals of Computer Systems Brown University Spring 2020 This course delves deep into the foundational principles behind computer systems, ranging from hardware intricacies to the vast global internet. Students gain insights into systems programming, the architecture of computer systems, concurrency, and the dynamics of distributed systems. Notably, the curriculum includes projects that offer hands-on experience, like building library functions, creating a toy OS, and designing a scalable key-value storage service. It's a stepping stone to advanced courses like Distributed Systems, Databases, and Computer Systems Security. The goal of **CS 131/CSCI 1310** 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. We will look at topics arranged in four main blocks during the course, building up your understanding across the whole systems stack:

1. **Computer Systems Basics**: programming in systems programming languages (C and C++); memory; how code executes; and why machine and memory organization mean that some code runs much faster than other code that implements the same algorithm.
    *Project*: you will build your own versions of standard library functions and a vector data structure (strvec), and you will develop your own debugging memory allocator, helping you understand common memory bugs in systems programming languages (DMalloc).
1. **Fundamentals of Operating Systems**: how your computer runs even buggy or incorrect programs without crashing; how it keeps your secrets in one program safe from others; and how an operating system like Windows, Mac OS X, or Linux works.
    *Project*: you will implement memory isolation via virtual memory in your own toy operating system (WeensyOS)!
1. **Concurrency and Parallel Programming**: how your computer can run multiple programs at the same time; how you can share memory even if running programs on multiple processors; why programming with concurrency is very difficult; and how concurrency is behind almost all major web services today.
    *Project*: you will implement the server-side component of a peer payment application called "Vunmo", and make it handle requests from many users.
1. **Distributed Systems**: what happens when you use more than one computer and have computers communicate over networks like the Internet; how hundreds of computer can work together to solve problems far too big for one computer; and how programs running distributedly can survive the failure of participating computers.
    *Project*: you will implement a sharded key-value storage service that can (in principle) scale over hundreds or thousands of machines.

The first block, Computer Systems Basics, begins today. It's about how we represent data and code in terms the computer can understand. But today's lecture is also a teaser lecture, so we'll see the material raise questions that you cannot yet answer (but you will, hopefully, at the end of the course!). CS 131/CSCI 1310 is open to anyone who has completed the introductory sequence (i.e., CS 16, 18, or 19). For students who don't satisfy the registration restrictions on CAB, please request an override code on CAB and include an explanation of your course experience, and we'll review your request. **What does CS 131 count for?** CS 131/CSCI 1310 is a 1000-level course that can count as a related course in the systems pathway of the CS concentration and masters. In addition, CS 131 will satisfy the prerequisites for CSCI 1380 (Distributed Systems), CSCI 1270 (Databases), CSCI 1650 (Software Security and Exploitation), CSCI 1660 (Computer Systems Security), CSCI 1730 (Programming Languages), CSCI 1951-A (Data Science), CSCI 1680 (Computer Networks), and CSCI 2390 (Privacy-Conscious Computer Systems).

CS 131: Fundamentals of Computer Systems

Computer Systems

C Programming

Memory representation

Control flow

Call stack

Buffer overflow

Address translation

Inter-process communication

Pipeline (Unix)

Multiprocessing

Atomic instructions

Mutexes (Mutual exclusion)

Bounded-buffer problem

Condition variables

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

Unix

Bitwise Operations

x86-64

Privacy

Assembly

C (programming language)

C Strings

Heap (data structure)

Assembly: Arithmetic and Logic

Trust

Integers

C Generics

Assembly: Control Flow

Managing the Heap

Data Representation

Function Pointers

Assembly: Function Call

Optimization

Overflow

Reverse Engineering

CS 107 Computer Organization & Systems Stanford University Autumn 2022 This Stanford University course delves into the depths of computer systems and programming. It continues from the introductory sequence, expanding students' programming experience using the C language, exploring machine-level code, computer arithmetic, memory management, and more. CS107 is the third course in Stanford's introductory programming sequence. The CS106 courses provide you with a solid foundation in programming methodology and abstractions, and CS107 follows on this to build up and expand your breadth and depth of programming experience and techniques. The course will work from the C programming language down to the microprocessor to de-mystify the machine. With a complete understanding of how computer systems execute programs and manipulate data, you will become a more effective programmer, especially in dealing with issues of debugging, performance, memory, and robustness. Topics covered include: the C programming language, data representation, machine-level code, computer arithmetic, elements of code compilation, optimization of memory and runtime performance, and memory organization and management.

### CS107A

CS107A, also called Pathfinders (or ACE), is a supplementary instruction program that meets for a weekly section and holds Pathfinders-specific review sessions. CS107A is application-only; please see the [FAQ](https://web.stanford.edu/class/archive/cs/cs107/cs107.1232/faq.html) page for more information. The goals for CS107 are for students to gain mastery of

- writing C programs with complex use of memory and pointers
- an accurate model of the address space and compile/runtime behavior of C programs

to achieve **competence** in

- translating C to/from assembly
- writing programs that respect the limitations of computer arithmetic
- identifying bottlenecks and improving runtime performance
- working effectively in a Unix development environment
- using ethical frameworks and case studies to inform decision-making

and have **exposure** to

a working understanding of the basics of computer architecture The prerequisite for CS107 is CS106B/X (or equivalent). You should have practical C/C++ skills using recursion, dynamic data structures (pointers, linked lists, trees, graphs), data abstraction, classic data structures (lists, stacks, queues, sets, maps), and standard algorithms (searching, sorting, hashing). You should have an appreciation of the intrinsic value of good engineering and design and you will be expected to produce well-decomposed, readable code. Come talk with us if you need help determining the right placement for you. **Required**: Bryant & O’Hallaron. Computer Systems: A Programmer’s Perspective. 3rd Edition.

The bookstore has a less-expensive custom version of this textbook for our course that includes only the chapters we will cover; you can also use the regular full 3rd edition. You will need the 3rd edition of the textbook, which has substantial updates from IA32 to x86-64. There will be assigned readings from this textbook that are important preparation for lecture and lab. For readings that we assign, you can view a free digital PDF copy of the textbook on Canvas under the "Files" tab.

**Strongly recommended**: We also strongly recommend you have a "C language goto" in whatever form works best for you: textbook, tutorial, reference sheet, website, etc. As one suggestion, The C Programming Language by Kernighan and Ritchie is the classic text and a digital copy is available for checkout via [Open Library](https://openlibrary.org/books/OL2030445M/The_C_Programming_Language) (make a free account to "borrow" it digitally). Another option is Nick Parlante's Essential C reader PDF [available here](http://cslibrary.stanford.edu/101).

There is also a CS107 reader written by Chris Gregg, another CS107 instructor: [https://web.stanford.edu/~cgregg/cgi-bin/107-reader](https://web.stanford.edu/~cgregg/cgi-bin/107-reader), which covers all of the course topics in detail.

Our lecture readings pull from Bryant & O'Halloran, Kernighan & Ritchie, and Essential C.

CS 107 Computer Organization & Systems

Address Space

Monitors

Starvation

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

Semaphores

Scheduling (computing)

Computer memory

Segments

Demand Paging Policies

Performance

Buffering

End-to-End Arguments

TCP/IP

NFS & AFS

DataCapsules

System Calls

Device Drivers

Concurrency

Mutual Exclusion

Lock (computer science)

Readers/Writers

Paging

Demand Paging

Storage Devices

Filesystem Design

Transactions

Distributed Storage

Chord

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

Operating Systems

Cache (computing)

Caching

4 courses cover this concept

CS 131: Fundamentals of Computer Systems

CSCI 0300: Fundamentals of Computer Systems

CS 107 Computer Organization & Systems

CS 162: Operating Systems and Systems Programming