Function Pointers

Boolean

Function (computer programming)

Lambda

Regular Expressions

Intermediate Representations

Register Allocation

Garbage Collection

Type Checking

Pattern Matching

Unary Operations

Binary Operations

OCaml

S-Expression

Conditional (computer programming)

Handling Errors

First-Class Functions

Constant Folding

Compiler

Types

Correctness and Testing

Naming Expressions

Tail Call Optimization

Functional Programming (FP)

Custom Types

Pairs

Parsing

Optimization

CS 164: Programming Languages and Compilers UC Berkeley Fall 2022 Explores how compilers translate high-level languages into machine-understandable code, offering practical experience with developing compilers for various languages. Also covers reasoning about compiler correctness and understanding runtime errors.  Have you ever wondered why C programs seem to run faster than Python programs? Have you ever been confused by an error message and wondered why Java couldn’t understand your program? In CS 164, we’ll learn how compilers take in code in one language and produce code in another; in particular, we’ll learn how to translate high-level languages into code that your computer’s processor can understand. We’ll get hands-on practice developing compilers for a series of increasingly complex languages. Along the way, we’ll learn some general best practices for developing and testing complex software systems. After completing this course, students will be able to:

- Develop programs to translate between different programming languages
- More broadly, develop programs that operate on programs
- Explain the relationship between compilers and interpreters, and the differences between them
- Understand the tools they use to run programs—and the errors those tools produce
- Assign meaning to high-level language constructs
- Implement high-level language constructs
- Reason about what it means for a compiler to be correct
- Reason about undefined behavior
- Read and write assembly language
- Write a parser - [CS 61B. Data Structures](https://www2.eecs.berkeley.edu/Courses/CS61B/)
- [CS 61C. Machine Structures](https://www2.eecs.berkeley.edu/Courses/CS61C/)

### Course Culture

Students taking CS 164 come from a wide range of backgrounds. We hope to foster an inclusive and safe learning environment based on curiosity rather than competition. All members of the course community—the instructor, students, and GSIs—are expected to treat each other with courtesy and respect. Some of the responsibility for that lies with the staff, but a lot of it ultimately rests with you, the students. There is no textbook for the course; all readings will be provided digitally.

CS 164: Programming Languages and Compilers

Compilers

Programming Languages

Unix

Bitwise Operations

x86-64

Privacy

Assembly

Stack (abstract data type)

C (programming language)

C Strings

Heap (data structure)

Assembly: Arithmetic and Logic

Trust

Integers

C Generics

Assembly: Control Flow

Managing the Heap

Buffer overflow

Data Representation

Array (data structure)

Assembly: Function Call

Overflow

Pointer (computer programming)

Reverse Engineering

Caching

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

Computer Systems