yet another noob via "little lisper" and scheme


After reading some of Paul Graham's stuff more than a year back, I picked up a (very old) copy of LL a while back, and am slowly getting through it. Having looked at some of the intro threads here, it seems I'm far from the only one to come this route.

Coming from an EE background, with no prior knowledge of "language design" (to me PL's have always been just tools to get the job done, my formal education in the subject is most rudimentary), this is quite an eye opener. I'm doing examples an exercises using DrScheme, and the fact that I seem to be able to get things to work is reassuring. But it is a VERY odd feeling to write functions that DO work, sort of know why they work ... and yet have all my usual tools for "reading code", erm, rearranged. The process has made me want to look at functional programming in much more depth, and check out languages liek Haskell ... but one thing at a time.

Anyhow, it's a lot of fun, and I'm happy to have found this stuff, although I've no idea where it's going (well, I did read ahead a few pages and it looks fairly mind boggling ...)

This was just to say "hi". I'll lurk around here and maybe ask the odd inane question, but I'll try not to make it *too* dumb.


Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

While you're on Scheme... suggestion would be to stick there for at least a while longer and read Structure and Interpretation of Computer Programming.

I'll second that

SICP was a great eye-opener for me, and it taught me to love Scheme. Common Lisp is all very well, but Scheme was the language that won my heart.

Then I met Haskell. Now, my memories of Scheme are like a third-year frat-boy's memories of his high-school sweetheart*.

I would suggest that you stick with Scheme at least as far as understanding hygienic macros and continuations. Then move on.


* But without the furtive, sticky parts.


I've come across it, and I may well dive in there. I've no reason to be in a hurry to leave scheme anyhow. But what's your own reason for reccomending the book?

Best introductory text ever written

You'll find the text highly regarded by almost all the functional programming communities (Scheme, Haskell, ML, etc..).

That and since you've expressed an interest in learning Haskell, maybe you can help on the SICP translation I'm slowly trying to grind away. Haven't got anyone interested yet (probably won't happen till I get the first 3 chapters get done - and then I'll get mostly criticism), so I'll likely have to cultivate someone who has just finised up Scheme/SICP and wants to move on to ML or Haskell. You're my first attempt at proselytizing someone in that group of candidates. :-)

Seriously, though, you'll find many, if not most, on LtU would recommend the book.

SICP lectures

I'd also recommend taking a look at the SICP lectures. Hal Abelson and Gerry Sussman are both extremely good teachers, and the lectures give a you a perspective on the material that's hard to capture on a printed page.

maybe one day ... !

OK. I'll definitely put some time into it. It's going to take a long time though, I doing get a lot of hours to invest in this.

And if I end up learning Haskell or OCaml or something at the same time I read it ... I may be able to chip in.

(Actually I was considering attempting Little Lisper in perl, which is mostly what I use at the moment ...)


I'm from the same background, and I had to supplement my fundamentals a bit to understand languages better: mathematical logic (it helps quite a bit if you want to learn about type systems later on), Turing machines, computability, etc. and then lambda calculus. The untyped LC is usually a single chapter and can be covered in a few hours, and it explains how functions actually do work.

Also see our Getting Started Thread.

Perl translation

Not a language that I do much with, but there is some activity in the Perl community wrt functional programming. I do think, however, that even if you can manage to do some FP in Perl, it's rather a hard language to learn the paradigm in.

I gave a few moments thought to translating the Little Schemer to Oz, having just done a big chunk of the Reasoned Schemer (the latest in the Little series). But then I figured I'd run into the same kind of translation issues as I would with SICP. I've been working sporadically on SICP for 9 months in Alice (really only a couple days here and there), but it has been secondary to the translation of CTM. Did manage to get chapter 1 translated into Oz and OCaml over the weekend, but it will take some more long weekends before I get much else done.

Anyhow, good luck on your PL journey. LtU suggests more than ample material for reading that can occupy any spare time you happen to make. :-)

[Edit Note: I must've pushed reply to the wrong message, because this was intended as a reply to danmcb.]

One more noob


I'm coming from a similar background as Daniel. I've been reading The Little Schemer in the past few weeks (not to mention lurking in LtU for a while longer) and would like your input as to what to take on next. I'm undecided between The Seasoned Schemer, CTM or SICP.

Though TSS is already sitting on my shelf, I'm currently leaning towards CTM (mainly because of the comments I see here in LtU and because it supposedly has a good section on concurrency, a subject I'm very interested in). The biggest argument against it is quite pedestrian, the price is a bit scary (MIT press is MIT press...). So, what would you recommend?


It depends on your taste. I think SICP and CTM have more breadth and address more practical issues. SS is more like little polished nuggets of prog. lang. theory. I would probably go SICP or CTM first, then SS to address some of the highly technical issues the first two elide. As for price, I have heard that CTM was once available on the web, and if that were so it is entirely possible that would have a copy. You didn't hear it here first!


I was initially a little put off by the price of CTM too. But I eventually bit the bullet and bought it. Trust me, it is well worth the money.

[Edit]: Peter, if you happen to be reading this thread: Thank you! CTM is probably one of the most worthwhile textbook purchases I've ever made. You and Seif did a wonderful job putting it together.

Well worth it

Indeed. I've found it well worth the money, and I'm only about 1/3 of the way through it, with an awful lot that I'm really looking forward to reading. Plus it's got a much more clear and readable format. I know a lot of people like the Socratic method used in the Lisper line of books, but I find it almost impossible to read and work with. The Little Schemer is one of the few books that my dog destroyed as a puppy whose passing I did not mourn.

Price of CTM

MIT Press judged (correctly, as it turns out) that CTM would be appropriate for the educational market (university courses) and not just for the scientific market (researchers and advanced industry). That is why the price is as low as it is (!). If you've seen other technical books, e.g., by Springer, you know what I mean.

There are also used copies for sale on Amazon and elsewhere (see BookFinder). Some of them are probably student copies. If you check the Wayback Machine you can find the draft we had on the net. The printed version corrects most of the errors in the draft and is more polished.

If You Had to Save For a Year... afford CTM, it would be well worth it: I have every confidence that in a year's time, CTM will still be heir apparent (IMHO) to SICP, the content will still be relevant, Mozart-Oz will still be available, and there will still be much for even expert programmers and computer scientists to learn from it.

Thanks for all the

Thanks for all the responses, I'll try to find an used copy of CTM and save SS for later.

get it used? :-)

thanks everyone!

for all the helpful replies.

I don't see any problem in reading SICP on the web while working through Little Lisper at the same time, as they are so different in approach. In teh end it's all just goes in the pot. I find LL quite intense, as it is so hands on, the more analytical approach of SICP might be quite complimentary.

It the moment it is all a bit like having my brains rearranged from the inside. FP is such a different way to work, lots of preconceptions get ripped up in short order. I'm still not sure if or how I will actually use this way of working; I guess that will come out in the wash.

Tertiary Benefits

danmcb: FP is such a different way to work, lots of preconceptions get ripped up in short order. I'm still not sure if or how I will actually use this way of working; I guess that will come out in the wash.

Look at it this way: if all it does is help you be less mystified when you see an anonymous object being created and passed to a method in Java, or be a good judge of when boost::lambda can help you in C++, it will have been worth it. One reason that I heartily recommend CTM is precisely because it isn't about just one paradigm and in fact explicitly rejects purity for purity's sake. The trick to being a competent programmer is having a comprehensive toolbox and, over time, the wisdom to know which tools to use under which circumstances.

Also, HtDP

You might also want to check out How to Design Programs by Felleisen et al., which is intermediate between LL and SICP.

It expands on the ideas in LL, but it's a little gentler than SICP (which is to say, it's a little more like an undergraduate textbook, for better or worse).

Others may wish to give other characterizations of LL vs. SICP vs. HtDP.

This article might be of

This article might be of interest.

My views

I didn't read the thread you linked so hopefully I'm repeating too much, but my impression is that HtDP is very gentle making it a good book for a complete beginner, but rather boring for more advanced programmers. SICP is extremely fun to read, but one of it's "problems" (for some) is the gratuitous mathematical examples/exercises, I would not recommend SICP for a complete beginner as it may send the wrong impression of what programming is and is like. For someone who already knows how to program it is interesting.

Part of the reason for my recommendation above...

...was the poster is a EE, so the engineering bent of SICP actually works in his favour. :-)

shouldn't be a problem, I

shouldn't be a problem, I think. I've quite a bit of "real world" programming experience, what I want is to broaden my mind more than anything else.

I'm pretty used to reading texts and filtering as I go too. With teh amount of stuff there is out there, that's a must ...

SICP's a keeper

I hate to just chime in, but that's all this is. Yes, he'll probably like SICP with his EE background. (I started out in that a long time ago, before I realized how much more fun it was to code than design circuits.)

I liked SICP a lot, and it's one of the books surviving my personal library purges. Coincidentally, I just fished it out of my garage again this last weekend, because I wanted to look at some environment material again.

A lot of SICP shows it was written by brilliant thinkers who can say things crisply when they want to do so. I expect beginners with little coding experience might feel slightly daunted, because quick studies at MIT were a primary audience.

(A bit OT, but hey ...)

"(I started out in that a long time ago, before I realized how much more fun it was to code than design circuits.)"

The funny thing is, when I started studying software in earnest, after quite a lot of years in hardware, I relearned a lot of concepts that were very familiar ...

For instance, when I got into OOP I met the idea of abstracting the API from the implementation. Well, what's one of the first thing you do when you go to design a circuit board? Assign signals to the edge connector. You can then publish that to the rest of the team before you even build anything, if you're reasonably sure of it.

Inheritance as a means of promoting code reuse ... well, when you design a complex system with many boards, you look for common elements that you can build as modules or common circuits or whatever. Once you have them designed and debugged, you reuse them everywhere you can, or use them as a start point for new designs. (Over time you start carrying libraries of such things around with you ...)

I guess those ideas have been used in other industries too, though no exmaples spring straight to mind.

It seems there is no much that's new in the world, anyhow.