"Now that you've finished SICP, time to move onto CTM" Online Book | Hacker News Reader

"Now that you've finished SICP, time to move onto CTM" Online Book

ulb.ac.be

72 pointsjules18 comments

There's a wiki for the book (http://codepoetics.com/wiki/index.php?title=Main_Page).

I really like CTM. I'm only about halfway through it (it's big!), but IMHO the writing is quite clear without being dry or shying away from harder material. Very well written.

The main idea of the book is that no one programming paradigm is the best fit for all problems, so it's worth knowing several, their respective strengths and weaknesses, and the ways in which they can be combined. The examples are mostly written in Oz, a language of the authors' invention, but they're not dogmatic about it - it's just a multi-paradigm language well suited to showing different techniques in isolation. (I made a quick attempt to port Oz/Mozart to OpenBSD/amd64, but didn't get it working. I wrote examples in OCaml and Scheme instead.)

Also, if you appreciate reading attempts to solve problems from multiple angles, Project Euler (http://projecteuler.net/) is worth a look. You can read other peoples' solutions after solving each problem; I've learned a lot about algorithms that way. (The problems are predominantly mathematical.)

Mozart-Oz http://www.mozart-oz.org/ is by no means a toy language. It is used and have been used in some serious commercial applications (I've used it myself in some even if it was never talked about or said in a even a single word (big secret)).

It's been awhile since I did any heavy lifting in mozart-oz but I keep it in my reference stack together with lisp, smalltalk.

I haven't written it off as a language. It looks very interesting, I just ran into trouble porting it to OpenBSD on amd64* and haven't gotten back to it. (I've done several ports for OpenBSD, and when/if I get it ported I will submit it.)

I prefer to work in languages that are reasonably portable across Linux, BSD (inc. OS X), and Windows. Combined with my other priorities and general taste, this means Lua, various Scheme implementations, OCaml, and C. (Your taste and priorities probably differ, though. Peace.)

* Which is an interesting portability test - Linux-isms are invalid, stuff that isn't 64-bit clean won't work, it's not quite i386, and OpenBSD's randomizing malloc tends to expose interesting bugs as well. (The only real loss has been Haskell, but I'm uneasy with how Haskell's de-facto standard seems to be "whatever the newest GHC does" when GHC has bootstrap/portability issues, e.g. http://hackage.haskell.org/trac/ghc/ticket/1346 .)

Just to clarify, I was i no way criticizing your choice to not use mozart-oz. I took the opportunity to give a reference to the mozart-oz as a language used outside the context of book.

I didn't take it as such, and I hope it didn't come across like I was getting irritated/defensive.

While I have your attention, do you have any other interesting links/references for it? Outside of CTM and its companion wiki, I've seen it mentioned on the c2 wiki (http://c2.com/cgi/wiki?OzLanguage http://c2.com/cgi/wiki?MozartProgrammingSystem http://c2.com/cgi/wiki?MultiParadigmProgrammingLanguage , etc.), but I haven't run across it otherwise. That might just be the places & niches I frequent, though.

It looks like there's a FreeBSD port of Mozart, FWIW (http://www.freebsd.org/cgi/ports.cgi?query=mozart&stype=...), though !i386 is flagged as broken.

well, my old link collection for oz is a little out of date but there should be some academic mention in the http://www.cpaior.org/ conferences series. (I used mozart-oz to create some hybrid algorithms back in the days but I didn't do it in the academic field but used it in commercial applications that I no longer are involved in)

Christian Schulte,http://web.it.kth.se/~cschulte/papers.html, wrote a book or collection of papers "Programming Constraint Services" that really what I can recall was using mozart-oz.

As you can see I only reference mozart-oz in the context of CP-AI-OR but 2000-2004 I used it more or less weekly to do all kind of "normal" programming (whatever that is;)).

This will give some more odd results http://www.google.se/search?q=round+robin+scheduling+mozart

Thanks!

Amazon reviews for this book:

http://www.amazon.com/Concepts-Techniques-Models-Computer-Pr...

One of my friends has been working through CTM. He is blogging his progress at http://ctm-himanshu.blogspot.com/

my god I loved SICP -- finally, a computer science book that taught actual concepts. If Brian Havey (one of my profs at Berkeley) gave this a two thumbs up, I'm sure it's worth keeping as a reference.

Does anyone know how different this version is from the final version that went to print? The site for the book talks up the difference but is hardly an impartial source.

My god, from looking at the table of contents this really looks like "SICP 2"!

It's not in any way a sequel, but the material is very complementary to SICP. It's also very well written, imho.

(There are, in fact, other deep computer science books that aren't related to SICP. :) )

I have to second this, of all the programming books I've read CTM comes closest to teaching me how to think in new ways as SICP once did.

If you haven't read CTP yet, buy it now and make it your downtime reading.

IMHO, you should move to RWH after SICP

http://book.realworldhaskell.org/

I don't think that RWH is at the same level of SICP and the other masterpieces of programming language theory: CTM and TAoP (The Art of Prolog).

RWH is just a good Haskell book teaching people how to do practical things with the language, but it doesn't have the intention of reaching the level of conceptualism and abstraction that the books I've mentioned achieve.

In fact, I think that RWH is not a good book for learning Haskell unless you're a Java programmer. It's mainly written for that audience. In case you come from Lisp or even Ruby or Python I'd strongly recommend A Gentle Introduction to Haskell (http://www.haskell.org/tutorial/).

It's been the officious Haskell tutorial since 1998. It's short, free and written by very relevant members of the Haskell community.

RWH is great too, but the topics are very different. RWH is about using functional programming. CTM is about a lot of different paradigms. It starts with a simple core language, and a set of features, like dataflow variables, lazy evaluation, higher order functions, concurrency, ports (message passing queues), mutable state, backtracking. Then it explores what happens if you take a subset of these features. For example dataflow variables + concurrency is deterministic concurrency. Mutable state + higher order functions can support object oriented programming. Ports + concurrency is an Erlang like model.

Lazy functional programming is just one of these models (higher order functions + laziness). CTM shows that other models can be beautiful and powerful too.

Could you tell us why?

Reply on news.ycombinator.com