SICP in Clojure

Don't know scheme? But it's even better that way! Many things will faster click in your head. Like oh wtf we're writing programs in some lists. Oh and now how the fuck your interpreter can evaluate programs far more complex than itself?

If you could start fresh and reprogramm your VM, JIT and GC, it would probebly be good idea to do full numeric tower, but in the real world you have constraints and you cant be pure.

Sure it is a poor man's replacement, but it works.

http://soft.vub.ac.be/

The ultimate utility is ignoring a specific language (Scheme really has nothing to do with the book, and SICP is not a Lisp book per se) and teaching students how to think about computing. It enables problem solving and understanding of the more abstract concepts involved with programming. Scheme just happens to work because there's nothing to the language and there are few boundaries, in terms of functionality.

Honestly, your school can decide if they want to churn out Students Who Program in Python (tm) or students who are taught to teach themselves and can reason about programs on their own, and who feel comfortable understanding varied language concepts. There may be other approaches to accomplish that, but SICP does it well. It's really the only thing that distinguishes a computer science curriculum from a vocational degree, which is an idea that has fallen out of favor or even been lost in the rush to graduate more CS students and embrace "industry standards." Does your school want to educate students or simply teach them programming trivia and practicum that they can pick up on their own? It's an important distinction. Would you want a Linguistics degree that started off by teaching some travel phrases from a Spanish guide purchased at a gas station?

Plus, given the depth of the book, the course could be scaled to a relative difficulty, which would probably be necessary. Recommended pre-reading could consist of the Schemer series (Little & Seasoned) with the expectation that the students might not make it all the way through them before the course starts.

Perhaps you could persuade the faculty to offer a basic Python course and an "honors" CS course that used SICP, or have the SICP course after the Python one, since I think in practice having some basic programming experience is probably a good idea before diving into SICP.

I went Googling for another perspective, and I found http://www.cs.berkeley.edu/~bh/sicp.html, which says a lot of the same things.

People who are new to programming look at SICP and like to say something to the effect of, "Wow, it's a shitty old Lisp book from a bygone error. I actually want to accomplish something, so I'm going to read this O'Reilly Java book now, because I can actually get a job that way." (heavy condescension implied), but perhaps this is a case of the amateur not really knowing what's best for them.

In the end, interested students can always pick up the book in their free time, and you will probably be fighting an uphill battle (at least if you're in the US).

SparkNotes Version: SICP encourages a thought process. A traditional class encourages you to learn how to do X in language Y. It is possible to do the former without SICP, but SICP does it very well.

http://www.cs.cmu.edu/~15150/

On the bright side, at least it's not JavaScript.

Also SICP teach all kinds of concepts from the ground up, its really cool to learn and understand but it has no use other then your learning.

So for example: https://github.com/nickbauman/sicp/blob/master/src/section2_...

You'll see I solved the exercise by ignoring what they were trying to teach because it can't be done in Clojure they way they were trying to teach it. I did learn how to make a tree with only lists, which is cool.

The idea of the book (at least in my interpretation) is that you are given a language with the absolute bare-minimum needed to built programs, thus why you can "learn Scheme in an afternoon." All of these things like (filter), hash-maps, dicts, etc, that we use and take for granted in our programs simply do not exist in Scheme unless you build it yourself.

In Scheme, you have to build up all the tools you need by creating your abstractions. To do this in Clojure (or any language) you have to ignore the abstractions you are given, and often must break the abstractions to create the abstractions you are already given.

Think of it this way. If you are going to be learning how to create and explore algorithms for matrix multiplication, would you prefer to use Mathematica or Python without Numpy?

As much as I wish Clojure on Android were a viable option, anyone with any sort of reading comprehension knows it's not. So while I don't doubt your criticism may have some sort of merit, you've managed to shoot your credibility in the foot, at least for this particular post.

I tell myself some day I'll go back and build a read layer so I can have macros.

https://github.com/CJOlsen/fez/blob/master/src/fez/core.clj