Re: Paul Graham's Arc is released today... what is the long term impact?

On Feb 19, 10:58 pm, dkixk <dki...@xxxxxxxxx> wrote:
On Feb 19, 7:32 am, "Kjetil S. Matheussen" <k.s.matheus...@xxxxxxxxxx>
wrote:

On Mon, 18 Feb 2008, Damien Kick wrote:
Kjetil S. Matheussen wrote:

[...] I still end up writing the macro version instead
only because "(when a b)" is faster to read
than "(when a #'(lambda () b))".

Really? Faster to read. If you sat down with a stop watch and actually
timed yourself, how long do you think it would take you to read either
form.

Its faster to read because its less messy, not because the time
looking at each token takes very much time. [...]

So one would look at each token in about the same time and then our
mental processes are supposed to get bogged down because of all the
extra "mess". What is this mess to which you're referring exactly?
Certinaly it can't be typographical messiness because you just agreed
that it would not take very much time to look at each token, whatever
a token is in this context. If we're writing a compiler, certainly
there are tokens. Are you so sure that your mental processes involve
something called tokens? Where does a token live in the brain,
exactly? And if the messiness isn't something more or less
typographical, if it is somehow semantic, why in the world would it
make any difference to use a word other than LAMBDA to try and clean
up the mess? Can't have it both ways.

Less messy. Cleaner. More readable. This is all still bull*** hand
waving to try and avoid just coming right out and saying, "I like it
better." Not because it's faster by any standard measure of time or
has been found to be so by any kind of repeatable experiment conducted
on a random sample of a relavent population or by anything even
remotely approaching so much as a pseudo-objective measure of
"goodness" or "lack of messiness". You just like it better. That's
fine. I happen to like the word LAMBDA because I like the association
with the intellectual history that gave birth to its use in Lisp. Not
for the CADDR of a WHEN form, though. But that doesn't mean that my
code, which uses LAMBDA, is "slower to read" or is somehow "messier".

In a round-a-bout way I think you have hit the nail right on the head,
except you are wrong. Of course the mess that he was referring to in
the second example is everything that is not in the first example. It
is a mess because it has nothing to do with the task at hand. In
fact, the #' syntax is a leaky abstraction. It is a piece of the
underlying implementation of a lisp-2 that is bubbling up into the
programmers point of view, and it is necessary to talk to the
compiler. Liking lambda's for historical reasons is quaint, but we
are talking about how to improve a programming language, not how to
hold them back for historical warm fuzzies. In this case, the goal is
to find the most efficient way to translate ideas in our head into a
language that both people and computers can understand.

As for goodness and testing on populations. You can find lots of work
which looks at library design, and it's quite clear that the fewer
concepts that must be dealt with by a library user to achieve the
exact same functionality the better. Concepts are represented by
groups of neural columns in your cerebral cortex, and you only have a
finite amount of attention to which you can give each one. Minimizing
the attention which is spent on concepts not directly leading to the
implementation of the ideas in your head is smart. It leaves as much
attention as possible for the primary task at hand.

I completely agree with you, though, when you write in another post in
this thread that

Hmm, I wonder if this, eh, dilemma can be solved just by using a
more intelligent text editor

I share this intution that a large part of this endless religious war
between those who hate vowels and those who love them should be solved
as a problem of customizing the display of a piece of code. I'd
posted something similiar previously <http://tinyurl.com/2trqta> and
Ray Dillinger had pointed out what he thought was a problem with the
idea <http://tinyurl.com/2rxqnd>. I haven't actually heard of a
system which customizes things like the displaying the names of the
symbols used according to user preference.

I'm sorry, but I completely disagree yet again. If you are automating
the generation of text which is going to be splatted into your
programs then you are forcing any future readers of that text to
actually deal with the splatted stuff rather than the nice concise
thing you actually input. When you read any words or groupings of
words for the first time you have to parse them piece by piece to map
them to their meaning. After having seen the same words or groupings
over and over your brain actually learns to recognize them as a single
unit, which lets you read and understand their meaning in much less
time. It is a bad idea if everyone is looking at things in different
ways, and depending on what editor, or browser or mail reader you are
looking at things look different. Methods that are used often should
have short names because you will type them often and remember them
anyway, while methods which are used less should have more descriptive
names to remind the user of their meaning. Look at Ruby for a very
well done standard library that uses clear names which are
considerably shorter than what common-lisp has.

-Jeff
.