duncan wrote:I'd suggest that in addition to reading books about CL you start looking at the simpler libraries.
Thanks so much for your help. Is there a library in particular you would suggest? I don't mind researching them on my own, but if you could point me in a general direction, that would be great.
Well, to begin with you might want to take a look at some of the libraries in cl-utilities. A lot of them are pretty compact, self-contained, and not hard to understand. Split-sequence is written bit differently than I probably would have chosen to write it, but it's nice and short and provides a good introduction to loop
. Pretty much any library you can find that's both very short and used widely enough that you can be sure it works is probably worth reading at first.
In terms of larger libraries, all of Edi Weitz's libraries that I've looked at have been well coded. Unfortunately a lot of them are too complicated to start with, particularly if you haven't been programming for that long. PPCRE tends to get mentioned as good reading, and it does some very interesting things with closures, but it requires a fair amount of background knowledge. Cl-who is quite short though, and it illustrates a few things quite well. It's worth noting how it uses a bunch of regular functions to build up the facilities necessary for the transformation it implements and then uses a few very short top-level macros to get the convenient syntax that's desired.
Other things about Edi's code that are worth looking at, IMHO, are: A fair bit of what he's written needs to be pretty efficient. He tends to do the right thing here, writing efficient code without doing extreme and marginally useful stuff. He also makes use of special variables in a nice idiomatic way. In a lot of languages global variables are best used very sparingly, but CL's special variables avoid a lot of the problems with globals, and they can make code significantly cleaner when used well. They don't get as much press as, say, macros, but they're a nice feature. And in general what he writes tends to exhibit "good taste." So after you've read some shorter libraries you might want to move onto some longer ones. If you're interested in clients, and servers, and protocols (oh, my!) you might find drakma and hunchentoot interesting.
Metatilities also looks like it has some pretty interesting stuff in it- I haven't read through it, but cl-containers looks as if it might be particularly interesting. One thing about programming in a language that comes with a fair number of useful built-in data structures is that it's pretty easy to not learn how data structures are actually implemented in that language. Since there are a number of good open source CLs largely written in CL you can always go and look at how, say, hash tables are implemented in one of them, but if there's a lot of dependence on internals that can get a bit hairy. Some of the other metatilities utilities are likely to require a fair bit of background though (like a good working knowledge of the MOP.)
I see that while I've been writing this Harnon has also responded, and his (?) suggestions are also good.