I am a fairly new member of the Lisp community, so new that most people have never heard of me. I’m one of the young programmers that have read the excellent writing from Paul Graham, Raganwald, and Steve Yegge and decided to try Lisp out for myself. I’ve had much more time available in small chunks, enough to read tutorials and articles on the internet but not enough to dive into heavy programming. As a result, I’ve gotten to know the community and history better than the language and tools, probably better than any new convert. Here are some observations I’ve made (summary then detail):
- Lisp is like a new language with lots of praise from important people.
- Lisp used to be very important but lost that position.
- Lisp lacks the infrastructure to get new users running quickly. The tools are there but they aren’t organized and streamlined.
- The Lisp community is fractured but composed of enough good people that it could develop into a positive, influential force.
1) Lisp feels like an emerging language (think Ruby circa 2003) that may or may not make it big but happens to have 50 years of history under its belt. I recently read that said SBCL and Clisp were the top two open source Common Lisp implementations, with single digit thousands of installs each. A decent number but nothing earth shaking. Interest could at this level for years, or given the right conditions, it could take off immensely (see Rails, Ruby on).
However, Lisp also has the burden and the blessing of decades of history. It was doing things 20 years ago that modern languages are just beginning to incorporate. Years of large scale development have driven improvements in the language, tools, and performance that blow the doors off of new scripting languages like Python and Ruby. It was the language of choice for the hardest problems of the 70s and 80s. Luminaries in all aspects of computing have publicly praised Lisp for being so great (Eric Raymond, Alan Kay, Peter Norvig, Guy Steele, etc).
But . . . decades of work by lots of brilliant people have caused Lisp’s family tree to splinter instead of remain close knit. The ease of writing software in Lisp means that people are more likely to roll their own tools instead of standardizing around a few common tools. And because it was so old and mature once the Internet started driving new users, the community infrastructure is not geared towards new users. This is more than a little weird compared to other languages.
2) Lisp used to be much more prominent in computing, and there are people around who remember that era. Lisp was the language of choice for CAD, artificial intelligence, expert systems, and many other challenging problems. There were multiple competing vendors offering Lisp environments, with new innovations in tools, improved compilers, and high performance. There were even two companies that made hardware to run Lisp natively and a complete stack on top of those machines! At that time, languages like Java, .Net, Perl, Python, Ruby, and even C++ didn’t even exist and Lisp was only competing with C, Cobol, Fortran, and Assembly.
To make a long story short, the game changed and Lisp fell from prominence. A number of factors torpedoed the Lisp machine companies, the DoD pulled funding for AI research, competing languages improved and incorporated some of Lisp’s features like garbage collection, and the Common Lisp standard took some of the innovation out of commercial Lisp vendors. Although it fell from prominence, during its heyday Lisp was a powerful contender in the computer world. Keep in mind that at this time, computer hardware was expensive (too expensive for individuals) and was almost exclusively owned by corporations and universities.
3) Today, most of the work in programming languages and development technology is done by individuals, on their own hardware and often on their own time. Since everyone is a volunteer, tools that cost money will reach many fewer people than free and especially open source tools will. Since most people are volunteers as opposed to employees, they care about stuff like “How long will it take me to get setup?” and “How hard is it to resolve issues?”. This is where languages like Ruby and Python shine. How long does it take to get setup? Just download the installer package and run it! Libraries included, directions just like the tutorial, easy. Oh yeah, and it works for Windows and Linux and Mac. Batteries Included.
With Lisp, newbies say “How do I get started?” and instead of a URL, they get “Lisp is a family of languages, with the primary branches being Common Lisp and Scheme. But these are just language standards with a number of implementations. Which implementation is best for you depends on your platform and computing needs.” Huh? From reading a bunch of blogs and discussions, the impression I got is that the two best environments are SBCL and PLT Scheme. But it seems rare for anyone to say “You should use implementation X” or even “You should use implementation X unless you need to do Y”. This confusion makes it hard to even know how to get started.
Enough has been said about emacs. I think it’s great fun and I’m enjoying learning it, but I can’t say that emacs/Slime is the most welcoming combination for newcomers.
And there are more and more of these types of things. In tutorials/demos, it’s not clear how your file structure should go. It’s not clear if a command should be entered in your code file, in the REPL, or in your SBCL init file (which is where, again?). Part of my problem is that I wanted to learn all the nitty gritty stuff, so I’m learning Linux, emacs, SBCL, Slime and Common Lisp at the same time. This means that I have to leave tons of time to work through issues, because I could run into something in any of these layers of my stack. I’m not sure what it is about me that keeps me from using Lispbox, but something like this would make life a lot easier. This should probably be the starting point for new Lispers, sort of like InstantRails is for the Ruby on Rails community.
Incidentally, there are good resources out there, but they need to be vetted and organized. Hey, I’m an organized person, maybe I’ll volunteer for this! (Oops, by publishing this, I think I just did (gulp)). (clearly my writing style predisposed me to write Lisp code).
(Note: If I had searched my feeds before I sat down to write, I would have found that Eli Bendersky basically wrote this post for me five months ago. Thanks Eli!)
4) The community is . . . special. There really is no community per se, but several communities bound together by one common name. There are the crusty old guys (the ones people warn you lurk on comp.lang.lisp), the generally good experienced developers (Peter Seibel had received several compliments), and the new people asking “dumb questions”. It’s a challenge having all these groups interact, and the results aren’t always pretty. I haven’t ventured onto c.l.l or IRC, but there are enough good Lisp bloggers that I feel connected (note to self: connect back more). People complain about the community (mainly because of group #1), but a couple dozen or so active, friendly, constructive people could create a positive impression for all visitors to the community. Just look what happened to Ruby with the Rails team.
And so that’s where I think I’ll leave off (now I just need to trim and edit the 1,000+ word ramble above):
So the Lisp “Golden Age” of #2 won’t be back (the computing world is too different), but the future could be very bright indeed. Let’s make it so.
*Original text: “better competing languages were developed,”