With the recent upsurge in the cachet of functional programming, your average self-taught developer will find himself in lack (real of perceived) of fundamental computer science concepts. For this reason, I've recently worked through the EdX Edge course based on Berkeley's CS61AS introductory computer science course. I've already published the homework solutions on GitHub and this is my short review of the course itself.
The course is basically a tutored, watered-down version of the famous book "Structure and Interpretation of Computer Programs", by Abelson and Sussman. A fair part of the exercises is taken straight from SICP, together with some additional coursework by the authors.
The material is based on a didactic dialect of LISP (Simply Scheme) but isn't overly focused on language details. Besides, LISPs don't have much syntax to begin with. I've done the exercises using Racket and only had to adapt a few idioms. You could probably use the homework as a nice and gentle introduction to LISP-like languages.
The first chapters will definitely be boring if you have already worked through some other functional programming material. On the other hand, the presentation of trees and other data structures was straight to the point and helped reinforced by useful exercises.
Mutation and state management are important topics in today's world of concurrent programming. The course doesn't disappoint in this respect, offering thoughtful materials and exercises about implementing data structures with mutable lists and handling the ripercussions of mutability.
The course also gets you to implement your own object oriented constructs by way of closures and other core concepts. After the initial enlightenment, that chapter got fairly boring as most experienced developers are already familiar with the ideas of message passing and internal object state.
The final chapters about streams and interpreters were the most challenging and mind-bending of all, probably because these ideas don't appear very often in your average web dev's workday. If nothing, I'd definitely recommend joining the course for those chapters alone.
As mentioned above, the course contains a selection of exercises from SICP, making it easier to make your way through an otherwise intimidating book. The progression is nicely graded, guiding you through harder and harder excercises.
I've managed to implement most of the homework in Racket instead of Scheme, as I felt it was an easier environment to set up on the Mac.
The course lives up to its reputation and offers a great theoretical grouding for self-taught developers. I would suggest skipping straight to units 3 and 4 to deal with the juicier concepts.