Call stack

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

Buffer overflow

Caching

Privilege separation

Memory protection

Virtual memory

Page table

Address translation

Process (computing)

Inter-process communication

Pipeline (Unix)

Multiprocessing

Thread (computing)

Race condition

Synchronization (computer science)

Atomic instructions

Mutexes (Mutual exclusion)

Deadlock

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

Computer Systems

Cryptography

Diffie-Hellman key exchange

Bitcoin

UI Attacks

WPA (WiFi Protected Access)

DNS (Domain Name System)

Malware

Cookies

Memory Safety Vulnerabilities

Pseudorandom Number Generator (PRNG)

Passwords

Cross-Site Scripting (XSS)

DHCP (Dynamic Host Configuration Protocol)

Transport Layer Security (TLS)

Intrusion Detection

Asymmetric Key Cryptography

x86 assembly language

Cryptographic Hashes

Digital signature

Session Management

Networking

TCP (Transmission Control Protocol)

Denial-of-Service (DoS) Attacks

Message authentication code (MAC)

Certificates

Cross-Site Request Forgery (CSRF)

ARP (Address Resolution Protocol)

UDP (User Datagram Protocol)

Firewalls

Memory Safety

Security Principles

Public-key cryptography

Same-Origin Policy

DNSSEC

Anonymity

SQL Injection

Symmetric-key Cryptography

Border Gateway Protocol (BGP)

CS 161: Computer Security UC Berkeley Summer 2022 This course offers an introduction to computer security, including cryptography, operating system security, network security, and software security. It uses case studies from real-world systems. Prerequisites include experience working with large codebases and a basic understanding of modular arithmetic/set notation. Introduction to computer security. Cryptography, including encryption, authentication, hash functions, cryptographic protocols, and applications. Operating system security, access control. Network security, firewalls, viruses, and worms. Software security, defensive programming, and language-based security. Case studies from real-world systems.  The prerequisites for CS 161 are:

- CS 61B (Data Structures), for experience working with large codebases (500–1000 lines of code) and basic data structures. This is relevant for Project 2.
- CS 61C (Machine Structures), for understanding of C memory layout and hex/binary number representation. This is relevant for the memory safety unit (Project 1). All necessary CS 61C content will be reviewed during lecture.
- CS 70 (Discrete Math and Probability Theory), for basic understanding of modular arithmetic/set notation and some mathematical intuition. This is relevant in the cryptography unit. We will review any necessary CS 70 content in lectures, so don’t worry if you don’t feel very comfortable with all the CS 70 material.

We assume basic knowledge of C and Python. Some basic familiarity with Unix systems is helpful for Project 1. Project 2 is done in Go and we won’t have any lectures on Go syntax, so we expect students to be able to learn the basics of the language on their own. The readings are all linked on [the course website](https://su22.cs161.org/) and freely available. The majority of readings come from the [course textbook](https://textbook.cs161.org/), which is freely available for you to use as a study and review resource. All readings are optional (but recommended) unless otherwise indicated.

CS 161: Computer Security

Computer Security and Cryptography

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

CS 240 Foundations of Computer Systems

Call stack

3 courses cover this concept

CSCI 0300: Fundamentals of Computer Systems

CS 161: Computer Security

CS 240 Foundations of Computer Systems