Course Topic Summary (and final exam study checklist)
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
- aliasing
- closures
- equality vs. identity (and when it matters)
- compile time vs. run time
- lexical vs. dynamic scoping
- recursion; tail recursion
- applicative vs. normal order evaluation for pure functional languages
Haskell
- 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
Scheme
- constructing and navigating list structures
- scoping issues (lexical scoping, global variables, parameters, let,
let*, environments)
- function definition; anonymous functions; special forms
- recursion; tail recursion
- 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; 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 argument types
- covariant vs. invariant return types
- method overloading
- Java generics; type parameters; wildcards; bounded wildcards
- Java arrays and the covariant typing rule (and why it may require a
runtime check)
- nested and inner classes; scoping issues