+## Recommended Software ##
+
+During the course, we'll be encouraging you to try out various things in Scheme
+and OCaml. Occasionally we will also make remarks about Haskell. All three of these
+are prominent *functional programming languages*. The term "functional" here means they have
+a special concern with functions, not just that they aren't broken. But what precisely is
+meant by "functional" is somewhat fuzzy and even its various precisifications take some
+time to explain. We'll get clearer on this during the course. Another term used roughly the same as "functional"
+is "declarative." At a first pass, "functional" or "declarative" programming is primarily focused on complex
+expressions that get computationally evaluated to some (usually simpler) result. In class I gave the examples
+of `1+2` (which gets evaluated in arithmetic to `3`), `1+2 < 5` (which gets evaluated in arithmetic to a truth-value), and `1`
+(which gets evaluated in arithmetic to `1`). Also Google search strings, which get evaluated by Google servers to a
+list of links.
+
+The dominant contrasting class of programming languages (the great majority of what's used
+in industry) are called "imperatival" languages, meaning they have more to do with following a sequence of commands (generating what we
+called in class "side-effects", though sometimes what they're *alongside* is not that interesting, and all the focus is instead
+on the effects). Programming languages like C and Python and JavaScript and so on are predominantly of this sort.
+
+In truth, nothing that gets marketed as a "programming language" is really completely 100% functional/declarative, and even the
+languages I called "imperatival" will have some "functional" *fragments* (they evaluate `1+2` to `3`, also). So these labels aren't
+strictly exclusive. The labels are better thought of as concerning different
+*styles* or *idioms* of programming. Languages like Scheme and OCaml and especially Haskell get called "functional languages" because
+of the extent to which they emphasize, and are designed around those idioms. Languages like Python and JavaScript are sometimes themselves
+described as "more functional" than other languages, like C.
+
+In any case, here is some more context for the three languages we will be focusing on.
+
+* **Scheme** is one of two or three major dialects of *Lisp*, which is a large family
+of programming languages. Scheme
+is the more clean and minimalist dialect of Lisp, and is what's mostly used in
+academic circles.
+Scheme itself has umpteen different "implementations", which share most of
+their fundamentals, but have slightly different extensions and interact with
+the operating system differently. One major implementation is called Racket,
+and that is what we recommend you use. If you're already using or comfortable with
+another Scheme implementation, though, there's no compelling reason to switch.
+
+ Another good Scheme implementation is Chicken. For our purposes, this is in some
+respects superior to Racket, and in other respects inferior. <!--
+Racket doesn't have R7RS-small, and won't anytime soon. :-(
+Also Chicken's library collection seems stronger, or at least better organized and maintained.
+Other R7RS-friendly: [Gauche](http://practical-scheme.net/gauche), [Chibi](https://code.google.com/p/chibi-scheme).
+-->
+
+ Racket and Chicken stand to Scheme in something like the relation Firefox stands to HTML.
+
+ (Wikipedia on
+[Lisp](http://en.wikipedia.org/wiki/Lisp_%28programming_language%29),
+[Scheme](http://en.wikipedia.org/wiki/Scheme_%28programming_language%29),
+[Racket](http://en.wikipedia.org/wiki/Racket_%28programming_language%29), and
+[Chicken](http://en.wikipedia.org/wiki/CHICKEN_%28Scheme_implementation%29).)
+
+* **Caml** is one of two major dialects of *ML*, which is another large
+family of programming languages. Caml has only one active "implementation",
+OCaml, developed by the INRIA academic group in France. Sometimes we may refer to Caml or ML
+more generally; but you can assume that what we're talking about always works more
+specifically in OCaml.
+
+ (Wikipedia on
+[ML](http://en.wikipedia.org/wiki/ML_%28programming_language%29),
+[Caml](http://en.wikipedia.org/wiki/Caml), and
+[OCaml](http://en.wikipedia.org/wiki/OCaml).)
+
+
+* **Haskell** is also used a
+lot in the academic contexts we'll be working through. Its surface syntax
+differs from Caml, and there are various important things one can do in
+each of Haskell and Caml that one can't (or can't as easily) do in the
+other. But these languages also have *a lot* in common, and if you're
+familiar with one of them, it's generally not hard to move between it and the
+other.
+
+ Like Scheme, Haskell has a couple of different implementations. The
+dominant one, and the one we recommend you install, is called GHC, short
+for "Glasgow Haskell Compiler".
+
+ (Wikipedia on
+[Haskell](http://en.wikipedia.org/wiki/Haskell_%28programming_language%29) and
+[GHC](https://en.wikipedia.org/wiki/Glasgow_Haskell_Compiler).)
+
+
+<a name=installing></a>
+[[How to get the programming languages running on your computer|installing]]
+
+
+## Recommended Books ##
+
+It's not *mandatory* to purchase these for the class. But they are good ways to get a more thorough and solid understanding of some of the more basic conceptual tools we'll be using. We especially recommend the first three of them.
+
+* *An Introduction to Lambda Calculi for Computer Scientists*, by Chris
+Hankin, currently $18 paperback on
+[Amazon](http://www.amazon.com/dp/0954300653).
+
+* *The Little Schemer, Fourth Edition*, by Daniel P. Friedman and Matthias
+Felleisen, currently $29 paperback on [Amazon](http://www.amazon.com/exec/obidos/ASIN/0262560992).
+This is a classic text introducing the gentle art of programming, using the
+functional programming language Scheme. Many people love this book, but it has
+an unusual dialog format that is not to everybody's taste. **Of particular
+interest for this course** is the explanation of the Y combinator, available as
+a free sample chapter [at the MIT Press web page for the
+book](http://www.ccs.neu.edu/home/matthias/BTLS/).
+
+* *The Seasoned Schemer*, also by Daniel P. Friedman and Matthias Felleisen, currently $29 paperback
+on [Amazon](http://www.amazon.com/Seasoned-Schemer-Daniel-P-Friedman/dp/026256100X). This is a sequel to The Little Schemer, and it focuses on mutation and continuations in Scheme. We will be covering those topics in the second half of the course.