Course Topic Summary (and final exam study checklist)
Big Ideas
- types
- scope
- static vs. dynamic analysis
- major programming language families
- interaction of different programming languages with good style for that
language
- objects and encapsulation
- purely functional languages vs. state
General Concepts
- types:
- static vs. dynamic typing
- type safety
- type inference
- terms with no generally-agreed on definition
("strongly typed language")
- polymorphism
- functional vs. imperative languages; functional subset of language
- higher-order functions
- parameter passing:
- call by value (including call by value with pointer semantics)
- call by result
- call by value/result
- call by reference
- call by name; lazy evaluation; thunks
- call by equality constraint
- overloaded functions, operators, and methods
- coercion
- aliasing
- closures
- equality vs. identity (and when it matters)
- lexical vs. dynamic scoping
- recursion; tail recursion
Haskell and Pure Functional Languages
- functions, including higher-order functions, currying, and
anonymous functions
- lexical scoping
- types: polymorphic types; type inference, declarations;
user-defined types, including recursive types; type classes; inheritance
- referential transparency
- lazy evaluation; infinite data structures
- pattern matching
- list comprehensions
- monads; I/O in Haskell
- applicative vs. normal order evaluation for pure functional languages
Scheme
- constructing and navigating list structures
- scoping issues (lexical scoping, global variables, parameters, let,
let*, environments)
- function definition; anonymous functions; special forms
- eval and apply
- programs as data
- metacircular interpreter
- side effects in Scheme
- Scheme macros (including hygenic macros and what problems they solve)
- functions with variable number of arguments; improper
lists; quasi-quoting
CLP(R)
- logic variables
- constraints in CLP(R):
- constraints over the real numbers
- constraints over trees
- rules, facts, and goals
- CLP(R) execution; backtracking
- CLP operational semantics: derivations, derivation trees, simplified
derivation trees, answers, successful vs. failed derivations,
infinite derivations
- CLP programming techniques: controlling search (including the infamous
"cut" operator); difference lists
Ruby
- pure object-oriented languages
- classes, instances; inheritance
- messages and methods
- duck typing
- self and super
- blocks, procs, and iterators
- mixins
- instance-specific methods; singleton classes
- reflection
Java
- subtype relation
- covariant vs. contravariant vs. invariant (also known as equivariant)
argument types
- covariant vs. invariant return types
- method overloading
- Java generics: wildcards, bounded wildcards, type parameters, generic
classes, generic methods
- Java arrays and the covariant typing rule (and why it may require a
runtime check)
- nested and inner classes; scoping issues
Cross-Cutting Object-Oriented Programming Language Topics
- pure vs. hybrid object-oriented languages
- multiple inheritance (for classes) vs. multiple inheritance
(for interfaces) vs. mixins
- classes vs. prototypes