Course Schedule

Note: everything in the future shown below is a rough sketch only. 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

Memory and data

Execution

Static vs. dynamic types

Types

Duck typing

Dynamic languages, metaprogramming

Ruby

Method dispatch

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 plang?, Early computing and “programming”, ENIAC, “GOTO Considered Harmful” ([original text](https://www.dcs.gla.ac.uk/~pat/cpM/choco4/nqueens/Goto-Harmful-Dijkstra.pdf)), Language design as human process

Read syllabus

Syntax vs. semantics, Grammar Explorer, Raw parse trees vs. ASTs

Learning reflection, Java AST investigations

glimflerk

Language impl as translation, Interpreters vs. compilers, about ASTs, For p-langs, translation _creates_ meaning, Familiar compiled vs. interpreted languages

Data encoding, Case study: Unicode tradeoffs, Stack vs heap, Heap timing example, Garbage collection (more later!)

Fn calls as GOTO, inlining, runtime, environment, libraries, linker and loader

What is a type?, static analysis & static type checking, Dyn vs static examples, types on AST, type checking as proof, completeness & soundness of type systems

Programmer errors into type errors

competing definitions of “type”, duck typing, ducks/geese/cars example, Why does Java need interfaces but not Python?, Python objects are hash tables

Learning reflection

Dynamic languages are made of hash tables (continued), dynamic vs static vs virtual dispatch, nominal vs structural typing, names as proxies for behavioral contracts More advantages of static types: code completion, IDE tools, analysis

Install Ruby; Lang excursion questionnaire

Ruby koans

Everything is an object in Ruby, Syntactic sugar, Ruby metaprogramming

More Ruby koans

retail_transaction

Inheritance, tension of code reuse vs subtyping, Liskov substitution principle

Single and multiple inheritance, mixins, method_missing

Intro to closures, higher-order functions: passing functions to functions, returning functions from functions, lexical capture, Why lexical scope vs. call chain scope?

“compose” FP puzzler

Captures, captures as data structures, capture by ref vs. value, currying

Memory implications of closures, Ruby blocks, Python generators

Smalltalk legacy

fn lang basics, inferred static types, fn types, value semantics, currying, side effects

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

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

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

Swift optionals

Existentials, witnesses, swift performance

Generics stuff, conditional extensions, conditional conformance

End-of-course survey?

Swift memory stuff?

Retrospective & discussion

wordy

9 days / 5 classes

type_modeling

12 days / 6 classes

ruby

18 days / 8 classes

elm

14 days / 7 classes

swift

16 days / 6 classes