Process (computing)

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

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

Filesystems

Directories

System Calls

Multiprocessing

Job Control

Pipeline (Unix)

Browser Design

Semaphores

Networking

Protocols

TCP (Transmission Control Protocol)

Async I/O

Large Files

Links

Synchronization (computer science)

execvp

Signals

Thread (computing)

Mutexes (Mutual exclusion)

Condition variables

Threading

IP (Internet Protocol)

MapReduce

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

CS 110: Principles of Computer Systems

Machine organization

String (computer science)

Vector (C++)

System Programming

struct (C programming language)

Collection Summary

Signed number representations

Assembly language

Calling Conventions

Stack (abstract data type)

Caching

Operating system

Privilege separation

Memory protection

Page table

Process Control

Inter-Process Communication (IPC)

Race condition

Synchronization Patterns

Deadlock

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

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

Combinational Logic

C Pointers

Digital Logic

Arithmetic Logic

C Arrays

Memory hierarchy

Transistors to Gates

Sequential logic

Exceptional Control Flow (ECF)

Data as Bits

Processor Datapath

Process modeling

Software Tools

Floating Point Number Representation

Representing Data Structures

Shell (computing)

Integer Representation

Programming with Memory

CS 240 Foundations of Computer Systems Wellesley College Spring 2023 This course explores the inner workings of computers, focusing on how they execute programs. Students gain an in-depth understanding of software and hardware abstractions, ranging from programming languages to transistors. Key areas covered include computational building blocks, hardware-software interfaces, data representation, and practical system abstractions. The course also emphasizes structured reasoning about program execution and promotes skills for independent learning, critical thinking, and problem-solving in computer science. CS 240 examines how computers run programs, introducing key abstractions and implementations in software and hardware between programming languages and transistors. ## Goals

Course goals include:

- To understand how computers execute programs.
- To understand the roles of key software and hardware abstractions, their implementations, and their relation through translation and representation, including: digital logic, microarchitecture, instruction set architecture, the memory hierarchy, basics of programming language implementations, and operating system abstractions.
- To understand when and how computer system implementation impacts correctness or performance of arbitrary high-level programs.
- To become proficient in structured reasoning about the execution of programs on well-defined models, including the use of assertions and debugging tools to inspect program invariants and execution state.
- To develop foundations for further study of programming language implementation, security, computer architecture, operating systems, networks, concurrent and distributed systems, or other systems/implementation topics in computer science.
- [**To develop skills for independent learning, critical thinking, and problem-solving as a self-reliant computer scientist.**](#compact)

## Topics

The [course home page](https://cs.wellesley.edu/~cs240/s23/) hosts the working schedule. +Optional extensions are prefixed in the schedule with a plus sign. We may visit these if there is time. They are always available for your own exploration in further depth.

**Computational Building Blocks:**

- Hardware computation building blocks: 
    - Transistors, digital logic gates
    - Combinational and arithmetic logic
    - Sequential (stateful) logic
    - Overview of computer processor architecture
- Data representation fundamentals: 
    - Data representation with bits, bit-level computation
    - Number representation, arithmetic
    - The memory model, pointers, and arrays in the C language
    - Assertions, debugging

**Hardware-Software Interface:**

- The instruction set architecture model, machine code, assembly language, x86
- Basic program translation
- Control flow
- Procedures, call stack
- Data layout, security implications

**Abstractions for Practical Systems:**

- The memory hierarchy, caches
- Memory allocation
- Operating system basics: 
    - Exception control flow
    - The process model
    - Virtual memory
- Compilers, run-time systems, programming tools
- Beyond 240 ### When Should You Take CS 240?

**Prerequisite:** CS 230 or permission of the instructor is **required** to enroll in CS 240.

**Recommendations:**

- Consider your courseload carefully. CS 240 is a 1.25-credit lab course that requires a larger time commitment and workload than most 1-credit courses.
- Take CS 240 early after finishing the CS 111 / CS 230 introductory sequence. CS 240 should boost your independence, give valuable context for *how things work* as you approach further computing studies, and open doors to a wide range of courses and areas in CS.

Please talk to the [instructors](#staff) if you have any questions or concerns. We are happy to work with you to make your time in CS 240 most effective and rewarding for you. ### Texts

Electronic options are available for all required sources. At least one physical copy of each text is also available in the physical SCI L037 CS Systems Lab **for use within the CS department area.**Please use them in the data lab area and return them to the shelf when you are done.

**We use one primary textbook extensively:**

- **CSAPP 3e** ([*Wellesley online access*](https://drive.google.com/drive/folders/1eFNJ7GqAHH8_W4dNv0UC4qkZX-kEMQH_?usp=sharing)):   
    [*Computer Systems: A Programmer’s Perspective, 3/E*](http://csapp.cs.cmu.edu). (**3rd edition**, significant changes since 2nd)   
    Bryant and O’Hallaron, Pearson, 2016. ISBN-13: 9780134092669. 
    - We **need the 3rd edition**. See [the errata](http://csapp.cs.cmu.edu/3e/errata.html).
    - Unfortunately, the library is not able to acquire an electronic version, but there are several options to access the book, including, but not limited to: 
        - If you prefer physical books, paperback copies are available for much less than the hardcover version. “Global” 3rd editions mostly work, but have some additional errors (not listed on the errata page).
        - [6 months of access to an electronic version is available for $35.](https://www.vitalsource.com/products/computer-systems-a-programmer-39-s-perspective-randal-e-bryant-david-r-v9780134092997)
        - During difficult pandemic circumstances, [we have scans of the relevant excerpts available for CS 240 students (Wellesley ONLY)](https://drive.google.com/drive/folders/1eFNJ7GqAHH8_W4dNv0UC4qkZX-kEMQH_?usp=sharing). Being scans, these excerpts are not quite as good quality as some other electronic or paper options.
    - Please contact the instructors if none of the available options work for you.

**Other textbooks are used during the first part of the course:**

- **DDCA** ([*Wellesley online access*](https://ebookcentral.proquest.com/lib/well/detail.action?docID=404196)):   
    [*Digital Design and Computer Architecture*](https://ebookcentral.proquest.com/lib/well/detail.action?docID=404196).   
    Harris and Harris, Morgan Kaufmann, 2007. 
    - [The library has an electronic version of this text](https://ebookcentral.proquest.com/lib/well/detail.action?docID=404196)

**We recommend a good reference on the C programming language.**Here are a couple solid options:

- **[Essential C](http://cslibrary.stanford.edu/101/)** (PDF)  
    Nick Parlante, 2003. Stanford University.
- **K&amp;R:**  
    [*The C Programming Language, 2nd edition*](http://luna.wellesley.edu/record=b1630956~s1).   
    Kernighan and Ritchie, Prentice Hall, 1988. ISBN-13: 978-0131103627, ISBN-10: 0131103628.

**Additional materials** will be posted directly on the [course website](/~cs240/s23/).