Pointer (computer programming)

The GNU Debugger (GDB)

Recursion (computer science)

System Control Flow

C (programming language)

Executables

Virtual memory

C Programming

Floating Point

Buffer overflow

Memory & Data

x86 Programming

Array (data structure)

Memory & Caches

Integers

x86-64 Assembly

Binary

Bitwise Operators

Procedures & Recursion

Data structure alignment

Process (computing)

Computers and Society

The Stack & Procedures

Cache (computing)

Java (programming language)

Memory allocation

CSE 351 The HW/SW Interface University of Washington Autumn 2022 This course develops students' understanding of software functioning at different levels of abstraction. Focus areas include C, assembly, and low-level data representation. It also introduces concepts of operating systems and differences between Java and C. It serves as a starting point for those interested in hardware or high-level abstractions. This course should develop students' sense of what really happens when software runs – and that this question can be answered at several levels of abstraction, including the hardware architecture level, the assembly level, the C programming level, and the Java programming level. The core around which the course is built is C, assembly, and low-level data representation, but this is connected to higher levels (roughly how basic Java could be implemented), lower levels (the general structure of a processor), and the role of the operating system (but not how the operating system is implemented).

For (computer science) students wanting to specialize at higher levels of abstraction, this could, in the extreme, be the only course they take that considers the "C level" and below. However, most will take a subset of [Systems Programming (CSE333)](http://courses.cs.washington.edu/courses/cse333/), [Operating Systems (CSE451)](http://courses.cs.washington.edu/courses/cse451/), [Compilers (CSE401)](https://www.cs.washington.edu/education/courses/cse401/), etc.

For students interested in hardware, embedded systems, computer engineering, computer architecture, etc., this course is the introductory course after which other courses will delve both deeper (into specific topics) and lower (into hardware implementation, circuit design, etc.). Of particular interest are [Introduction to Digital Design (CSE369)](https://www.cs.washington.edu/education/courses/cse369/), [Design of Digital Circuits and Systems (CSE371)](https://www.cs.washington.edu/education/courses/cse371/), [Introduction to Embedded Systems (CSE474)](https://www.cs.washington.edu/education/courses/cse474/), and [Computer Architecture I (CSE469)](https://www.cs.washington.edu/education/courses/cse469/). At the end of this course, students should be able to:

- Describe the multi-step process by which a high-level program becomes a stream of instructions executed by a processor;
- Describe the basic organization of the memory hierarchy and the effect of its parameters on system performance;
- Trace the execution of assembly code (x86-64), map the assembly to high-level language constructs, and write simple pieces of assembly programs;
- Write C code using pointers to create and manipulate complex data structures;
- Write (or rewrite) code to be take advantage of the computer execution model to improve execution efficiency;
- Debug small-ish C and assembly programs using GDB;
- Explain the role of an operating system;
- Describe fundamental differences between Java and C.  Course Themes
## Course Themes

The course has four principal themes:

- Representation: How different data types (from simple integers to arrays of data structures) are represented in memory, how instructions are encoded, and how memory addresses (pointers) are generated and used to create complex structures.
- Translation: How high-level languages are translated into the basic instructions embodied in process hardware with a particular focus on C and Java.
- Control Flow: How computers organize the order of their computations, keep track of where they are in large programs, and provide the illusion of multiple processes executing in parallel.
- History and Society: The principles computers are built upon were influenced by the societal context of the historical periods in which they were designed and, in turn, computers influence society in ways far beyond pure computational power.

CSE 351 The HW/SW Interface

Computer Systems

Types

struct (C programming language)

Initialization

References

Streams

Containers

Iterators

Class (computer programming)

Template Classes

Const Correctness

Template Functions

Function (computer programming)

Lambda

Operators

Special Member Functions

Move Semantics

`std::optional`

Type Safety

Resource acquisition is initialization (RAII)

Smart pointer

Building C++ Projects

CS 106L Standard C++ Programming Stanford University Winter 2023 This is a companion course to CS106B/CS106X, diving into the modern C++ language. It covers some of the most exciting features of C++, including modern patterns that give it beauty and power. It is an intermediate-level course assuming familiarity with basic programming concepts. **CS 106L** is a companion class to CS106B/CS106X that explores the modern C++ language in depth. We'll cover some of the most exciting features of C++, including modern patterns that give it beauty and power.   

CS 106L Standard C++ Programming

Computer Programming

Abstract Data Structures

C++ Classes

Memory management

Implementation-level abstractions

Linked data structures

Python

Grids

Set (abstract data type)

Asymptotic Analysis

Backtracking

Sorting algorithm

Binary Search Trees

Graphs

String (computer science)

Stack (abstract data type)

Map (higher-order function)

Fractals

Dynamic Memory

Implementing `StackInt`

Linked list

Huffman Coding

Graph Shortest Path Algorithms

Queue (abstract data type)

Big-O notation

Procedural Recursion

Computer memory

Tree (data structure)

Hashing

Vector (C++)

Heap (data structure)

CS 106B Programming Abstractions Stanford University Winter 2023 This course helps transition from coding to problem-solving using computers. The course explores techniques, tools, and models for problem-solving across disciplines using C++. Prior programming experience is assumed. A nonprofit needs to assign tasks to its volunteers so they get completed as fast as possible. A political scientist wants to determine how to allocate city council seats based on a popular vote. A climatologist wants to estimate how many trees are in a forest. A city planner wants to see whether a proposed development will be underwater as sea levels rise. A physicist wants to know why perturbations to a system cause cascading effects.

How can we use computing power to answer these questions?

This course is about transitioning from “I know how to write programs” to “I know how to solve problems with computers.” Over the course of ten weeks, we’ll explore an array of techniques, tools, and perspectives useful for modeling and solving problems. We’ll explore recursion and see how it can be used both to model the intricacies of nature and to optimally allocate resources. We’ll develop a rich vocabulary of structures that can both capture the position of a dancer in space and compress a data file. And we’ll see how to put these techniques to use in problems drawn from a range of disciplines. By the time you’ve completed this course, you’ll learn how to look at problems in fundamentally different ways and how to use those perspectives to create clean and elegant computational solutions.  CS106B assumes that you have a familiarity with programming at the level of CS106A or the AP Computer Science exam. Check out [our course placement page](https://web.stanford.edu/class/archive/cs/cs106b/cs106b.1234/course_placement) for more information about deciding whether CS106B is right for you. As always, feel free to get in touch with us if you have any questions.

A note: although this class uses C++, this class is primarily designed to teach abstraction, recursion, and algorithmic analysis. If you already know those topics and just want to learn C++, you may want to opt to take CS106L instead of CS106B. The required reading for this course is Eric Roberts' *Programming Abstractions in C++*. You can purchase a copy at the bookstore using this link:

> https://www.bkstr.com/stanfordstore/search/keyword/programming%2520abstractions

You can also use this online version, which is a 2012 draft version of the book.

> https://web.stanford.edu/dept/cs_edu/resources/textbook/

We assume that the majority of you have no prior programming experience in C++, and this textbook is a great resource to use at the start of the quarter as you’re transitioning into the language.

A helpful note from the School of Engineering:

> *“All students should retain receipts for books and other course-related expenses, as these may be qualified educational expenses for tax purposes. If you are an undergraduate receiving financial aid, you may be eligible for additional financial aid for required books and course materials if these expenses exceed the aid amount in your award letter. For more information, review your award letter or visit the [Student Budget website](https://financialaid.stanford.edu/undergrad/budget/index.html).”*

CS 106B Programming Abstractions

Rust

Data structure

Modules

Compilation

Debugging

Makefiles

File I/O

Buffering

POSIX I/O

System Calls

Directories

C++ Programming

Introduction

Const

Constructors

new/delete

Casting

Client-side Networking

HTTP

Templates

Inheritance (object-oriented programming)

Networks

Server-side Networking

Standard Template Library (STL)

vtables

IP (Internet Protocol)

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

Machine organization

System Programming

Collection Summary

Signed number representations

Assembly language

Calling Conventions

Caching

Operating system

Privilege separation

Memory protection

Page table

Process Control

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

Memory representation

Control flow

Call stack

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 Strings

Assembly: Arithmetic and Logic

Trust

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