Unix

Assembly

Heap Allocator Work Time

Binary Representation

C Strings

Computer memory

Heap (data structure)

Integers

Bitwise Operators

String (computer science)

Generics

Explicit List

Stack (abstract data type)

CS 107A: Problem-solving Lab for CS 107 Stanford University Autumn 2022 This supplementary section provides extra support for CS 107 students. It offers an opportunity to review and practice course material in a small group setting, boosting understanding of CS 107 content. It uses a Satisfactory/No Credit grading scheme and is based on effort and participation. ### Welcome to 107A!

🌽 **CS 107A** is the [ACE](https://engineering.stanford.edu/students-academics/equity-and-inclusion-initiatives/undergraduate-programs/additional-calculus) section for [CS 107](https://cs107.stanford.edu), meeting two hours a week to give students an opportunity to review and practice course material in a smaller group setting. We also have CS 107A-specific office hours and support such as exam review sessions to help you do your best in CS 107.

### What is CS107A?

CS 107A is the ACE course for CS107. We spend two hours a week reviewing and practicing CS 107 material in a small-group environment. CS 107A also offers CS 107A-specific office hours and exam review sessions. CS 107A is worth 1 unit and uses a Satisfactory/No Credit grading scheme. Grading is based on effort and participation. If you feel like you would benefit from extra support as you take CS 107, Consider applying to take the course. If your application is accepted, you will be given a permission number in advance of the Add/Drop deadline to enroll in CS 107A on Axess, but you should attend class in the meantime anyway. - To provide students with extra opportunities to review and practice CS 107 material
- To provide an environment where students feel supported and part of a community as they take CS 107  About Ace
### About Ace

Additional Calculus for Engineers (ACE) is designed to provide the skills and solid foundation in mathematics, computational math in engineering, and computer science to undergraduate students interested in pursuing an engineering degree.

The goal of ACE is to increase confidence and increase content knowledge through small group interactive sessions and the academic resources provided to students enrolled in the program.

CS 107A: Problem-solving Lab for CS 107

Computer Systems

System R

File system

Flash File Systems

Isolation Levels

Transactional Recovery

Practical Byzantine Fault Tolerance

Exokernel

Resource Allocation and Scheduling

Edge Computing

Distributed Storage

MapReduce

Column Stores

Microkernels

Spectre Attack

Bigtable

Databases

End-To-End Arguments in System Design

File System Reliability

Transaction Locking

Concurrency

The Byzantine Generals Problem

Google File System (GFS)

Dynamo

seL4

Virtual Machine (VM)

Peer To Peer Networks

Distributed Consensus

Apache Spark

Security

CryptDB

CS 262a Advanced Topics in Computer Systems UC Berkeley Fall 2021 A graduate survey of systems managing computation and information. Topics include volatile and persistent memory management, system support for networking, security infrastructure, extensible systems, APIs, and large software system performance analysis. Students are expected to engage in quality systems research, culminating in a publishable group project. Graduate survey of systems for managing computation and information, covering a breadth of topics: early systems; volatile memory management, including virtual memory and buffer management; persistent memory systems, including both file systems and transactional storage managers; storage metadata, physical vs. logical naming, schemas, process scheduling, threading and concurrency control; system support for networking, including remote procedure calls, transactional RPC, TCP, and active messages; security infrastructure; extensible systems and APIs; performance analysis and engineering of large software systems. Homework assignments, exam, and term paper or project required.

The main work of this class is to read frequently and deeply, while working toward a group research project of publishable quality.  Each student will be individually responsible for writing up a short summary of every paper. There will be one midterm exam (albeit near the end), and no final exam. Research projects are a critical aspect of the course.  Your goal is to do some quality systems research; that is, to add to our understanding of how to build systems.  Research projects must be written up in a term paper, and will be presented in a poster in a departmental mini-conference.  Suggested project ideas will be provided by the instructors, but you are strongly encouraged to come up with your own project ideas.  Potential projects include implementation or analysis of some piece of an OS, a DBMS, or an Internet service; extending one of these systems with new functionality; or measurement and analysis of existing systems with the goal of better understanding issues in system design.   [CS 162](https://cs162.org/), or equivalent. There is no required textbook, but some of the papers are in [*Readings in Database Systems*](http://redbook.cs.berkeley.edu/). We will read and discuss 2-4 papers per week. Likely all of the papers will be available online.

General information: ISBN-10: 0-262-69314-3, ISBN-13: 978-0-262-69314-1

Link to MIT press site: [Readings in Database Systems, 4th Edition](http://mitpress.mit.edu/catalog/item/default.asp?tid=10480&ttype=2)

CS 262a Advanced Topics in Computer Systems

Bitwise Operations

x86-64

Privacy

C (programming language)

Assembly: Arithmetic and Logic

Trust

C Generics

Assembly: Control Flow

Managing the Heap

Buffer overflow

Data Representation

Array (data structure)

Function Pointers

Assembly: Function Call

Optimization

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

Thread (computing)

Interrupts

Input/output

Booting

Operating System Structure

Operating System Design

Scheduling (computing)

Virtual memory

Operating System Security

Communication protocol

Remote Procedure Call (RPC)

Distributed File Systems

Avoiding Operating Systems

CS167 Operating Systems Brown University Spring 2023 CS167 offers comprehensive insights into the principles and intricacies of operating systems. Topics range from multithreaded programming to file system designs. Students will not only grasp theoretical knowledge but also get hands-on experience, particularly through the optional lab CS169, where they can develop an operating system called Weenix. In this class, you'll have the opportunity to learn both the overarching principles of operating systems as well as the intricacies of how they work.

We'll cover topics including multithreaded programming; managing threads, interrupts, and storage; processor scheduling; operating system structure; virtualization; security; and the design of both local and distributed file systems. You'll develop your skill as a C programmer while simultaneously learning what goes on inside your computer from the moment you power it on.

As part of the class, if you are enrolled in CS167, you may choose to take the (optional) half-credit lab, CS169. If you do so, you will attend the same lectures and complete the written assignments as usual. However, you will only complete the first two programming assignments from CS167, before embarking on an in-depth project wherein you build much of the functionality of a small operating system called Weenix. It is a significant time investment, and you'll still get a lot from the class if you don't take the lab. Some thoughts on taking CS169 from previous students can be found [here](). CS267 covers the material of both CS167 and 169; it is for graduate students only. ### The Course

- Implement threads
- Learn about operating systems
- Implement one (Weenix)
    - file-system-related components (1670)
    - most of the rest of it (1690, 2670) ### Skills Needed

- Ability to write and debug largish programs in C with POSIX threads
    - CSCI 330/1330 or CSCI 300/1310 (you may want to review POSIX threads material from 330 lectures)
- Basic computer architecture
    - CSCI 330/1330 or CSCI 300/1310 ### Workload Components

- Four moderate programming assignments
    - UThreads: simple user-level threads package
    - MThreads: more sophisticated user-level threads package
    - VFS: system calls and high-level file system
    - S5FS: low-level file system
- One large programming assignment: Weenix
- combines VFS and S5FS, as well as Processes, Drivers, and Virtual Memory
- Four homeworks
- In-class TopHat questions

### Textbook

Operating Systems In Depth: Design and Programming, 1st Edition

CS167 Operating Systems

Operating Systems

Unix

4 courses cover this concept

CS 107A: Problem-solving Lab for CS 107

CS 262a Advanced Topics in Computer Systems

CS 107 Computer Organization & Systems

CS167 Operating Systems