Apparently there's an important library for the course called scmutils that the Racket people gave up on porting a while back: http://lists.racket-lang.org/users/archive/2005-October/0099...
(The name is a little vague, I haven't decided what to call it; "scmutils" doesn't convey much).
Having it in Clojure means it could be integrated with lots of other things; I'm considering graphics, at some point, or some kind of integration with javascript.
I'm a daily reader of HN, but not much of a contributor (sadly): do you think this might be worth a Show HN when it was more mature?
Either way - really cool, wish I could help but I don't really know how.
The authors are really onto something with programming as a means to learn other subjects. I know there is a very recent book on differential geometry topics from them also!
Would you happen to have proof of property d of exercise 1.33 lying around? (The one on the Euler-Lagrange operator of a composition of Lagrangian-like functions)
I think this is because of the precision that programming demands. You have to really nail down every edge case, and think about things down to their essence.
This is one reason why programmers can succeed in jumping the fence to work in their customer's jobs, even when it's an unrelated field. (I've seen many programmers make swaps from fields as diverse as brand management, telecom customer support and bond trading)
That is, in programming you learn a small set of abstractions (programming language syntax), and the actual coursework in applying that is in how they combine, how to fit them to problems.
In math, you learn a large number of abstractions (notation), that can vary and have new ones across different domains, and which doesn't tell you what it is doing unless you learn all the abstractions.
The latter you can kinda get, if you think about it, but forcing you to actually turn it into something expressed in the former means it is synthesized into something applicable, rather than just abstraction that may or may not be.
That is,
http://upload.wikimedia.org/math/d/f/1/df17b3410e58ac4c285bc...
is harder to understand when you come across it than
total = 0;
for(i = 0; i<=100; i++)
{
total += i;
}
return total;
or sum([1..100])
You have to convert the first from a symbol that does not describe its action, to an action; the code describes the action. That extra translation step leads to additional cognitive load when learning, at least for me.(verbatim transliteration would be
sum (map (\i -> i)) [1..100]
)
There's an older course that's a bit of a sequel to Structure and Interpretation of Computer Programs (SICP) called Structure and Interpretation of Classical Mechanics (SICM). I've never done it but always thought it looked like fun. (If you're into Scheme or Lisp)
course: http://ocw.mit.edu/courses/earth-atmospheric-and-planetary-s...
book: http://mitpress.mit.edu/sites/default/files/titles/content/s...