Set (abstract data type)

Abstract Data Structures

Recursion (computer science)

C++ Classes

Memory management

Implementation-level abstractions

Linked data structures

Python

Grids

Asymptotic Analysis

Backtracking

Pointer (computer programming)

Sorting algorithm

Binary Search Trees

Graphs

String (computer science)

Stack (abstract data type)

Map (higher-order function)

Fractals

Dynamic Memory

Implementing `StackInt`

Linked list

Huffman Coding

Graph Shortest Path Algorithms

Queue (abstract data type)

Big-O notation

Procedural Recursion

Computer memory

Tree (data structure)

Hashing

Vector (C++)

Heap (data structure)

CS 106B Programming Abstractions Stanford University Winter 2023 This course helps transition from coding to problem-solving using computers. The course explores techniques, tools, and models for problem-solving across disciplines using C++. Prior programming experience is assumed. A nonprofit needs to assign tasks to its volunteers so they get completed as fast as possible. A political scientist wants to determine how to allocate city council seats based on a popular vote. A climatologist wants to estimate how many trees are in a forest. A city planner wants to see whether a proposed development will be underwater as sea levels rise. A physicist wants to know why perturbations to a system cause cascading effects.

How can we use computing power to answer these questions?

This course is about transitioning from “I know how to write programs” to “I know how to solve problems with computers.” Over the course of ten weeks, we’ll explore an array of techniques, tools, and perspectives useful for modeling and solving problems. We’ll explore recursion and see how it can be used both to model the intricacies of nature and to optimally allocate resources. We’ll develop a rich vocabulary of structures that can both capture the position of a dancer in space and compress a data file. And we’ll see how to put these techniques to use in problems drawn from a range of disciplines. By the time you’ve completed this course, you’ll learn how to look at problems in fundamentally different ways and how to use those perspectives to create clean and elegant computational solutions.  CS106B assumes that you have a familiarity with programming at the level of CS106A or the AP Computer Science exam. Check out [our course placement page](https://web.stanford.edu/class/archive/cs/cs106b/cs106b.1234/course_placement) for more information about deciding whether CS106B is right for you. As always, feel free to get in touch with us if you have any questions.

A note: although this class uses C++, this class is primarily designed to teach abstraction, recursion, and algorithmic analysis. If you already know those topics and just want to learn C++, you may want to opt to take CS106L instead of CS106B. The required reading for this course is Eric Roberts' *Programming Abstractions in C++*. You can purchase a copy at the bookstore using this link:

> https://www.bkstr.com/stanfordstore/search/keyword/programming%2520abstractions

You can also use this online version, which is a 2012 draft version of the book.

> https://web.stanford.edu/dept/cs_edu/resources/textbook/

We assume that the majority of you have no prior programming experience in C++, and this textbook is a great resource to use at the start of the quarter as you’re transitioning into the language.

A helpful note from the School of Engineering:

> *“All students should retain receipts for books and other course-related expenses, as these may be qualified educational expenses for tax purposes. If you are an undergraduate receiving financial aid, you may be eligible for additional financial aid for required books and course materials if these expenses exceed the aid amount in your award letter. For more information, review your award letter or visit the [Student Budget website](https://financialaid.stanford.edu/undergrad/budget/index.html).”*

CS 106B Programming Abstractions

Computer Programming

Java (programming language)

Class (computer programming)

Software testing

References

List (abstract data type)

SLLists

Nested Classes

Debugging

Array (data structure)

Array Resizing

Inheritance (object-oriented programming)

Extends

Higher-order function (HOF)

Exception handling

Object Methods

Disjoint Sets

Binary Search Tree (BST)

Red Black Trees

Tree traversal

Multi-Dimensional Data

Prefix Operations and Tries

Reductions and Decomposition

Quick Sort

Algorithmic Bounds

Data structure

Scope

Shortest paths

Kolmogorov complexity

Sentinel Nodes

DLLists

ALists

SLists

Implements

Casting

Subtype Polymorphism

Iterators

Asymptotics

Abstract Data Type (ADT)

B-tree

Priority queue (PQ)

Graph traversal

Range Searching

Software Engineering

Radix Sorts

Compression

P=NP

Static

Minimum Spanning Tree (MST)

CS 61B: Data Structures UC Berkeley Fall 2022 CS 61B focuses on software efficiency from design and runtime perspectives. It covers object-oriented programming with Java, teaching data structures and various programming concepts. The course promotes hands-on learning with optional assignments. The CS 61 series is an introduction to Computer Science, with particular emphasis on software and machines from a programmer’s point of view. CS 61A covered high-level approaches to problem-solving, providing you with a variety of ways to organize solutions to programming problems as compositions of functions, collections of objects, or sets of rules. In CS 61B, we move to a somewhat more detailed (and to some extent, more basic) level of programming by focusing particularly on the efficiency of writing programs (design) and running programs (runtime).  This class assumes you have taken CS 61A, CS 88, or E 7, or have equivalent background to a student who has taken one of these courses. The course is largely built upon the assumption that you have taken CS 61A. CS 88 and E7 students may find the beginning of the course to be a bit scarier, particularly when it comes to object oriented programming. We assume you are coming in with zero Java experience, but we will move through basic Java syntax very quickly.

We recommend all students to complete the [optional introductory assignment](https://fa22.datastructur.es/materials/hw/hw0/) by the beginning of the semester to get comfortable with Java and practice some of the programming skills expected by this class.

If you already have Java experience, great! We hope that you’ll help out your fellow students in discussion, lab, and on our class forum, particularly in the opening weeks when everyone is catching up on Java. **There is no required textbook for the class.**

There is an online textbook written by myself and a large team of former TAs. It can be found at https://joshhug.gitbooks.io/hug61b. If you find these notes insufficient, you might consider consulting [Paul Hilfinger’s (free) Java Reference](http://www-inst.eecs.berkeley.edu/~cs61b/fa14/book1/java.pdf) or [Head First Java, 2nd Edition by Sierra and Bates (O’Reilly, 2005)](https://www.google.com/search?q=head+first+java). These are not required for the course. The **optional** textbook for the weeks 5-14 of the course is Algorithms, 4th Edition by Wayne and Sedgewick.

The official description of the Java core language is available online in [The Java Language Specification](https://docs.oracle.com/javase/specs/jls/se17/html/index.html) (Java SE 17 Edition) by James Gosling, Bill Joy, Guy Steele, Gilad Bracha, Alex Buckley, Daniel Smith, and Gavin Bierman. It’s extremely thorough and precise, at the expense of being quite dense and technical. You will find the official [Java 17 documentation](ttps://docs.oracle.com/en/java/javase/17/docs/api/index.html) to be useful as well

CS 61B: Data Structures

Data Structures and Algorithms

File I/O

Machine learning

Hash table

Object (computer science)

Polymorphism (computer science)

Debugger

Object-Oriented Programming (OOP)

Web scraping

Binary tree

Web API

Merge sort

Random testing

Binary expression tree

CSCI 0112 - Computing Foundations: Program Organization Brown University Fall 2022 CSCI 0112 progresses from CSCI 0111, focusing on structuring programs for solving isolated subproblems. It delves into various algorithms, implementations from abstract descriptions, data organization methods, and program efficiency. Ethical considerations in software development are underscored. Topics include data structures, OOP, web APIs, machine learning, and more. CSCI 0112 builds on the data-focused programming introduced in CSCI 0111. Students will learn how to structure their programs so that subproblems can be solved in isolation. We will discuss several algorithms–abstract descriptions of computations–and students will get practice implementing working programs from these abstract descriptions. We will continue our study of data organization, covering several new ways of storing and accessing information. We will also continue to discuss program efficiency; students will learn how to reason about the performance of their programs. Finally, like CSCI 0111, CSCI 0112 will foreground the ethical considerations programmers must think about when developing software.   

CSCI 0112 - Computing Foundations: Program Organization

Tkinter

Arithmetic Expressions

Variable (computer science)

Function (computer programming)

Boolean

Tuple

Array slicing

Control flow

For loop

Dictionary (data structure)

Modular programming

File system

While loop

Assertion (software development)

API (Application Programming Interface)

Lambda

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 

Interface

Encapsulation

`ArrayIntList`

pre/post conditions

Reference Semantics

List Nodes

`LinkedIntList`

Recursive Tracing

Grammars

Binary Search

Recursive Backtracking

Comparable

Generics

Priority Queues

Huffman

Resizing

Abstract Classes

Computational complexity

CSE 143 Computer Programming II University of Washington Summer 2022 This course is a continuation of CSE 142, focusing on manipulating data, implementing data structures, and learning about algorithms in Java. It delves into abstract data types, recursion, inheritance, and more.  This course is a continuation of CSE 142. While CSE 142 focused on topics of program control (loops, conditionals, methods, parameter passing, etc.), CSE 143 focuses on topics ofb manipulating data. Topics include: abstract data types (ADTs), lists, stacks, queues, linked lists, binary trees, recursion, interfaces, inheritance, and encapsulation. Students will also learn about the notion of complexity and how to evaluate performance trade-offs of classic algorithms (such as sorting and searching) and classic data structures (such as lists, sets, and maps). The course will include a mixture of implementing data structures and using components from the Java Collections Framework.  ## Textbook

Our optional textbook for CSE 143 this quarter will be the following:

Reges/Stepp. Building Java Programs: A Back to Basics Approach, 5th edition. ISBN 978-0135471944

- [Building Java Programs: A Back to Basics Approach (authors' web site)](http://www.buildingjavaprograms.com/)

This book was written specifically for this course and makes a valuable supplement to the lecture presentations.

## Code Files

The textbook includes many sample programs. You can access a full set of [code files](http://www.buildingjavaprograms.com/code_files/) that is organized chapter by chapter. This will allow you to download any of the programs and run them on your own computer.

## Video Notes

New copies of the textbook come with an access code to watch "Video Notes." These videos supplement the lecture and book material by walking through more examples in detail. You can access the video notes at the Pearson [VideoNotes](http://www.pearsonhighered.com/regesstepp/) web site.

CSE 143 Computer Programming II

Interface (object-oriented programming)

Loops

Software design pattern

Search algorithm

CSCI 0150: Introduction to Object-Oriented Programming and Computer Science Brown University Fall 2022 CS0150 introduces Computer Science via object-oriented design and programming using Java and JavaFX for creating interactive programs with GUIs. Concepts like data structures, algorithms, and computational efficiency are explored. Practical exercises include engaging programming assignments like Doodle Jump and Tetris. The course is designed for all, requiring no prior knowledge. This course introduces students to Computer Science through object-oriented design and programming, using Java and the JavaFX graphics library. You will use these tools for building interactive programs with graphical user interfaces. CS0150 reinforces concepts with practical exercises in weekly lab sessions and with challenging and engaging programming assignments, such as Doodle Jump and Tetris!

There are no prerequisites for CS0150 and the course expects no prior programming experience. This course introduces principles of computer science, emphasizing object-oriented design and programming in Java, an effective modern technique for producing modular, reusable, and internet-aware programs. It also introduces interactive 2D computer graphics, user interface design, some fundamental data structures and algorithms, and computational efficiency. A sequence of successively more complex graphics programs, including Tetris and culminating in a significant final project, helps provide a serious introduction to the field. Each assignment includes an interactive user interface. Therefore, most of the games you program can be played! However, this course is not focused on games nor game design. It uses games as a natural and fun vehicle for learning object-oriented programming and graphical user interfaces.  The course takes an interactive approach to programming assignments and an equally interactive approach to lectures. Andy’s lectures are supplemented by skits performed by the UTAs (Undergraduate Teaching Assistants) to teach course concepts and to make the class fun and enjoyable!  This course is intended for both potential concentrators and those who may take only a single course. No prerequisites and no prior knowledge of programming and mathematics, beyond basic algebra, are required.  

CSCI 0150: Introduction to Object-Oriented Programming and Computer Science