I found some of the exercises in building abstractions with procedures pretty inaccessible with implicit maths knowledge necessary. From building abstractions with data onwards they become well spec'd and straightforward.

That makes a lot more sense. It also matches the times they record for the exercise. For context, 2.92 is:

> Exercise 2.92. By imposing an ordering on variables, extend the polynomial package so that addition and multiplication of polynomials works for polynomials in different variables. (This is not easy!)

2.29 is what I described in my other comment, it's a pair of functions walking a binary tree with conditional logic based on if it's an interior or exterior node, returning either a sum or a true/false value. Which is not hard at all and their time was only 83 minutes. Versus their claimed time of 2400 minutes for 2.92.

Extra whitespace to put the `cond` clauses in columns can make it even more clear, for "visual" looking at code, rather than only "verbal":

    (define (member? item set)
      (cond ((null? set)             #f)
            ((equal? item (car set)) #t)
            (else                    (member? item (cdr set)))))

For bonus points, line up the key variable in the clauses, and it's easier to see visually that the `cond` is about that one variable:

    (define (member? item set)
      (cond ((null?       set)       #f)
            ((equal? (car set) item) #t)
            (else                    (member? item (cdr set)))))

Which accidentally also lines up with one of the procedure's arguments, though I didn't intend that one, but you could double down on that:

    (define (member? item      set)
      (cond ((null?            set)  #f)
            ((equal? item (car set)) #t)
            (else                    (member? item (cdr set)))))

This isn't some deep thing; just a little example of how sometimes whitespace, other than just indenting at the beginning of the line, helps to exposure some of the structure visually.

The authors of the JS version of SICP had a problem: Scheme is expression based and JavaScript is statement based.

When I say Scheme is expression based, I am alluding to the fact that constructs such as `if`, `cond`, `case` etc. are all expressions. Scheme also has several binding constructs (let, letrec, etc) that allows in an expression context to bind the result of a computation in a subexpression. These are all expressions.

The expression version of `if` is in JavaScript called ternary if. A direct translation from Scheme to JavaScript therefore uses ternary if.

But why make a direct translation?

Well, later in the book one writes an interpreter for Scheme. This interpreter shows how the expression based language constructs are implemented. It is therefore necessary that the reader is very familiar with these constructs.

I'm convinced someone wrote a (bad) Scheme to JavaScript transpiler to convert the code. It looks like nothing anyone would actually write.

In my humble opinion, a for loop is easier to reason about then recursion. So one of JavaScript's "features" is that it does not have proper recursion support, so you need to break out the recursion into a for loop, or the call stack will eventually become too big.

It’s not the language to blame in SICP, if any. Scheme is totally find (and cool).

SICP modified for Python exists (I haven't looked at it, so not vouching or commenting) https://wizardforcel.gitbooks.io/sicp-in-python/content/

Hate to do this but https://chatgpt.com/share/67c78ef6-2418-8000-a40a-59d5b708ba...

I was lucky enough to read it during my studies and to have a teacher that made very good Slides focusing on the most interesting parts.

I think finding someone that guide you through the book allows to go way faster than alone.

Now, while the concepts were extremely illuminating, I think following the book but doing the exercises in haskell is also a nice path. Haskell was another lecture following the one on SICP by the same teacher, and it uses most of the same ideas, sometimes formulated a little differently, but on a more modern language.

I still remember my exam where we received ~6 pages double column of printed lisp, no comments. The code was a compiler, and we needed to change it so that it can jump back in time using call with cc. Difficult to do in 3h and on paper but very fun.