Lambda

Types

struct (C programming language)

Initialization

References

Streams

Containers

Iterators

Pointer (computer programming)

Class (computer programming)

Template Classes

Const Correctness

Template Functions

Function (computer programming)

Operators

Special Member Functions

Move Semantics

`std::optional`

Type Safety

Resource acquisition is initialization (RAII)

Smart pointer

Building C++ Projects

CS 106L Standard C++ Programming Stanford University Winter 2023 This is a companion course to CS106B/CS106X, diving into the modern C++ language. It covers some of the most exciting features of C++, including modern patterns that give it beauty and power. It is an intermediate-level course assuming familiarity with basic programming concepts. **CS 106L** is a companion class to CS106B/CS106X that explores the modern C++ language in depth. We'll cover some of the most exciting features of C++, including modern patterns that give it beauty and power.   

CS 106L Standard C++ Programming

Computer Programming

Boolean

Regular Expressions

Intermediate Representations

Register Allocation

Garbage Collection

Type Checking

Pattern Matching

Unary Operations

Binary Operations

Function Pointers

OCaml

S-Expression

Conditional (computer programming)

Handling Errors

First-Class Functions

Constant Folding

Compiler

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

Tkinter

Python

Arithmetic Expressions

Variable (computer science)

String (computer science)

List (abstract data type)

Tuple

Array slicing

Control flow

Debugging

For loop

Dictionary (data structure)

Set (abstract data type)

Modular programming

Exception handling

File system

Recursion (computer science)

Object-Oriented Programming (OOP)

Inheritance (object-oriented programming)

While loop

Assertion (software development)

API (Application Programming Interface)

Web API

Filter (higher-order function)

Event loop

Graphical User Interface (GUI)

CICS 110: Foundations of Programming  The University of Massachusetts Amherst Spring 2023 This course introduces computer programming and problem-solving. Students learn using a modern language, covering variables, data types, branching, functions, classes, and methods. Emphasis is on real-world problem translation, computational understanding, and debugging. An introduction to computer programming and problem solving using computers. This course teaches you how real-world problems can be solved computationally using programming constructs and data abstractions of a modern programming language. Concepts and techniques covered include variables, expressions, data types, objects, branching, iteration, functions, classes, and methods. We will also cover how to translate problems into a sequence of instructions, investigate the fundamental operation of a computational system and trace program execution and memory, and learn how to test and debug programs. No previous programming experience required. The objective of this course is to introduce the fundamentals of computing and programming using a general-purpose programming language from a modern perspective. This includes understanding the operation of a machine from a programming language perspective and what it means to execute a whole program as well as its individual parts, how to solve problems using constructs that a programming language provides such as variables, data types, objects, branching, iteration, functions, and classes, and how to write programs that receive data from various sources, process that data, and produce output in various forms.

## Learning Outcomes

At the completion of this course you will be able to:

- Read and write programs to solve non-trivial programs using the Python programming language.
- Describe fundamental units of computation and program structure.
- Translate real-world problems into computational solutions.
- Solve problems using a general-purpose programming language and the tools it provides such as variables, data types, objects, branching, iteration, functions/methods, and classes.
- Design and implement whole programs and functions to solve computational problems using top-down and bottom-up techniques.
- Describe application programming interfaces (API) and use APIs available from existing objects and libraries to solve problems.
- Translate data from and into various formats that are in computer memory, a graphical interface, a file, from a remote API on the web, or other data resources.
- Use console-based or graphical interfaces to learn about input/output to move data into and out of a program.
- Use modules and classes to organize data and functions.
- Explain the notion of a machine and how it relates to the execution of a general-purpose programming language.
- Explain how programs and their data are represented in a computer and build mental models and use diagrams of program and function execution and data stored in memory.
- Use basic debugging techniques such as “print debugging” and assert statements to determine the cause of logical programming errors and show the correctness of a program and its implementation.
- Describe programs using proper documentation techniques to communicate implementation details at various levels of granularity. R1 (or a score of 20 or higher on the math placement test Part A), or one of the following courses: MATH 101&102 or MATH 104 or MATH 127 or MATH 128 or MATH 131 or MATH 132. ## Textbook

The following textbook is required:

- Programming in Python 3, an interactive textbook from [zyBooks](https://learn.zybooks.com/) designed specifically for this course.

The information you need to subscribe to this book can be found on the course LMS (e.g., Moodle).

Here are some additional textbook recommendations freely available online. You may consider looking at these as supplemental material:

- Automate the Boring Stuff with Python, Al Sweigert, https://automatetheboringstuff.com
- A Byte of Python, https://www.gitbook.com/book/swaroopch/byte-of-python/details
- Dive into Python, Mark Pilgrim, http://getpython3.com/diveintopython3
- Learn python the hard way, Zed Shaw, http://learnpythonthehardway.org/book
- Python Practice Book, Anad Chitpothu, http://anandology.com/python-practice-book

CICS 110: Foundations of Programming 

Abstraction (computer science)

Loops

For Loop

Environment Diagrams

Dictionaries

Mutable Data

Linked list

Tree (data structure)

Generators

Databases

Higher-order function (HOF)

Abstract Data Type (ADT)

Tree Recursion

Efficiency

Programming Paradigms

CS 88: Computational Structures in Data Science UC Berkeley Fall 2022 This course provides an introduction to computer science with an emphasis on functional programming, data abstraction, object-oriented programming, and program complexity. The course teaches foundational programming concepts primarily in Python. CS 88 is a "connector" for Data 8 that is designed for students who would like a more complete introduction to Computer Science. We will cover a variety of topics such as functional programming, data abstraction, object-oriented programming, and program complexity. This course will be taught primarily in Python. However, we are interested in teaching you foundational programming ideas, not just how to use one particular programming language. Once you have learned the essence of programming and the concepts that appear in various forms in programming languages, you will be able to pick up other languages and other programming concepts rapidly.

The material for this course has significant overlap with CS 61A. We do not cover the interpretation section of CS61A. If you are certain that you want to major or minor in Computer Science, CS 61A is the right introductory course. You can take CS 61A for credit after having taken CS 88. However, you cannot take CS 88 for credit after having taken CS 61A. Data 8 and CS 88 together satisfy the knowledge prerequisite for CS 61B.  It is recommended, but not required, that you are currently enrolled in or have taken Data 8. There is no formal programming-related prerequisite for CS 88. You do not need to be familiar with any particular programming language. The online textbook for the course is [Composing Programs](http://composingprograms.com/), which was created specifically for CS61A but is also the best basis for this course. Readings for each lecture appear in the course schedule. We will be jumping around a little due to the data-centric orientation of the course. You should complete the readings before attending lecture.

In addition, the course website and Piazza will contain additional links to guides, handouts, and practice materials available for the course.

CS 88: Computational Structures in Data Science

Data Structures and Algorithms

Anonymous function

Lambda

4 courses cover this concept

CS 106L Standard C++ Programming

CS 164: Programming Languages and Compilers

CICS 110: Foundations of Programming

CS 88: Computational Structures in Data Science