SICP was used as the reference book for the introductory course on programming on my degree. People with prior experience had the most trouble with recursion. Students with no programming experience whatsoever grasped the concept pretty easily.
I would try it out. It might need some analytically wired thought process, but again that is true for any kind of programming paradigm.
Let's not forget to draw a distinction between programming and computer science...
SICP was created to be an introductory computer science textbook back in the day when anybody who actually enrolled in a computer science course could reasonably be expected to be an absolute nerd. It's a book for teaching computer science to people who already have some amount of programming aptitude. It is not a book that tries to teach programming, to hand-hold students through learning practical applications. Yes, it's been shoehorned into many programming courses, but that's not the book's purpose.
HtDP is much better for teaching programming - it's a book that follows many of SICP's ideas, but doesn't presume any relevant experience on the part of the student. It's still not an ideal book for teaching practical programming to a student who doesn't care about any of the CS theory, though.
It depends on the person. How they like to think. I promise!
Whether we look at it as programming or computer science, it's abstract enough that it's highly personal and each person has their own idiosyncratic style of learning.
I did and would benefit much more from a book like SICP than books that are written into a more specific purpose.
What I personally see in academic setting is that when recursion is taught, it's taught using examples where you would not want to use recursion.
It's easy to understand why recursion is useful when you are tasked with traversing a file system. It's not when the first example you are given is calculating Fibonacci sequence.
I like the way SICP handles this, actually. They state clearly (in the text, haven't watched the videos) that the naive recursive form for Fibonacci is only illustrative, then they proceed to provide the iterative form. Following that they have this paragraph:
> One should not conclude from this that tree-recursive processes are useless. When we consider processes that operate on hierarchically structured data rather than numbers, we will find that tree recursion is a natural and powerful tool. But even in numerical operations, tree-recursive processes can be useful in helping us to understand and design programs. For instance, although the first fib procedure is much less efficient than the second one, it is more straightforward, being little more than a translation into Lisp of the definition of the Fibonacci sequence. To formulate the iterative algorithm required noticing that the computation could be recast as an iteration with three state variables.
Hopefully a professor in a course would make similar statements (I know mine did, repeatedly). And, at least in my early programming courses, we quickly (within a week or two) went on to those other problems where recursion was a natural and useful solution. The professors [0] introduced problems where recursion was either necessary (using for/while loops would be a non-trivial transformation with no performance gain) or, like naive Fibonacci, natural expressions of the problem.
[0] I transferred universities, not all courses lined up so I got to see the second school's introduction to this topic even though I was past that point academically. I was an unpaid TA (technically I guess I was paying to be the TA).
This is like complaining that when piano teachers teach students how to hold their hands they teach it with scales where it doesn't really matter. The importance of hand position is obvious when you are tasked with playing chords in a real song.
The very first exercise should be as simple as possible. Explicitly because you're introducing a new concept and so want as little else in the way as you can arrange.
A great way to let someone understand recursion is to let them learn how the principle of mathematical induction works. It gets rid of all the noise related to the programming language.
It's "introductory" for MIT students who have a background in engineering, math, or physics, not average people off the street.
Recursion is hard for students to grasp when taught in math contexts as well, so I don't think this is a matter of prior CS teaching biasing them one way.
I would try it out. It might need some analytically wired thought process, but again that is true for any kind of programming paradigm.