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
- call by result
- call by value/result
- call by reference
- call by name; lazy evaluation; thunks
- using constraints for parameter passing
- lexical vs. dynamic scoping
- aliasing
- closures
- equality vs. identity (and when it matters)
- compile time vs. run time
- stack-based storage allocation, heap-based allocation, garbage
collection
- recursion; tail recursion
- "first-class citizens" (e.g. functions in Miranda, classes in
Smalltalk, but not classes in Java)
Scheme
- constructing and navigating list structures
- scoping issues (global variables, parameters, let, let*, environments)
- function definition; anonymous functions; special forms
- recursion; design patterns for using recursion
- eval and apply
- programs as data
- metacircular interpreter
- simulating lazy evaluation with thunks; stream processing
- side effects in Scheme
- macros (including hygenic macros and what problems they solve)
Miranda
- functions, including higher-order functions and currying
- lexical scoping and closures
- types: polymorphic types; type inference, declarations;
user-defined types, including recursive types; abstract types
- referential transparency
- lazy evaluation; infinite data structures
- pattern matching
- list comprehensions
Smalltalk
- pure object-oriented languages
- classes, instances; inheritance
- messages and methods
- self and super
- blocks
- control structures in Smalltalk
- metaclasses
Other Object-Oriented Language Topics
- Java generics (parametric polymorphism); wildcards; bounded generics
- Java arrays and the covariant typing rule (and why it may require a
runtime check)
- Java: nested and inner classes; scoping issues
- prototype-based languages
CLP(R)
- logic variables
- constraints in CLP(R):
- constraints over the real numbers
- constraints over trees (note relation to type inference in Miranda!)
- CLP(R) execution -- backtracking
- CLP operational semantics; derivations; derivation trees
- the "cut" operator
Other Topics
Finally, here are some topics we discussed, but that won't be on the final:
- programming environments, debugging support (and sometimes lack
thereof)
- multiple inheritance
- some history of programming languages
- hard and soft constraints, constraints and state, incremental
constraint solvers, constraints for interactive applications