Principles of Programming Languages

This page contains a set of jupyter scala notebooks for the undergraduate course Principles of Programming Languages course (CSCI 3155) at the University of Colorado Boulder.

The notes are all available in this github repository. Alternatively, we have links to notebooks hosted on the google colaboratory below.

If you are teaching a similar course at a university, and would like access to problem sets that go with these notes, email Sriram for access.

What is the course about?

Principles of programming language is a core course in the CS curriculum at CU Boulder that focuses on the following topics:

• Functional programming concepts using the Scala programming language.
  • These concepts include recursion, inductive datatypes, higher-order functions, currying, functors (map/reduce), lazy evaluation, continuations and trampolines.
  • Although we use the Scala programming language, the course emphasizes the universal applicability of these concepts to other programming languages that the students may be using elsewhere.
• Semantics of various programming language constructs using a simple programming language (called Lettuce) based on ML.
  • We start with bigstep semantics for basic arithmetic operations and build concepts on top of it.
  • The “buildups” include let-bindings, scopes, function calls (with static scoping), handling recursion, implicit and explicit references, types with type checking and finally type inference.
  • Demonstrate how differences in semantics give rise to significant differences in behavior of similar programs in various programming languages.
• Object Oriented Programming concepts covered more formally: objects, inheritance, traits, generics, subtyping, Liskov’s substitution principle and co/contra-variance.

Students use the notes from this page as their official textbook. Additionally, we have:

• Ten problem sets of assignments (as jupyter notebooks using the nbgrader system). These include a combination of conceptual problems with a programming component, all implemented as jupyter notebooks and partly autograded against test cases.
• Three “mini-projects”: these explore concepts we have not adequately explored in class including
  • Compiling programs into a tiny virtual machine bytecode language inspired by Java bytecode.
  • Designing and Implementing a domain specific language (DSL) for 2D graphics (recursion allows the student to draw some nice fractals in this language). Inspired directly bythe Haskell diagrams package.
  • Designing a DSL for reactive applications using the actor model (a toy version of the Akka framework).

How to view these notebooks

You can interact with the material locally on your computer by fist installing jupyter notebooks with scala kernel. Alternatively, we have links to notebooks hosted on the google colaboratory below.

Google Colab Instructions

We have provided links to notebooks on the google drive below. You can open them by clicking on the google drive link. Choose “google colab” as the application for opening the .ipynb file.

• Once in google colab, the very first cell of each notebook should be run to install the almond scala kernel each time you open the notebook.
• After running the very first cell successfully, you should choose menu option “runtime” -> “change runtime type” and select a “scala” runtime option (it should be available if the previous step was successful).
• Your kernel will restart and you should be able to run the programs.

If you are facing technical challenges, please let Sriram know.

Local Installation Instructions

Please install jupyter using a standard python package repository such as anaconda or pip. For running jupyter notebooks with scala, you will need to install the Almond kernel for scala. It works well with Java 1.8 and 1.11 (the stable versions for the JDK). However, we have made it work for other Java versions with careful choice of the almond kernel, sbt and scala versions. Once jupyter notebooks with almond kernel for scala is installed on your local machine, just check out the notebooks from our github repository and view them.

Notes

Here are links to the notes roughly in the order we cover them. They will open on google colab: you will need a google account to view them. See the github repository for alternatives.

Chapter	Description (Google Colab Link)
1	Basic Introduction to the Scala Language
2	Constructing Programs: A Brief Primer
3	Recursion
4	Inductive Definitions and Inductively Defined Structures
5	Operations on Inductively Defined Structures
6	A Brief Introduction to Parsing
7	Functors in Scala: Map, Filter and Fold
8	Big Step Operational Semantics : Introduction
9	Lettuce: A toy language with let-bindings
10	Lettuce: Scopes and Environments
11	Function Calls and Closures in Lettuce
12	Recursion in Lettuce: Y-Combinators and Circular Scopes
13	References, Mutable Vars and Side Effects
14	Implicit References
15	Calling Conventions: Call by Value vs. Reference
16	Garbage Collection: Basic Concepts
17	Continuation Passing Style (CPS): Converting to Tail Recursion
18	Trampolines
19	Types and Type Checking
20	Type Inference: Basic Idea
21	Type Inference: Unification and Constraint Solving
22	Introduction to Object Oriented Concepts (in Scala)
23	Traits, Type Parameters, Generics and Type Constraints
24	Subtyping and Variance Annotations
25	Lazy Evaluation, Streams, Iterators and Comprehensions

Companion Visualization Software

I have also a scala implementation of the Lettuce programming language interpreter with a visualization that shows how the interpreter works. It shows the various steps of the interpreter, the corresponding environment and illustrates how function calls work.

Click here for the git repository and instructions to run.

Sources and Credits

The notebooks form the official “textbook” for this class. Sriram Sankaranarayanan is the author of these notebooks, and takes full responsibility/blame for their contents. The original goal of these notes was to translate the wonderful book: Essentials of Programming Languages by Daniel P. Friedman and Mitchell Wand into the Scala language used in our class as lecture notes. However, the notes have since diverged significantly from Friedman and Wand’s textbook. Nevertheless, the reader interested in studying this subject further is asked to consult the textbook above since the notes themselves lack important bibliographic references and an adequate coverage of the more advanced topics.

Spencer Wilson contributed comments/critique and many of the in-class notebooks that gave Sriram the idea for using Jupyter notebooks.

This course teaches material similar to the principles of PL course designed by Prof. Bor-Yuh Evan Chang, but following a different pedagogical style. Sriram is thankful to Prof. Chang for designing this class in the first place. These lecture notes were inspired by Prof. Chang’s own notes.

The notebooks have evolved thanks to comments by current and past TAs including Albert Dayn, David Moon, Kyle Headley, Jack Martin, Monal Narasimhamurthy, and Rohit Mehra. Many students contributed typo fixes and suggestions.