
Ron Garret: How knowing Lisp destroyed my programming career. - asciilifeform
http://coding.derkeiler.com/Archive/Lisp/comp.lang.lisp/2006-04/msg01644.html
======
jrockway
The only thing to take away from this anecdote is that libraries are the key
to getting things done these days.

When you are writing a compiler, you are doing most of the work on your own.
You don't need much help from external libraries. (Perhaps you need a compiler
compiler, but that's about it.) When you are writing a web app (or something
similarly "useful"), you aren't going to have much time to do your thing if
you are reinventing an HTTP server, a request dispatcher, a component loader,
an event handling system, a persistence layer, and so on. The reason the
author's C++, Java, and Python colleagues were getting more done than him is
that they were all building things on top of each other's work. The author was
starting with nothing every time.

0 + 1 person's work is almost always going to be less than (everyone in the
company's work) + 1 person's work. If Google used Lisp, he would probably not
be "behind".

~~~
azanar
There's more to take away than that, although yours is one big tangible reason
why he got left in the dust.

The major point I got from this article is that you can't stop being hungry
for knowledge and expect not to get beat by those who are. The language didn't
matter; he got bested by the people who kept learning and exploring while he
decided he had learned "enough" for one lifetime. He made the mistake of
making it about those around him; he didn't want to continually improve, just
better than those he would be compared with. He went from learning just enough
to best people, to being smug, to being a curmudgeon against other
languages/platforms/etc he professed to not know a lot about. I keep seeing
evidence around me that this is a very counter-productive shortcut to take,
but one that most people don’t own up to; props to him for being honest, but
sad that it took him too long to come to reason about it. In an odd way, I see
this same pattern of behavior in a lot of the one-language-wonder Java
programmers I meet today; they know Java, and find what reasons they can to
declare that all other languages suck.

So, your point about libraries is a good one, but I’d amend your remarks to
advise cultivating an attitude toward development that makes using libraries
and ideas of others almost instinctual, and that, I think, is by making sure
you always stay hungry for knowledge.

~~~
jibiki
I don't know how much you can cultivate that attitude, and how much it's just
something you're born with.

~~~
azanar
I think this is a deeper question than the downvoting you're receiving
suggests that it is.

There is a certain amount of one's desire to learn that is a matter of
personality, and my understanding is that there is some degree of a person's
personality that is determined by things other than socialization. Not all of
it, but enough to possibly make a difference.

The flip-side of this is that if there are people who, due to some or another
in-born trait, are unable to cultivate an attitude of continued hunger for
knowledge, that is something they need to deal with by not entering into a
profession that demands it. And programming is definitely one of those fields.

EDIT: silencing my own inner grammar nazi

~~~
lisper
> I think this is a deeper question than the downvoting your receiving
> suggests that it is.

Yes, I agree. (I upvoted the comment.)

A full response to this will take longer than I have right now (maybe I'll
work on a blog entry later tonight). But for now, just for the record, my
problem was definitely not that I was unwilling to learn new things. I _love_
learning new things, and always have.

~~~
lisper
<http://news.ycombinator.com/item?id=546080>

~~~
jibiki
> That's one of the reasons I hate Java, because learning Java didn't teach me
> anything except how truly brain-damaged a language can be.

> I learned more in my one year at Google than in the previous thirty.

This actually makes sense. It's not about being curious, it's about what
you're curious about. I remember once asking one of my friends a very basic
question about ring theory (whether a certain ring axiom is overly strong.) He
completely refused to consider the problem, because it didn't seem relevant.
That's not a lack of curiosity, just a lack of curiosity about irrelevant
questions, and math is all about knowing which questions to ask. It's not like
you learn nothing by solving the problem, just not anything you would have
ever wanted to know.

------
mahmud
Here is his own summary:

"The conclusion was inescapable: the problem wasn't Perl or C++ or Java, it
was me. I just wasn't a very good programmer any more. Lisp's power had made
me complacent, and the world had passed me by. Looking back, I actually don't
think I was ever a very good programmer. I just happened to have the good
fortune to recognize a good thing when I saw it, and used the resulting
leverage to build a successful career. But I credit much of my success to the
people who designed Common Lisp."

Yeah. I can attest to that. Many non-lisper friends have learned to do very
difficult things while _I_ personally remained ignorant of them because I
never needed them. This is analogous to how being a fortune 100 CEO is bad for
your health compared to being a day laborer; you no longer sweat and work your
muscles, you no longer get the necessary daily vitamin D from sun rays, your
hands are not as manly and rugged, etc.

Yeah, but then you can afford a chartered JetStream to fly you to the Bahamas
for 2 hours of Jungle Gym and back.

Ron Garret just wishes 37Signals to fork SBCL and get us Lispers some hype :-P
McCLIM windows with rounded corners FTW!

~~~
gord
Scheme implemented in Javascript for both server and UI might be a sweet spot.

This -

    
    
      "37signals DHH ports Rails to Scheme" 
    

would have been my april 1st HN headline sweetspot !

------
trapper
A good question would be who learns more: someone who is an expert at one
language and toolset, and continually uses it for investigation of new ideas,
or someone who continually changes his language and toolset. Given it takes
thousands of hours to become an expert at any combination of language and
toolset, I would rather spend my time doing great things than learning new
tools. Will you gain exponentially more programming skill by learning haskell
or erlang, or should you invest the same time learning another domain (e.g.
chemistry, biochemistry, finance etc), and solving new problems in those
domains? I would suggest that the latter provides more brain expansion.

Another way to look at it is that programming isn't hard in and of itself. The
hard part in any software project is understanding the problem. If all you do
is practice programming, and ignore the real world it's likely you will be a
great programmer, but make beginner mistakes when trying to solve problems. I
have seen brilliant programmers get completely schooled by domain experts with
excel macros when it comes to solving some of these problems.

It's the difference between programming for programmings sake or programming
to solve problems.

~~~
pfedor
I agree with everything you said but I would take it even further. One doesn't
even have to go to chemistry or finance to find better things to invest time
in than learning new tools. There are plenty of areas within the domain of
computer science/software engineering/hacking that are more worthy of effort
than learning a new programming language (let alone a new text editor or
version control system.) How about learning how to write code that matches
regular expressions in guaranteed linear time. Or implementing a compiler. Or
looking at the networking protocols used by QuakeWorld and how they are
different from the protocols used by the original Quake and why.

I'm not against learning new programming languages. Everyone should learn a
few different languages. I just think many people fetishize them out of
proportion.

------
sgrove
His story is almost sad - but in a good way I suppose.

I'm going back through my undergrad CS classes and picking up scheme and lisp
again, and I'm really enjoying it this time through. I feel retroactively
angry at the linguistic kludges I had to work around in other programming
languages before.

That being said, there's always room for diversity. Knowing different
languages will either reinforce your opinion of the superiority of your
preferred programming paradigm, or it will shed light on a new way that you
can hope to incorporate into future development. Either way, you end up the
better for it.

"The state of C++ was so horrific back then that they were forced to go back
to Lisp because they just couldn't get things to run in C++ even though they
tried very very hard." But I'm sure they were much richer for the experience,
with several new connections in their brains about how to approach problems
with a different set of limitations.

~~~
gord
"...I feel retroactively angry at the linguistic kludges..."

I can so relate to this - I was looking forward to hacking in Ruby after php /
C++ / Java , but this enjoyment is muted as I've now had a taste of Scheme...

Ill bite my lip and do some Rails hacking aboard the Lear jet...

------
drawkbox
I think this is a lesson that you dont' stick to one platform or language. You
always branch out. Programming fundamentals are the same, different syntax and
culture sometimes but you limit yourself to one language and you are done when
it is done... and it will be done at some point.

~~~
asciilifeform
>dont' stick to one platform or language. You always branch out.

The problem is that, to many Lispers, branching out from the Lisp world often
feels like branching out on a random path from Rome in its glory days might
have felt like - filthy, stinking barbarians abound in all directions.
Personally, I feel caged whenever I am not programming in Lisp or a language
with similar metaprogramming capabilities (Mathematica, for example.)

~~~
plinkplonk
"The problem is that, to many Lispers, branching out from the Lisp world often
feels like branching out on a random path from Rome in its glory days might
have felt like - filthy, stinking barbarians abound in all directions."

There are plenty of languages as "elegant" as Lisp, but are significantly
different in "feel" and usage - smalltalk, Forth, Prolog, Haskell, Io ...

Lisp has no monopoly on elegance or "metaprogramming", certainly not to the
point where the "classical rome vs stinking barbarians" analogy is valid.
(This ignores the historical fact that many greeks thought the romans were
loutish parvenus, but that is a story fro another day).

~~~
asciilifeform
>Lisp has no monopoly on elegance or "metaprogramming"

Lisp (or rather, the Lisp family - the word has not referred to a specific
programming language for decades) does have a monopoly on programming by way
of raw syntax tree entry. The latter appears to be required for a proper macro
system (though David Moon and others have attempted to change this.)

The fact is, I feel caged when I am programming in a language where I cannot
monkey with the syntax at will, and I am not alone in this feeling. When I am
barred from creating new syntactic constructs, I feel like a "human compiler"
(in fact, exactly that which the job title "programmer" actually meant in
practice before the invention of actual compilers.)

I wish to branch out to languages which feel _less_ limiting and _more_
general than the Lisps, not otherwise. And I have yet to encounter any. All of
the good ideas of Haskell (laziness, etc.) are easily bolted on top of even a
stock Common Lisp. Likewise for the other languages named. Forth, however,
remains interesting due to its AK47-like simplicity and embeddability.

~~~
dmoney
_I feel like a "human compiler" (in fact, exactly that which the job title
"programmer" actually meant in practice before the invention of actual
compilers.)_

[citation needed]

~~~
asciilifeform
Read a history of Fortran. It was originally meant for a human to compile into
machine code.

------
systems
Okay, so apparently he is now working on something called uwiki (pronounced
micro-wiki, because the u is actually a symbol that looks like u)

<http://www.flownet.com/ron/code/uwiki.html>

I am trying to analyze his choice of Python. Python in my opinion, is a
practical language, not a fun language.

Perl, Ruby and Groovy are all in my opinion more fun and interesting to work
with than Python.

Perl is my opinion, hardcore and the Perl community is again in my opinion by
far the most interesting.

Ruby, well, its hip! I guess, and all the girl developer are using it.

Groovy combines Java's practicality and the fun of using a dynamic language
with advance feature, like closure! or Groovy's definition of it

Python, well, yea okay they have Django and TwistedMatrix, other than that I
believe Python can destroy more careers than Java, C++ and Visual basic
combined, the community is so dry and the language is so boring ... which I
believe makes it an effective deterrent to any free-spirited individual

Python was one of the first languages I tried, and I have to say that it
knocked me out! and I am still recovering! The Python community just killed my
enthusiasm to be a programmer.

What I believe killed Ron's career, is that he never cared if Programming was
fun! And it seems he still don't! Lisp is smart, intellectual and intrigues
you to think, but not very usable and the brackets thingie, its annoying.
Python is not thought provoking at all but very usable and practical.

Perl, Ruby and Groovy are both!

------
petercooper
I enjoyed this post because I feel the same way about Ruby. Many moons ago I
used to know C (as in, I didn't have to look every little thing up), Pascal,
and even some x86 (for inline use only, mind).

For the last four years I've done nothing by Ruby and.. statically typed
languages freak me out now. I know I _could_ do it, but if it's not as super
easy as Ruby I'm not all that interested anymore even though there are
probably plenty of cool projects I could be using C, C++, Objective C, or
whatever for.

------
psyklic
It is the author's fault for not realizing the real-world skills he'd need.
You're not a good programmer unless you know multiple paradigms -- that's like
saying you're a mechanic but only being able to change the tires. And true,
knowing Lisp gives insight on the flaws of Java ... but knowing Java gives
insight on the flaws of Lisp.

------
hs
if current java/python/perl/ruby and their goodies were used instead back then
... could Rover in moon be REPL-debugged miles away from earth? ... given the
limitations of very low memory

i'm particularly curious about that one year learning from google

~~~
Confusion
Of course. Via [http://www.gigamonkeys.com/book/lather-rinse-repeat-a-
tour-o...](http://www.gigamonkeys.com/book/lather-rinse-repeat-a-tour-of-the-
repl.html) you can find <http://www.flownet.com/gat/jpl-lisp.html> where they
mention "Debugging a program running on a $100M piece of hardware that is 100
million miles away is an interesting experience."

------
elv
funny story :) python ftw

------
dinkumthinkum
Is anyone tired of titles that are "edgy," "controversial," and link bait?
It's become a bit passe.

