C Programming

Pointer (computer programming)

The GNU Debugger (GDB)

Recursion (computer science)

System Control Flow

C (programming language)

Executables

Virtual memory

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

Rust

Function (computer programming)

Computer memory

Heap (data structure)

Data structure

Modules

Compilation

Debugging

Makefiles

File I/O

Buffering

POSIX I/O

System Calls

Directories

C++ Programming

Introduction

References

Const

Constructors

Class (computer programming)

new/delete

Smart pointer

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

String (computer science)

Memory representation

struct (C programming language)

Signed number representations

Assembly language

Control flow

Call stack

Caching

Privilege separation

Memory protection

Page table

Address translation

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

C Programming

3 courses cover this concept

CSE 351 The HW/SW Interface

CSE 333 Systems Programming

CSCI 0300: Fundamentals of Computer Systems