Here's the lesson plan that I use:

Begin with generative recursion.  This is in the file qs.ps.  Many of
them are itching to see "real" sorting.  Walk through the example,
then explain why we didn't show it earlier.  Explain also how
fractals, etc fall under this rubric.  Newton's method is a good
example of how you need domain expertise to understand convergence.
(Sorting isn't such a good example, because the domain there is CS
itself.)  I found GCD was a good example to ask them to think about,
because many had never considered convergence.  Also, the quicksort
code includes an example of a mistake that I made while writing it,
which failed to converge.  I did not discuss the generative "recipe".

While doing quicksort, I ask them to humor me by walking through both
the number filters -- "just to be sure we can write this in our
sleep".  This goes off on one edge of the board -- space that I can
afford to not use for the next topic.

The second topic is higher-order functions.  I walk them through
d/dx.  The first surprise if that you can pass in an operator at all.
The second is that you can construct anonymous functions.  Appeal to
their distrust of anonymous other things earlier in the week (eg,
anonymous lists).  I introduce lambda by first asking them imagine how 
nice and simple it would be if we could introduce an anonymous
function just by writing

  (function (h) ...)

-- of course we can't, but let's conceptually imagine we can.  This
comforts them some.  Then erase function with lambda, unveil our logo, 
hear the trumpets from the sky, etc.  Be sure to revise the contracts
*after* they've understood the function itself.

Now we can return to abstractions.  Repeat the experiment of operator
abstraction with your code from the first topic.  From here talk them
through filter and map.  This is a nice order not only because there
is an immediate need for filter, but also because when you consider
the contracts, filter has only one variable whereas map has two, so
conceptually it's easier for them to understand filter's contract
before map's.  Note that the grades example comes from Thursday
night's gradebook construction.  It's useful to tie things together
for those who were at that session.  (As our group concluded, "It's
true -- you *can* write every program in just four lines!")

I made a point throughout the week of letting them know we *would* see 
Scheme's looping constructs on Friday.  When Friday came, I unleashed
filter and map (fold would be pure overload at this point) and said
these were Scheme's looping constructs.  Happily, by that point in the 
course they seemed able to appreciate (a) why these were loops, and
(b) how much nicer these were.  There was still a mystical sense about 
it all, but it's good to leave them in a daze.