Menu

- Chapter 1 Distilled
- Introduction
- 1.1 - The Elements Of Programming
- Expressions
- Naming and the Environment
- Evaluating Combinations
- Defining New Functions
- The Substitution Model
- Exercises
- Predicates
- Conditional Expressions
- Example: Newtonâ€™s Method
- Functions as Black-Box Abstractions
- 1.2 - Procedures and the Processes They Generate
- Linear Recursion and Iteration
- Tree Recursion
- Orders of Growth
- Exponentiation
- Example: Testing For Primality
- 1.3 Higher Order Functions
- Project - Blackjack

- Chapter 2 Distilled
- Introduction
- Data Abstraction
- Everything From Nothing
- Abstractions In Clojure
- Clojure's Data Structures
- Data Abstraction, Revisited
- Escher
- Project - Escher
- Symbolic Data
- Representing Sets
- Huffman Encoding Trees
- Zippers

This chapter is all about pure functions of numbers, it introduces the
idea of *recursive* and *iterative* procedures and talks a bit about
space and time complexity of algorithms (so-called *big-O* notation)

It develops a model for evaluating Clojure expressions that suffices
as long as we have only *pure functions*

Most importantly it introduces the idea of *first class* elements in a
programming language and uses the fact that Clojure has first class
functions. Higher Order Functions is one of the main ideas in the
book.

SICP is very careful to always refer to *procedures* in programs and
reserves *function* for mathematical functions. I took the decision
(though was very conflicted) of saying *functions*, *mathematical
functions* and saying *pure functions* if
referential transparency
is significant in the context.

I think terms like *first class functions*, *higher order functions*
etc are in common enough use that it is better to use them. This may
change and I am interested to know what you think.

Sections 1.1 and 1.2 are fairly direct translations of the book, though if I can think of a different example to replace Newtons Method I may well do it.

Section 1.3 I found the examples a bit contrived to stay within the constraint of having not yet introduced data structures so skipped lots of the examples (the coin counting one for instance makes much more sense with a collection of coins), replacing them with few simple ones of my own.

I took the Blackjack exercise from the projects page

If you want to really understand recursion, check out The Litte Schemer (it goes on to things that appear later in the presentation here too)