Since I got back into Lisp again (I had a wonderful flirtation with

it in University, but it was presented as a toy language, so I

didn’t stick with it), I’ve been telling people how incredibly

freeing it is, and how I seem to be allergic to syntax. I’ve had a

hard time explaining this to other people, and finally hit on a way

to do it. This essay is the result.

Before I get into this, some general comments on Lisp:

If you’re saying “Eww, how can you count all those parens?”, You’re Doing It Wrong . See scheme-style for how it actually works. Note that this objection is different from “I don’t like all those parens”, which is a perfectly legitimate personal choice, but see the rest of this essay.

. See scheme-style for how it actually works. Note that this objection is different from “I don’t like all those parens”, which is a perfectly legitimate personal choice, but see the rest of this essay. If you’re saying “But Lisp is a toy language”, you’re simply incorrect .



Unless you want to make one of those two points, please feel free to

email me about this essay.

Moving on. I use an example out of Perl. It doesn’t actually

matter what the example means, I don’t think, except that it’s

setting a sub-set of a complex data structure hanging off the object

“self”.

Let’s say we have:

$self->{'CONF'}->{'outerdatawindow'} = $outerdatawindow;



I have no idea how this would work in

CLOS off the top of my

head, but let’s say it looks like this in CL:

(setf (outerdatawindow (CONF self)) outerdatawindow)



In both cases, I need to know:

what type of thing self is as a data structure

what the CONF slot is for, and what type of thing it holds

what the outerdatawindow slot is for, and what type of thing it holds



In the CL case, I also need to know:

what function application looks like

that the CONF and outerdatawindow functions are slot accessor functions

what setf does



It is important to know that the first one doesn’t count to me:

no matter what language I’m in, I need to know what function

application looks like.

On top of that, the last one doesn’t really count either: it’s just

a library function, every language has them, and I’m always having

to look them up no matter what; that’s just how my brain works.

So, in my head at least, only one additional item of information is

needed for CL that wouldn’t be needed for any possible language.

In the perl case, I need to know:

what = does

what ; does

what $ does in both places, which are in my mind quite different: retrieving a value feels different than retreiving a reference to a value. This is a problem with my mind rather than Perl, but that’s what this whole essay is about anyways. I probably wouldn’t have this problem if $$foo{‘bar’} didn’t work, but that just makes $ Incomprehensible Magic to me, so that every case of its use is a special case in my mind.

I probably wouldn’t have this problem if $$foo{‘bar’} didn’t work, but that just makes $ Incomprehensible Magic to me, so that every case of its use is a special case in my mind. What -> does

What {...} does

Whether the quotes are actually necessary or not



In any given programming situation, for every one of the points

listed above, the odds of my having to look something up are, at a

bare minimum, 1 in 10. That is, if I’ve been programming my ass off

in a language for days and I know this shit cold, for every chunk of

information like the ones above, there’s still a 1 in 10 chance

I’ll have forgotten it and have to look it up; I keep many

standard library reference windows open when I code, always, and

often many language reference windows open.

The less familiar a language is, the higher that 1 in 10 goes, of

course, but it never goes lower than that, and I think 1 in 10 is a

pretty generous estimate; the lower bound may be more like 1 in 5.

So every chunk added to a statement is another seperate-die-roll

chance that I have to look something up.

In Lisp basically all I need to know is function application and

what the functions do and what’s in the variables. All inescapable.

Yes, lisp has special forms, but they’re few and far between, and

I just treat them as functions anyways, because that’s mostly

what they look like. There was a conversation whith kpreid where I

realized that I was fucking up because of that, but mostly it works.

New pieces of syntax (like $ or -> or whatever) cannot be handled in

this fashion.

I think the difference between me and other people is that for other

people, after a while the syntactical bits stop couting as data that

one might forget, and that’s never true with me. They always count,

and I routinely have to look them up, and that’s on top of

having to look up functions routinely. So every bit of syntax

gotten rid of makes me happy.

To give you a sense of scale here, I remember having to stop and

think about how to do function application whilst working with

Oz, when I was right in the thick of it.

Now, Oz’s function application syntax is unusual, but I was doing at

least an hour in this language every single day, and it’s not

that unusual. No question that this whole issue is a problem

with my brain; I just wanted to explain the problem once and for

all, since it’s hard to convey to people.

It’s worth noting that this may all be illusory. I feel that

syntax-heavy languages have more places-per-line-of-code that my

memory can fail me, but that may not actually be true. It may

simply be that looking up functions annoys me less, because it’s

unavoidable. Even if that’s all it is, being less annoyed is

valuable all by itself.