Object-Oriented Programming (OOP)

Function (computer programming)

Scoping

Algorithmic Complexity

2048

Python

Tree Recursion

Higher-order function (HOF)

Algorithms

Best Coding Practices

Programming Paradigms

List Mutation

Social Implications

Abstraction (computer science)

List (abstract data type)

Mutability

Recursion (computer science)

Fractals

Python Data Structures

Number Representation

Concurrency

CS 10: The Beauty and Joy of Computing UC Berkeley Summer 2022 A gentle, thorough introduction to computer science, starting with block-based language Snap! and transitioning to Python. The course covers fundamental programming concepts and encourages application in various fields.
Level: Beginner friendly. Welcome to CS10: The Beauty and Joy of Computing! We’re really excited to have you on board with us this Summer for a gentle but thorough introduction to computer science. Our course will start out in the blocks-based language Snap!, but will transition into Python once you have learned some fundamentals of programming. By the end of the class, we hope you walk away with a deeper understanding of the ideas that have come to define computer science, the ability to build your own programs, and the confidence to apply these skills in whichever field you choose to pursue.   

CS 10: The Beauty and Joy of Computing

Computer Programming

Functional Decomposition

Data Abstraction

JavaScript

Timer-Based Animation

JavaScript Arrays

Cryptography

Python Strings

Python Objects

Data-Driven Programs

Interactors

HTTP

JavaScript Graphics

Advanced Animation

JavaScript Objects

Enigma Machine

Python Lists

Adventure

Building Web Applications

Interactive Graphics

JavaScript Strings

Binary Representation

Python Dictionaries

Objects and Abstraction

Web Programming

Asynchronous Requests

Frontiers of Computer Science

CS 106AX Programming Methodologies in JavaScript and Python Stanford University Autumn 2022 This course is designed for those with prior programming experience. It focuses on advanced programming methodologies in Python and JavaScript, and covers topics from object-oriented design principles to building web applications. Introduction to the engineering of computer and web applications emphasizing modern software engineering principles: object-oriented design, decomposition, encapsulation, abstraction, and testing. This course targets an audience with prior programming experience, and that prior experience is leveraged so material can be covered in greater depth.   

CS 106AX Programming Methodologies in JavaScript and Python

File I/O

Data structure

Software testing

Computer memory

Set (abstract data type)

Machine learning

Hash table

Tree (data structure)

Object (computer science)

Polymorphism (computer science)

Exception handling

Debugger

Class (computer programming)

Inheritance (object-oriented programming)

Linked list

Web scraping

Binary tree

Web API

Sorting algorithm

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)

String (computer science)

Boolean

Tuple

Array slicing

Control flow

Debugging

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 

Loops

For Loop

Environment Diagrams

Dictionaries

Mutable Data

Generators

Databases

Abstract Data Type (ADT)

Efficiency

Iterators

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

Java (programming language)

Control Structures

Documentation and Readability

Static methods

Types

`print` statements

Scanners

Conditional (computer programming)

Array (data structure)

ArrayList

Java

Expressions

Scope

Parameters

`Math` class

Information flow

Pseudorandomness

Line-based file input

reference semantics

Constructors

Escape sequences

`for` loops

Class constants

Return values

Chaining

Sentinel loops

Token-based file input

Array Traversals

Fields

`println`

Variable (computer_science)

Nested `for` loops

Cumulative algorithm

Fencepost problems

File output

Array Shifting

Instance Methods

Critters

CSE 142 Computer Programming I University of Washington Summer 2022 This introductory course teaches programming using Java. Students learn computational problem-solving techniques, functional decomposition, control structures, data abstraction, and code documentation. No prior programming experience is required. This course provides an introduction to programming using the Java programming language. We will explore common computational problem-solving techniques useful to computer scientists, but also to anyone who has large data sets, repetitive processes or other needs for computation. No prior programming experience is assumed, although students should know the basics of using a computer (e.g., using a web browser and a text editor) and should be comfortable with math through Algebra 1. Students with significant prior programming experience should consider skipping CSE 142 and taking [CSE 143](https://cs.washington.edu/143). CSE 142 is organized around five key learning objectives. At the end of the course, students will be able to do the following:

1. Functionality/Behavior: Write functionally correct Java programs that meet a provided specification and/or solve a specified problem
1. Functional Decomposition: Break down problems into subproblems that are modular and reusable, and define methods to represent those subproblems
1. Control Structures: Select and apply control structures (e.g. methods, loops, conditionals) to manage the flow of control and information in programs
1. Data Abstraction: Select and apply basic data abstractions (e.g. variables, parameters, arrays, classes) to manage and manipulate data in programs
1. Documentation and Readability: Define programs that are well-written, readable, maintainable, and conform to established standards  Recommended textbook: [*Building Java Programs* by Reges and Stepp (5th edition)](https://courses.cs.washington.edu/courses/cse142/22su/textbook.html)

CSE 142 Computer Programming I