[Gardeners] An offering: One programmer's experience with Lisp

[Jonathan Simms]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Hello all!

First let me start out by saying that I am very glad that Mr. Seibel has
decided to organize this effort, and that so many seasoned Lispniks have
joined.

I wanted to take this opportunity, while this effort is still fresh,  
to offer
My Two Cents (tm) on my experience of Lisp, in the hopes that it will be
helpful feedback. I am 29, I've been a professional programmer for 3 1/2
years, I've done Java, C#, PHP (blech!), Python, and my current
joi-de-vive is Ruby. I work primarily designing Ruby on Rails web  
applications
(backend and behavioral focus) for a startup in New York.

In "The Common Lisp Road Block Manifesto" thread there was one  
response, from
Herb Martin, that I found particularly compelling.

 > While I have written production programs in some thirty or
 > more languages, my use of Lisp has always been "for fun"
 > because the language never provided me all of the combination
 > of features/availability/readiness etc to allow me to
 > substitute it for all of the other languages at my disposal.
 >
 > No matter, I always come back to Lisp because I ENJOY it.
 >
 > And despite 25 years having passed, I am still a Lisp "newbie".
 > When (and until) I program everyday in a language for a week
 > or three my skill level rapidly improves but I have seldom
 > done that in Lisp.


I'm not a particularly religious man, but I sometimes say a small  
prayer at
night before bed:

"Please God, provide me with the strength and fortitude necessary to  
learn
Common Lisp before I die."

Lisp to me has always had a mystic appeal. It is a language that has  
survived
from the Paleolithic period of computing, when computers were things  
that
governments, colleges, and IBM owned. It is steeped in tradition, and is
obviously very powerful. It is the Grandaddy of All Scripting  
Languages, and
yet there is something about it that is difficult to grasp, and  
harder yet to
wield effectively.

The two languages which I have the most experience in are Python and  
Ruby. The
primary advantage of these two languages, IMHO, is that they're very  
unix-y.
They facilitate the programmer's need to express unix-y concepts:  
files, fifos,
sockets, processes, threads, and filesystem. It was immediately  
apparent to me
when learning these lanugages the advantages of having simple yet  
powerful
data types, strong-typing, and large standard libraries that covered  
most of
the (dare I say) "useful" functionality available on your standard linux
distribution.

The rubber meets the road very early on in learning these languages,  
because
the nouns and verbs that are presented to the the programmer are the  
stuff of
daily existence.

So, how does this relate to Lisp?

I've tried at least 3 times now to get that feeling of traction with  
Lisp. The
most recent experience I've had was working dilligently through Mr.  
Seibel's
"Practical Common Lisp". From the outset, I kept thinking, "Yes, this  
is all
well and good, but when do we actually get to *do* something?" I  
strengthened
my resolve, and pushed ahead to chapter 14 "Files and File I/O" thinking
"Surely, we will reach files and I'll get to do something fun, like  
copy a
something from one place to another, or (dare I say?) traverse a  
directory
tree."

Alas, I was somewhat disappointed.

It seems to me that one of the problems Lispniks have is that they're  
always
talking about Lisp, they're describing things *in terms of Lisp*.  
 From PCL:

"I'll discuss the standard functions here and point out the ones that  
suffer
from nonportability between implementations. In the next chapter you'll
develop a pathname portability library to smooth over some of those
nonportability issues."

Now, to be blunt, speaking as a non-Lisp programmer, I don't give a  
hoot how
one implementation handles this differently from another. This  
strikes me
wonky, staring-into-your-belly-button type stuff. It also caused me  
to feel a
bit incredulous, "What do you mean? *I* have to write a compatability  
layer?
I've only been doing this for *two weeks!*. I just want to do some
file-management or simple text-processing!"

Is this a bad attitude? Possibly.

On the other hand, I want to be able to do something useful, something
directly related to my poor, unenlightened, non-Lisp world. I want to  
be able
to do that without having to know how the 5-10 popular flavors of Lisp
implemented PATHNAME differently. I read PCL's chapter on the CLOS  
and I don't
think i've ever been so depressed in my life. Here is the world's most
powerful object system, with AOP hooks and all sorts of  
wonderfulness, and
it's gonna take me *years* before I can do anything practical with it.

There seem to me to be two major issues one has to grapple with in  
learning
and writing Successful Lisp (nudge nudge, wink wink). First is the  
myraid of
inconsistencies between the implementations of Lisp. It struck me  
that this is
not too dissimilar from my experience in trying to write cross-browser
Javascript. Thankfully, there is the prototype project
(http://prototype.conio.net) that is gaining wild popularity because it
handles the browser inconsistencies for you, and provides a  
consistent API for
standard programming tasks. Such a library would be terrifically  
useful to a
Lisp newbie, as it would allow them to ignore some of the finer,  
niggling
details and faciliatate their enjoyment of Lisp.

The second issue seems to me to be that there isn't a simple,  
consistent, and
unix-y way to deal with the operating system (if I'm terribly wrong  
about
this, I plead ignorance). It would be very helpful to me in learning  
Lisp if
there were a library I could use that would make it easy to use my  
operating
system as subject matter, something that would make it as easy and as  
natural
to write bash-style scripts in Lisp as it would be to write them  
in...well...
bash.

One last thing, when I was first getting into it, something that Ruby's
creator (Yukihiro Matsumoto) said really struck me.

    "The purpose of Ruby is to maximize programming pleasure.
     Programming in Ruby is extremely fun, for me at least."

I believe that we as programmers value many things, and one of the  
things that
I've seen a high value placed on is fun. I believe that there are  
things that
could be done to make programming Lisp more pleasurable and more fun  
for the
newbie out there. I believe that those things have value, both for the
beginner, and possibly for the community as a whole.


Well, hopefully I haven't offended anyone too greatly. I am very  
excited about
this project and I applaud all of your efforts in keeping Lisp alive,  
well,
and relevant to the next generation of programmers.

Thank you for taking an interest in us, the new guys :)

- -Jonathan Simms



-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.1 (Darwin)

iD8DBQFDszonukPQ9vfVJEARAgO4AJ4klTYNwRMbmDzQmt7eU8cSE6f+FACgjCXz
PKJIKnhwhDd2/ei+AZ7a0II=
=UdKK
-----END PGP SIGNATURE-----