Course Schedule

Note: everything in the future shown below is a rough sketch only. Most of it is just notes from last time I taught the class dumped into the timeline without further thought.

I will be fussing with the timeline regularly as the semester unfolds. Do not rely on any future dates on this page!

Intro

Course overview, fundamentals

Language structure and execution

Parsing and syntax

Interpreters and compilers

Runtime and execution

Memory and data

Static vs. dynamic types

Types

Method calls, duck typing

Method dispatch

Dynamic languages, metaprogramming

Ruby

Inheritance

Closures, functional programming

Closures

Fall Break

Typed functional programming

Elm

Combining OO and typed functional approaches

Static types, generics

Thanksgiving Break

The problems of memory

What is a programming language?, Early computing and “programming”, ENIAC, Some early languages, “GOTO Considered Harmful” (original text), Language design as human process, (Slides)

Read the Syllabus

Join the Slack channel

Grammar Explorer

Term rewriting systems, Context-free grammars, Parse trees, syntax, Parse trees vs. abstract syntax trees (ASTs)

Initial learning reflection

Java AST investigations

Syntax vs. semantics, Interpreters vs. compilers, Language impl as translation, For p-langs, translation creates meaning, Familiar languages: interpreted or compiled?

Runtime, environment, The call stack (visualizer), Function calls as GOTO, Inlining, compiler optimization, Programming languages are abstractions

Case study: C structs, Stack vs heap, Heap timing example, Garbage collection (more on this later!), Case study: Unicode strings

What is a type? Competing definitions, Static analysis & static type checking, Dynamic vs static code examples, Types on the AST, Type checking as proof, Completeness & soundness of type systems

Turning programmer errors into type errors

Type checking method calls, Ducks/geese example, Duck typing, Why does Java need interfaces but not Python?, Nominal vs structural types, Names are proxies for semantics

Dynamic languages are made of hash tables, Dynamic vs static vs virtual dispatch, Late binding vs optimization, Advantages of static types, IDE tools, analysis

The case for static types, Intro to Ruby (examples from class)

Syntactic sugar, Ruby metaprogramming, (code from class)

Language excursion questionnaire

Retail Transactions

Inheritance, Tension of code reuse vs subtyping, Squaretangle example, Liskov Substitution Principle

The Problems with Inheritance

Mixins, Metaprogramming as a code reuse alternative, Dimensional example, Implicit type relationships

Functions as values, Higher-order functions, Variable capture, Capture extends variable lifetime

Play with closures

Why lexical scope vs. call chain scope?, Capture by ref vs. capture by value, Memory implications of variable capture

Closure Exercises

Smalltalk

Smalltalk’s legacy

Midterm reflection

Generators, Ruby blocks, (examples from class)

Intro to functional languages, Inferred types, Function types, Currying, Side effects, (Elm playground)

Scheme

Spotting FP similarities between Elm and Scheme

Read about Elm

More elm: function types, records, map, Elm practical demo, structural static typing, reminder to think about project topics

Working with value semantics / immutability in practice, The Elm architecture, Decomposition of code in Elm, Higher-order function techniques (e.g. pipeline style)

Play with shopping list

Algebraic data types, null violates LSP

More Elm reading

Haskell

Optionals, optional sugar, property sugar and willSet / didSet (where are the ivars?)

Swift structs, value types and value semantics, COW data structures, value semantics connection to pure FP

Elixir

Larger context of value semantics / no side effects / functional approaches in current language evolution; SwiftUI demo

Factor

More Swift, aync/await?

Rust

Existentials, witnesses, swift performance

Prolog

Alloy

Generics stuff, conditional extensions, conditional conformance

MAX/MSP

End-of-course survey

Swift memory stuff?

Retrospective & discussion

9 days / 5 classes

12 days / 6 classes

Ruby Adventures

14 days / 6 classes

Elm Time Travel

12 days / 6 classes

swift

16 days / 6 classes