Ryan's Tech Blog

I’ve seen a lot of complaints about the lisp community being arrogant bastards who are too busy being smarter than you to help. Over the past few months, I’ve been observing behavior, lurking in #lisp, and I think I’ve figured out the source of confusion. The lisp community behaves differently than many other communities, and many lisp newbies have no way to know that.

Based on the many blog posts and articles extolling lisp, as a newcomer I expected the room to have:

• jubilant evangelists hopping at the opportunity to make another convert
• experts offering silver-bullet solutions to every problem
• rapid-fire discussion on how to solve hard problems (with silver-bullet solutions)

Obviously, I was wrong.

• There are no evangelists on call to help new lisp users. Some people have the channel open, and will offer advice, but there’s no one chomping at the bit.
• experts will offer solutions to problems, if you ask an intelligent question
• occasional rapid-fire discussion about hard problems that are WAAAY over my head
• occasional discussion about simpler problems
• lots of redirecting to web pages with information

I think the hype around languages has been taken up a notch since ruby and rails hit the scene (my brother and I would joke about the hyperbole by trading suggestions over IM like “why don’t you just $gem install my_internal_webapps”). Language mavens get practically orgasmic in their praise, so much as to spawn a mock blog: Lisp at Light Speed. That thing makes me laugh every time I read it. I’m noticing a trend: the real core members of a community are too busy working to blog, and most evangelists don’t have a lot of knowledge, they just feel really good about what they’ve done so far.

I’ve asked easy / stupid questions in #lisp without any noticeable backlash by treating it as if I were a 6th grader in the university library, surrounded by Ph.D students who are all working quietly on their own theses. This is how I handle any knowledgeable group that I’m trying to get help from. I check every reference manual I can find first (clhs, practical common lisp, google), if I have code I first copy/paste it into pastebin, then include that link along with a lengthy, detailed question. I re-read my question a few times, thinking if I could phrase it any better, then submit. For now, all my questions have been basic enough that someone will link me to the relevant resource or give a terse answer almost immediately.

I have seen some people ask questions without much forethought, and get criticized bluntly, which too frequently gets interpreted as harshly. I saw someone post some code, claiming to have solved some problem for the community, and the terse response was something like “that code is not very good”. It’s the truth, but that’s gotta sting. I tried to soften it by eliciting some specific recommendations for the newcomer, but I think that person will simply walk away thinking #lisp is full of assholes.

In my mental image, that sixth grader just walked up to the Ph.Ds with some chicken scratch on notebook paper and said “Hey, I did this for you”. The Ph.Ds, being engrossed in their work, look up and immediately think “there’s no way I could ever use that”. Being used to talking to other Ph.Ds, they dismiss the kid’s paper, trying not to be mean about it, and then go back to work.

It seems to me that much of the negative impression around the lisp community arises from sky-high expectations and bad question asking procedures.

We’re grinding (in the RPG sense) with lisp at work, and keep coming into problems that have multiple simple solutions, but don’t have the instincts/knowledge to readily identify which one is best. One such problem is building up strings, in a couple of cases. I took some time this morning to go through the cases, using a 10000 iteration loop and time to do a simple benchmark. The tests were run on SBCL 1.0.11.

UPDATE: added metrics with *PRINT-PRETTY* off, as suggested in comments. This has a big effect.

Conversion

There are some cases where we wanted a number as a string, as part of building HTML. For this demo, we’ll put the number in variable *d*:

(defvar *d* 19.80)

We found three options:

1. cl-interpol: #?”${*d*}” => “19.8”
2. (princ-to-string *d*) => “19.8”
3. (format nil “~a” *d*) => “19.8”

Here’s how they compared:

Princ-to-string is the bigger winner in this case.

Simple Prepending

For the this case, we have some decimal value in a variable called *d*, and want it in a string, prepended with a “$”.

We identified three possible solutions:

1. (arnesi:join-strings (list “$” (princ-to-string *d*))) => “$19.8”
2. cl-interpol: #?”$${*d*}” => “$19.8”
3. (format nil “$~a” *d*) => “$19.8”

Here’s how they compared:

In this case, cl-interpol wins on all counts, after compile time.

Dynamic Prepending

In this case, our prefix is determined by another variable:

(defvar *prefix* "$")

1. (arnesi:join-strings (list *prefix* (princ-to-string *d*))) => “$19.8”
2. cl-interpol: #?”${*prefix*}${*d*}” => “$19.8”
3. (format nil “~a~a” *prefix* *d*) => “$19.8”

Now things get a little messier, and dependent on the setting of *PRINT-PRETTY*. join-strings wins big if *PRINT-PRETTY is on, but if its off, then cl-interpol takes the cake again.

Simple Wrapping

In this case we want to put some text before and after our value.

The options:

1. (arnesi:join-strings (list “$” (princ-to-string *d*) ” USD”)) => “$19.8 USD”
2. cl-interpol: #?”$${*d*} USD” => “$19.8 USD”
3. (format nil “$~a USD” *d*) => “$19.8 USD”

The data:

cl-interpol is still the winner, which is expected given the results of the simple prepending.

Dynamic Wrapping

Now let’s put the suffix into a variable and see how it goes:

(defvar *suffix* "USD")

The options:

1. (arnesi:join-strings (list *prefix* (princ-to-string *d*) ” ” *suffix*)) => “$19.8 USD”
2. cl-interpol: #?”${*prefix*}${*d*} ${*suffix*}” => “$19.8 USD”
3. (format nil “~a~a ~a” *prefix* *d* *suffix*)=> “$19.8 USD”

The results:

Another mixed result, depending on *PRINT-PRETTY*. Again we have join-strings if you need *PRINT-PRETTY*, cl-interpol if not.

My Conclusions

Use princ-to-string for simple conversions, use cl-interpol everywhere if you can turn off *PRINT-PRETTY*. If I need *PRINT-PRETTY*, then use cl-interpol and replace it with join-strings when tuning performance.