Subject: Re: superior(?) programming languages
From: Erik Naggum <>
Date: 1996/12/20
Newsgroups: comp.arch,comp.lang.lisp
Message-ID: <>

* Adam Alpern
| Oh, wait a minute - add about 10 to that for the function I wrote to
| count the lines in every file.

I see.  but such numbers are wholly irrelevant.  the only lines _I_ could
have counted are ones that got saved into a file or otherwise committed
that was not immediately overwitten with a new version.

| You estimate that you've written about a million lines of code over 15
| years.

just for fun, let's see how irrelevant this can get.  if I hold down my
RETURN key, I can "write" a line of code every 18 ms once the autorepeat
kicks in.  it would take me 5 hours to produce a million lines at that
speed.  and if I wanted (god forbid!) to _cheat_, I could type C-x ( RET
C-u 1000000 C-x ) and have it done in about 2 seconds.

on a less useless note, you can measure somebody's typing speed in terms of
the number of keystrokes per second sustained average, and you can measure
it in terms of _successfully_ typed words per minute, where there are
penalities for mistakes, such as text saved on disk during a day.  writing
prose text in news articles, I generally average 7.5 keystrokes per second
while writing, and this is no big deal.  I make a small number of mistakes,
but I also rephrase myself several times over before I post, stop and
think, etc, so the average is down to 2 posted characters per second with
some articles.

I can't count all the throw-away code I have written any more than I can
(or will) count IRC or non-saved text in my literary production.  if you
write five drafts for a book before it's published, you haven't written
five books.  it's as simple as that.

| I've been coding in Lisp for 5 years, and I estimate I've written about
| 1/3 of a million lines - is it impossible to believe that someone else
| can code at the same speed you can?

not at all.  Lotus, Inc, has estimated that there is en order of magnitude
difference in coding speed between their _good_ programmers.  that is,
measuring code that the programmer gives somebody else.  this is like the
secretary standard for typing speed compared to the raw "hack speed" -- a
hacker may well type like a maniac (10 keystrokes per second is not _that_
unusual), but still end up with less effective speed than a secretary who
types only 30 words per minute but never makes mistakes.  (for purposes of
comparison, 1 keystroke per second is 10 words per minute.)

| You've obviously extrapolated quite a ways beyond my original sentence. 

no, I took it at face value, and then got _really_ disappointed.

| Published?  When did I say publish?  I said "written".  To have published
| that much code would indeed be a real acheivement, and I wish you luck.

thanks.  I wish you well, too, after this cleanup job, but please don't use
"written" to mean "typed".  that is not at all impressive.  you should also
work harder to _reduce_ the number of lines of code you write (and type).
it's not the number of lines that count, but what you get done in them.

example: a student I had the pleasure of guiding through her thesis on
abstracting a document type definition from an SGML document instance,
wrote her first major Common Lisp program to prove her point, and she wrote
about 12 000 lines.  I took over the code after that and worked a bit with
it to get it into production state.  it had been reduced to 1500 lines when
we were all done, and ran 70 times faster.  still, a naive reimplementation
of some of the functions in the admittedly procedural style she had used
required _twice_ the number of lines in Pascal!  if a Pascal programmer
worked his ass off, he would appear 4 times more proficient than a Lisp
programmer, as he would probably spend nearly the same time thinking about
the problem as we did.  Lisp gives the programmer more time to think, IMHO.

I saw a TV production about the Bill Gates imperium some time ago.  at some
point, IBM wanted everything measured in "KLOCs", and somebody (Paul Allen,
I think) said "if we work smarter and write fewer lines, we don't want to
be punished for that".  I agree with this sentiment, and thus find "lines
of code" to be a moderately useless measurement in the first place.

indeed, it can be construed that whoever writes too _many_ lines per unit
of time should stop expanding macros by hand and instead let the machine
write those lines.  not to mention the fact that your carreer may be
measured in a fixed number of keystrokes due to various strain syndromes,
not unlike every living animal supposedly lives for about the same number
of heartbeats (within an order of magnitude difference, anyway).

(as long as we count useless things, my pulse while coding averages 60.)

users should be computer-friendly.