Inertia. Things like Java and Python were close enough to C (syntax and imperative paradigm) that moving to them was just a minor course change. Lisp feels like a U-turn, though I have argued elsewhere it is not really. Meanwhile Java had Sun behind it, giving PHBs a vital warm fuzzy. Lisp looks like the north wall of the Eiger in winter to PHBs.

The IDE problem just confirms anyone's fears if they even get that far, though Franz and Lispworks tried to address that by making unlimited-length trials of their fine IDEs available. Agreed on Emacs+Slime not being a good answer for noobs.

"I focused on IDE's, but I'm also interested in the general question of what things can be done and not done to get more people into Lisp."

http://www.international-lisp-conference.org/2005/speakers.h...

Mr Dussud (a respected Lisper in a former life) said MS would be happy to host a Lisp if we would just add strong static typing and lose our silly little OO package, CLOS. A couple of other things, too.

We almost ran him from the room. :)

Meanwhile, there is: http://dotlisp.sourceforge.net/dotlisp.htm

Wow, yeah. I tuned him out when I saw he wanted us to declare our variable types. I did not listen to all of the audio, but in there somewhere you will hear some nutjob asking if, given that Lisp has finally started taking over the landscape and he now wants us to run up the white flag and adopt static typing, he also thinks it is time for mainland China surrender to Taiwan. That was me.

  irb(main):003:0> x + 7
  TypeError: can't convert Fixnum into String
          from (irb):3:in `+'
          from (irb):3

Lisp is so powerful that it lets everyone modify it, and so everyone goes and creates their own dialect of it. It compiles to fast, native code, so no need to adopt and maintain libraries shared by a large user base.

Compare this to most other languages–notable outliers like C/C++ excepted–have canonical implementations that world-wide communities can germinate from. This additional confusion at the outset of adoption has stopped more than one of my colleagues from learning Lisp.

The first substantial barrier is Emacs. Before learning Lisp, first you must learn Emacs. I've tried several times, but keep deciding it's not worth the effort. Imagine for an instant that in order to use Ruby, you need to use some strange Japanese editor, but it's really not bad once you get used to the cryptic commands and rebind your keyboard so it is usable. Do you think this might hamper the adoption of Ruby?

Next, the IDE. I'm willing to put up with Slime's 1980's styling, but I keep ending up in mysterious inferior modes that don't seem to be documented. After reading through Slime documentation, it seems I need to understand Emacs's Lisp modes first.

Then, the REPL. Sure, it's nice to be able to interact. But sometimes I need to write a self-contained script that can take part in the whole Unix environment: things like being part of a pipeline, running as a cron job, running through CGI, running as a command. Python makes this trivial; Lisp makes this difficult or impossible.

Then there's the payoff. Will Lisp actually help me solve any of my problems? That's still extremely unclear. Perl or Python are great for random problems I have, such as "Fetch a web page, pull stuff out with regular expressions, and convert it from iso-8859-1 to UTF-8" or "Analyze a pcap dump file". This is where Lisp runs into the infamous library issues. The problems Lisp solves seem to not be the problems I want to solve.

The issue of a dialect/implementation is somewhat vexing: try reading SICP and Practical Common Lisp at the same time, and discovering that everything is different. Also, the expectation that whatever implementation you pick will be the wrong one for the libraries you want is a bit scary. But overall, I'd say this isn't a fundamental barrier.

The above is meant as an honest answer to your question; I'm not interested in starting a flame war.

First of all, I don't think it's accurate to say that you must learn Emacs before learning Lisp. Other editors such as vi or IDEs such as ACL & LispWorks are used successfully.

Lisp in a Box is the closest thing Lisp has to this, but can anyone seriously say that asking people to learn Lisp, Emacs and SLIME at the same time is the way to get people hooked on the language?

I think what Lisp actually needs is a nice, easy install package: Scheme/Lisp, a nice HTML help/tutorial system and a simple editor, like the one that comes with Ruby (basically Notepad with syntax highlighting and top-level integration <-- this is the key feature). Perhaps you could throw in some kind of web-app package that people can start playing with (just like the one in Arc) and a package system (one as easy to use as Gems would be nice). All of this should be wrapped up in a single installer.

This way, people have a nice, gentle introduction to the language through a simple but expedient system, and can graduate to Emacs/Vi/Eclipse at their leisure.

Eclipse is ugly as sin.

Eclipse belongs to that school of UI design that further divides and subdivides the available space into smaller and smaller little tiles and panes until you are squinting at your code through a keyhole and distracted by all the stuff surrounding it. Yes, there are ways around this, but you have to fight the default paradigm. Most other IDEs adopt the same paradigm (to varying degrees).

Also, your whole point about IDEs does not account for the growing popularity of Python and Ruby. I know you point to an online Ruby interpreter, but these languages rose to popularity with most noobies first experiencing them through a text editor + shell/REPL environment. Stop and think about being a noobie downloading Eclipse and firing it up for the first time. What is the first step? How many steps will it take to see a useful result of your labor?

Versus an intro tutorial of:

    python
    >>> print "Hello world"
    Hello World

I think you are right about one thing, I freaked when I realized Python did not have quality IDEs.

Would I be even more productive in Ruby with an IDE? Possibly. But it's possible that more powerful languages lessen the need for an IDE. Your love of ACL for Common Lisp would be a counter data point, but it's only one data point. Well, Avi Bryant would tout the Squeak IDE as a great advantage in using Smalltalk. In my case, it's somewhat moot given the lack of IDEs for Ruby. As I develop more in Lisp, I'll be better able to judge the effectiveness of the available IDEs.

Bingo, and that is why we do not see fancy IDEs for agile languages. The corollary being horrid languages have great IDEs because lawdy we need something!

One thing going on here is reflection. If my language has that I can toss off my own rough IDE-ish hacks in minutes and then they do exactly what I want, too, so the demand just never develops for off-the-shelf IDEs.

However for editing Scheme, DrScheme is the best choice. Not because it is "graphical", but simply because it was designed with one purpose only: writing Scheme code.

It has all the standard stuff (such as: to show the documentation on an identifier just press F1), but it also contain the Scheme specific stuff, that you won't notice until you try some advanced Scheming.

Among the most impressive features is how precise the error messages are reported. This goes for both standard errors, but not the least when macros are involved. If you compare the error reports you get from a few errorneous macros in DrScheme and in a standard Scheme implementation, you'll see that you can save a lot of time if you use DrScheme.

A good IDE helps you with large projects, especially with multiple developers, and a bad IDE is just a glorified editor with a lot of extra clutter. Eclipse is that with a lot of extra bugginess, IMO. Given all of the assinine bugs I've found in it, I'm frankly amazed that anyone uses it, let alone uses it as a platform for their own tools (Flex?).

I'm just getting into Lisp again after being introduced to it in college before learning how to program, and I'm liking it quite a bit. I'm using JEdit and DrScheme for the most part, and it's working pretty well so far. But I'd rather use IntelliJ or Visual C# or SharpDevelop, because I'm lazy and don't want to waste time with stuff that isn't actually programming.

I think one reason that Rails has done so well is that the vast majority of the people who use it don't write much code. Most of the code that they "write" is stuff they got from someone else via one of the forums. It's stunningly easy to build a reasonable though generic-looking site in Rails without writing much code, which makes it great for newbies.