How Studying SICP Made Me a Better Programmer, part II

Okay, I told “Jon” that I would follow this up, so here goes.

The problem I had with the code last time was that I was leaning too much on bad habits I developed staring at too much relational database code. I used a hash table to store everything about the data structures. In all my functions for manipulating the data, I had to tag the arguments with an additional reference to to the hash. This was pointlessly cumbersome. What I really needed to do was eliminate my dependency on a data store and just use cons, car, and cdr to construct everything. This allows me to treat my data structures (and pieces of my data structures) as primitives in a linguistic abstraction layer. As a bonus, all of the standard common lisp operators work with them without any “crutches” or extraneous code getting in the way.

One thing I learned going down this road is that the Visitor Pattern is hardly anything more than an application of mapcar. I remember trying to learn about Design Patterns a few years ago and I just couldn’t pick many of them up. The code examples for them and the UML diagrams seem to me to do a good job of obfuscating the whole point. Your brain has to “compile” so much information just to get to the point– its no wonder so many developers mangle them up in the application of them. After reading SICP, it’s much easier to parse them. In a lot of cases they just do things that are very similar to what I want to do in my more functional language anyway.

Another thing I picked up in this exercise was that dynamic variables and hash tables store references to the “conses”. This means you have a lot of control over the lists that are stored in them. It also means that I don’t have to work too hard to write code to manipulate or transform them. Life certainly gets easier coding in Lisp once you think in terms of “pairs” so fluently that they are more natural than anything else. The example code for this post demonstrates some implications of this in detail, so folks that are just beginning their studies with Lisp will want to take note of what’s going on there when we start doing the “forbidden” destructive operations….  (The output of the Common Lisp code should look like this.)

Finally, after having slogged through most of the first two chapters of SICP, I can finally understand much better how bad a developer I’ve been. On the one hand, I can comprehend a much wider range of architectural approaches… but as a consequence it’s sinking in more and more just how limited my mental programming vocabulary was up until now. I really had no clue how ignorant I was. I knew I was struggling with things that should have had tidier answers, but I really thought I could only ever get just a little bit better than what I was. Now I can sense all those several orders of magnitudes that I have to go and I wish I could consume a dozen more books before going on to the next project– but life and learning don’t work quite like that….

The main thing is that I now see that I never really understood OOP near as well as I thought that I did. A lot of people objected to the recent Golf ball example that a Perl hacker recently used to criticize typical object oriented “design,” but that guy sure had me pegged. Of course, good OOP design is going to be almost indistinguishable from functional programming approaches in some cases– even if it’s a little more verbose– but I don’t think I would ever have understood that so well without my many hours spent with Lisp and SICP.

4 Responses to “How Studying SICP Made Me a Better Programmer, part II”

  1. BigMouth Says:

    Out of curiosity–how long did it take you to grok the first two chapters at the point you are at now?

  2. lispy Says:

    I started studying Lisp 6 months ago.

    After 14 chapters of Practical common Lisp, 23 short chapters of Shapiro’s Lisp book, 10 chapters of Ansi Common Lisp, 8 chapters of On Lisp, and 2 chapters of PAIP, I still had a *lot* to learn. SICP was a much more profitable book given where I was at mentally, but it covers alomost no Lisp syntax at all; it’s highly minimalistic. That allows you to focus on the concepts and not the language.

    I wasted a lot of time struggling on my own at first. With a study group a lot less time is lost on such wanderings. You could probably do a section a week if you skip the most difficult problems and keep moving– the videos are a big help at clarifying the main points, too.

    So I’d say that a typical programmer– even a bad one– should be able to get the point of those two chapters in 6 to 8 weeks if she dedicated all of her “spare time” to the task. Not counting some of the time I spent chasing “rabbit trails” that’s about how long it took me.

  3. Lisp at Work: Evidence Based Scheduling « Learning Lisp Says:

    […] when more straight-forward functions would have done the job. I built a new data-structure when one that I’d already written would probably have been sufficient to the task and allowed me to think at a higher level […]

  4. Pierre Says:

    I have been reading SICP recently together with a couple of other books. One of them has been quite helpful in my attempt to digest all the materials. It is the well-known CTM books.

    You might want to give it a try.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: