Control flow

JavaScript

Function Implementation

Type Classes

Inheritance (object-oriented programming)

IO Monad

Storage Management

type Inference

Subtyping

Continuations

Lambda Calculus

Haskell

Object (computer science)

Scope

Type Polymorphism

Exception handling

vtables

CSE 130: Programming Languages: Principles and Paradigms UC San Diego Winter 2017 UC San Diego's CSE 130 provides an overview of basic concepts and design trade-offs related to programming languages. The course covers a wide range of topics like scope, storage management, exceptions, and concurrency, through practical implementation. This course will cover basic concepts and design trade-offs related to programming languages. The first half of the course focuses on functions, types, scope, storage management, exceptions, and continuations. The second half covers object-oriented features and concurrency. We will conclude with a few special-topics in programming languages. The class also has a number of small labs where students get to implement some of the language features discussed in class. The course consists of lectures, written homeworks, and programming assignments. The goal of the course is to (1) familiarize you with various modern programming language concepts and paradigms and (2) get you to think about and understand the design trade-offs and implementations of different language features. We will use real-world languages (e.g., JavaScript, Haskell, and C++) to explore the different concepts. But, we will not cover any one language in full – this course is not meant to make you a proficient programmer, learning how to proficiently program in any of these languages is a course in of itself.  We will be following John Mitchell’s [Concepts In Programming Languages](https://books.google.com/books?id=AUUgAwAAQBAJ) textbook and assigning reading from this book and various other online resources and papers. Some of the book chapters have been revised, we will be handing out PDFs of these chapters. Cheaper renting options for the book seem to be available online (e.g., on [Amazon](https://www.amazon.com/Concepts-Programming-Languages-John-Mitchell-ebook/dp/B00AHTN2TA/ref=mt_kindle?_encoding=UTF8&me=)).

If you are serious about programming languages Benjamin Pierce’s [Types and Programming Languages](https://www.cis.upenn.edu/~bcpierce/tapl/) is a must.

CSE 130: Programming Languages: Principles and Paradigms

Programming Languages

Tkinter

Python

Arithmetic Expressions

Variable (computer science)

Function (computer programming)

String (computer science)

Boolean

List (abstract data type)

Tuple

Array slicing

Debugging

For loop

Dictionary (data structure)

Set (abstract data type)

Modular programming

File system

Recursion (computer science)

Object-Oriented Programming (OOP)

Class (computer programming)

While loop

Assertion (software development)

API (Application Programming Interface)

Web API

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 

Computer Programming

Expressions

Images

Dictionaries

Computer memory

Search algorithm

Decomposition

Python Control Flow

Graphics

List of Lists

Computer file

Data Science

Internet

Python Variables

Graphical Animation

Nested Structures

Function Variables

CS 106A: Programming Methodologies Stanford University Spring 2023 This is an introductory course offering step-by-step instruction on key programming concepts with Python, including control flow, decomposition, data science, and more. Students are guided through exercises to learn by doing. ### How Does This Class Work?

- Start the very beginning
- Careful to go step by step, little exercises every day
- Like swimming, you can't just read about it
- Learn by doing
- "reps" - Nick's favorite word
- Technology to practice ideas right away
- In just a couple weeks .. amazed at what you can do
- Partly because computers are powerful
- Partly because coding is easier than you think  No prior programming experience required. There is one required text for this class, entitled Karel the Robot Learns Python. It's a short interactive tutorial that introduces the major concepts in programming in the context of an extremely simple robot world. This text is available for free on the class website. In addition to this text, we will also have reference material on Python available via the class webpage.

CS 106A: Programming Methodologies

Machine organization

C Programming

Pointer (computer programming)

Memory representation

Memory allocation

Array (data structure)

struct (C programming language)

Signed number representations

Data structure alignment

Assembly language

Call stack

Buffer overflow

Caching

Privilege separation

Memory protection

Virtual memory

Page table

Address translation

Process (computing)

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

Computer Systems

Control flow

4 courses cover this concept

CSE 130: Programming Languages: Principles and Paradigms

CICS 110: Foundations of Programming

CS 106A: Programming Methodologies

CSCI 0300: Fundamentals of Computer Systems