[[ This file is maintained by Dan Grossman as the 341 Course
Coordinator.  Each year he confers with the cadre of 341 instructors
to make sure this topic list is coordinated and matches reality even
though the style, order, and languages in 341 depends on instructor
(see course homepages).  This file was not created by the
curriculum-revision work. ]]

Last updated: 2008

Textbook(s) and/or other required material:

Varies depending on instructor, but typically one or two of:

Simon Thompson, Miranda: The Craft of Functional Programming
Jeff Ullman, Elements of ML Programming
Mark Guzdial, Squeak: Object-Oriented Programming with Multimedia Applications
Kent Dybvig, The Scheme Programming Language
Dave Thomas, Programming Ruby

(In addition, significant on-line materials, tutorials, and resources
are provided.)

Course objectives:
* To understand fundamental programming-language concepts
* To become fluent in non-imperative programming paradigms
* To become able to learn new programming languages efficiently

Topics covered:

The following topics are always covered:

* Functional programming (avoiding mutation; exploiting recursion and
higher-order functions; closures; anonymous functions)
* algebraic datatypes and pattern-matching
* essential object-oriented programming (late-binding / dynamic
dispatch, subtyping vs. subclassing)
* language support for abstraction, such as modules, abstract types, and
     dynamic type-creation
* syntax vs. semantics
* static vs. dynamic typing
* parametric polymorphism / generics
* object-oriented extensibility vs. functional extensibility

In any particular offering, most of the following are covered:

* tail recursion
* currying
* equality vs. identity
* macros
* type inference
* lazy evaluation and related idioms such as streams and memoization
* code-as-data concepts, such as reflection and eval/apply
* lexical vs. dynamic scope
* subtyping issues such as structural vs. named subtyping
and sumpsumption vs. coercion
* object-oriented concepts such as multiple inheritance, multimethods,
and metaclasses
* bounded parametric polymorphism
* forms of parameter passing
* subtype polymorphism and bounded polymorphism
* logic programming
* garbage collection

A small number of these topics might also be covered:

* language-design principles
* history of programming languages
* programming environments
* debugging support
* compilers vs. interpreters
* continuations
* continuation-passing style
* coroutines
* iterators
* language support for concurrency 

===========

"Official" department pre/post information:

See http://www.cs.washington.edu/education/syllabi/341.html, updated
April 2007