Calling Conventions

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

Stack (abstract data type)

Caching

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

Register Allocation

Static Single-assignment (SSA)

Control-flow Graph (CFG)

Basic Blocks

Instruction Selection

Middle End

Dataflow Analysis

Dataflow Theory

Lexing

Parsing

Typechecking

Static Semantics

Dynamic Semantics

Mutable Store

Loops

Partial Redundancy Elimination

Locality

Instruction Scheduling

Alias Analysis

15-411 Compiler Design Carnegie Mellon University Fall 2020 Comprehensive study of compiler design and implementation, examining interaction between language design and runtime organization. Topics include program analysis, code generation, optimization, memory management. This course covers the design and implementation of compiler and runtime systems for high-level languages, and examines the interaction between language design, compiler design, and runtime organization. Topics covered include lexical and syntactic analysis, type-checking, program analysis, code generation and optimization, memory management, and runtime organization. - Distinguish the main phases of a state-of-the-art compiler
- Understand static and dynamic semantics of an imperative language
- Develop parsers and lexers using parser generators and combinators
- Perform semantic analysis
- Translate abstract syntax trees to intermediate representations and static single assignment form
- Analyze the dataflow in an imperative language
- Perform standard compiler optimizations
- Generate efficient assembly code for a modern architecture
- Allocate registers using a graph-coloring algorithm
- Understand opportunities and limitations of compiler optimizations
- Appreciate design tradeoffs how representation affects optimizations
- Automatically manage memory using garbage collection
- Develop complex software following high-level specifications  

15-411 Compiler Design

Compilers

X86 calling conventions

Calling Conventions

2 courses cover this concept

CS 131: Fundamentals of Computer Systems

15-411 Compiler Design