The magic of Lisp is that you can use it to make software that you just can’t make in other languages (including those other languages). But most programmers never need to (and specifically don’t want to) create software the likes of which the world has never seen, which is fine. If you want libraries, lambdas and LAMP, use Python, for God’s sake. If it’s good enough for Peter Norvig, it’s good enough.

Worse is indeed better (just look at PHP); but popularity is overrated. I’ve been programming for 20 years, and I can afford LispWorks Pro *and* its annual maintenance contract. (And if I couldn’t, and/or if I wasn’t required to use Windows, I’d be using SBCL, end of story.) I’d love to get more Lisp work and work with more Lispers, but I couldn’t give a wet slap whether Lisp is more or less popular than any other language. As they say, “when the student is ready, the master will appear”; it isn’t that hard to learn Lisp if you put your mind to it. I did, and I’m no Bram Cohen.

regarding the problem of ‘batteries included’ can be solved with a hint from the text below from Erik:

“the reason there _are_ a bunch of “libraries” and packages for all those ****** languages is that people probably didn’t feel bad about not having something nice, so they went ahead and made something ugly but at least functional. now, everyone’s happy, right? why not repeat this for *Common Lisp*, too? ”
qouted from http://groups.google.no/group/comp.lang.lisp/msg/4bda6a98e5cf0bce

A-ha! Here’s the disconnect. Perhaps all the old, nice Lisp hackers who are welcoming to newbies hang out on USENET, and all the smug jerks hang out on IRC. (I’ve had bad experiences on #lisp, too.)

Where’s a newbie more likely to go? As much as I love USENET, “we” (speaking as someone younger than 30) grew up with computers and want instant gratification, and that means IRC. If people are rude to us on IRC, we’re not likely to say “well, it’s probably just IRC; I bet USENET has nicer people”.

I wonder if #lisp can be fixed, or if we should spend our energy convincing people to try out comp.lang.lisp first instead. I suspect the more likely fix is that somebody will come up with a killer library for Lisp (a la Rails for Ruby), and people will flock to the IRC channel for that library, and we’ll just route around the meanness while not abandoning IRC altogether.

1. No strong primary implementation.

you don’t have to have to have a dictator (Haskell does not, SPJ is at best a revered and respected figure), and you don’t have to have a single implementation.

but you do have to have a very strong, preferrably free/open implementation that’s licensed under very liberal terms (read BSD3/MIT). There are a number of devs and researchers who don’t work on OCaml for the license reason because it has a wonky Q License, and if you’re an up and coming language you need all the devs and researchers you can get.

I don’t have to fuck around with deciding if I want to use SBCL, CMUCL, Clozure Common Lisp, or whatever since I’m on a Mac. I don’t have to contemplate purchasing expensive semi-crippled Lisp packages to get good integrated OS support and all the goodies. I don’t have to switch my compiler suite to something else if I’m working on Linux/FBSD, or Windows.

I don’t have to navigate the huge duplication of effort in the Scheme community where there are probably double the number of credible systems compared to CL.

I just use ghc. In fact, more or less everyone uses ghc. There are other implementations of Haskell that try to do things ghc won’t or can’t (strong embedded support, or highly advanced optimizations) but there are generally strong reasons for branching off, and even if they fail, so what? I still have ghc.

Haskell is also standardized in the H98 and future Haskell Prime efforts. And unlike the ANSI process, it is recognized these standards are not immutably fixed in stone because they’re too damn expensive to update with another standard.

unlike the R6RS effort, Haskell standardization has been generally agreeable to most parties and hasn’t alienated significant parts of the community.

Haskell was more or less founded on a recognition that many researchers were experimenting with lazy functional languages and it was going to end with an unnecessary amount of duplication and result in underserving of that niche, and it’s a lesson everyone who wants to roll their own Lisp for use as opposed to learning should learn.

You get good features and good optimization in a compiler by have a good design that can updated as needs change, and by having lots of really smart people bang away at it for a good long time.

there are just as many smart people in the Lisp communities as the Haskell community, but the Lisp implementing talents are being spread thin.

It would be nice if the Scheme/CL debate could be ended by all parties. Maybe we can all agree to agree around Clojure. But deciding on an agreeable reference implementation for both CL and Scheme would be a major step if harmony can’t be achieved. CL seems to be solidifying around SBCL for free/open support, and asdf has real promise. The Scheme situation looks to stay fragmented and even induce more fragmentation around R6RS support and whether a implementation has decided to go along with it or not..

basically, just _fucking pick something_. It’s not going to make everyone happy but it should make most people happy. People will build new implementations to support special cases as necessary, but most people should be working on a common implementation.

2. No batteries included. It’s not a coincidence you’re using that phrase right now - it’s more or less become a battlecry in the Haskell community, and OCaml is now working feverishly to catch up and remain competitive in those terms.

Haskell is building infrastructure that may eventually put CPAN to shame, and at the very least in it’s current state can compete with offerings from Python and Ruby in quality of experience if not in library size.

instead of writing software that only works on one Scheme implementation or hasn’t been ported to your current CL compiler of choice, you end up deploying software that works for all Haskell users and that, most importantly, other Haskell users can build bigger and better things on.

both CL and Scheme need really good library support RIGHT NOW, and using the current methods are not going to get them anywhere near that goal. Haskell has already leapfrogged them and is shooting towards Ruby-like levels, and I’m quite sure they are already making plans on where to go after getting there..

3. Community Friendliness

This is a big win for Haskell and a mixed bag for Lisp. Scheme is generally more friendly than Lisp since it was used as a teaching language for undergrads. I’m not sure there’s much difference between Scheme and Haskell really in terms of language community friendliness.

comp.lang.lisp should just bounce new posters onto gigamonkey’s site and a reference to PCL and #lisp on freenode with a sign “We’re Closed”. I wrote a rant, but I realized doing so put me on their level, so I’ll just say this -

I think it’s pretty self-evident that if you want people to drink your koolaid you better keep the True Believers locked up in the basement before they scare off the less committed first. It might be full of delicious sugar and s-expressions, but it doesn’t go well with poisonous words.

#lisp on freenode is nice enough. It’s not perfect but new people are treated reasonably well and I’ve felt safe to direct new people there. #scheme is also good. If you want to talk about communities that can get more people into the language, start there. The slow death of Usenet as a credible place for discussing technical topics is probably a hidden benefit for the Lisp language community.

also gigamonkey is a fucking saint and c.l.l people should spend less time arguing and more time getting him canonized and/or funding his projects for making Lisp easier to grasp and more appealing to new programmers, at least if they really want a better Lisp.

#haskell is famously friendly, has almost more users than #lisp and #scheme combined on that network, and has gone so far as to ban highly talented but persistently socially disruptive members that many other online communities would and have simply tolerated as a source of knowledge (this isn’t a dig at Lisp communities, more like evidence that people in the #haskell channel are sticking to their guns about staying friendly).

4. A real plan for massive multicore -

Termite Scheme has one. There are effort to implement Erlang-style parallelism in CL along with STM for concurrency. But Haskell offers an embarrassment of riches for solving these problems, has very good support for them, and is managing to build massive threading systems that make Erlang’s processes look heavyweight.

In fact it’s becoming something of a research testbed for massive multicore.

that brings me to another issue.

5. The research fire is gone

there is not a lot of new research action happening in the Lisps. The main trend in theoretical CS languages research is going toward pure functions, more complex and powerful static typing systems, and massive multicore requrements. Guess which languages this favors?

Someone needs to start beating the Lisps with a electrified cattle prod, getting researchers to start extending and evolving the language in new directions and taking it to new heights. I don’t expect the old school guys to do it, they’ve put their time in and deserve a rest, but if there are no Young Turks who take up their place and start revolutionizing the language, the language is going to increasingly fall into academic disfavor and disuse, with negative results on the language community. Sadly, I also know I’m not the one to do it.

Qi is at least interesting.

in short - the Lisps aren’t dead. And macros ensure that, for certain work that needs that kind of flexibility, they won’t die anytime soon. But they are losing real ground to languages with communities that are not subject to many of the dysfunctions the Lisp community has and have their own brand of power, flexibility, and beauty, and have in theory only been in any kind of practically usable state for much less time than even modern Lisps like CL and Scheme have existed.

don’t take this as a hostile criticism or a insult, because it’s not intended to be. Take this as your warcry as things start get fixed….

Agreed. The reason newbies find the communities so … hostile, is because quite often the wrong questions are asked — fixing a symptom, instead of the underlying, actual, problem.