I'm really new to Lisp. I had heard of it before and got the
impression of a dead language with an exotic syntax and no real use.
My opinion was changed by Paul Graham's article <a href = "http://
www.paulgraham.com/avg.html">Beating the averages</a>.

I started investigating and in the last weeks I've been watching the
videos of "Structure and Interpretation of Computer Programs" and I'm
reading "Practical Common Lisp". I liked a lot what I heard and read
and tried to tell my friends and colleagues about it, but the reaction
was like I'm going nuts, even though I made it clear that I intend to
learn more and try to implement a nontrivial program in Common Lisp
before forming my final opinion. The most frequent argument I heard
was: "If Lisp was that good, it would be much more popular".

So I started asking myself why isn't Lisp popular. Is it because of
it's syntax? Is it because of the prejudice that it is slow? Or some
other reason? I searched the Internet a little and saw that other
people had asked themselves the same question. A discussion on
Lispcast titled <a href = "http://www.lispcast.com/drupal/node/29">No
easy download</a> caught my attention along with another article by
Paul Graham - <a href = "http://www.paulgraham.com/popular.html">Being
Popular</a>.

So I formed my own opinion on why Lisp isn't popular and summarized it
in the following two points:

1. There are not enough libraries in Lisp. Even worse, most of the
existing libraries are not standard. The fastest way to implement
something is to have it already implemented for you.

2. Most people don't see the advantages of Lisp over their programming
language even for tasks for which Lisp is really much more suitable,
because they don't know what can be done easily in Lisp.

And then I asked myself if there are circumstances which would help
Lisp get back on center stage. What I'm certain of is two things.
First, as time goes by, more and more features of Lisp will get
introduced to other languages and its will become harder to convince
people to make the transition. And second, trying to get people to
learn Lisp so they would appreciate it won't work. They should be
convinced of the use to learn it before they agree to do it. And so I
got to this crazy idea which I want to share. If I'm being stupid
please bear with me.

The best way to convince people to learn Lisp is by convincing them to
use it first and then use that to show them its advantages. I don't
know about Scheme, but the FFI of Common Lisp seems to be good enough
to allow for other languages to use libraries written in Lisp. So if
there are powerful libraries written in Lisp which can be used from C+
+, Java, C#, Perl, Python, Ruby, etc, people will use them. Several
widely used popular libraries in Lisp, especially for tasks which are
outside the traditional Lisp domain, can really make a difference in
the attitude towards the language.

The other thing which is mandatory is to make rich libraries for Lisp
which are readily available, comprehensive, free and standard. The
best way to do this is by creating the prerequisites for the emergence
of libraries which are de facto standard, like what boost is for C++.
Instead of almost 10 libraries for GUI of which people don't know
which to choose, there should be no more than three and it should be
immediately clear what's the use of each of them.

And the third thing which could really boost things up is some way to
make both kinds of libraries very public so that non-lispers could
become aware that:

1. They can benefit from Lisp without learning it through powerful
libraries written in Lisp.
2. There will benefit from investing in learning Lisp, because there
are a lot of solutions readily available.

And here comes my crazy idea. All of this can be achieved through a
web site targeted at developers in all programming languages. This
site should be the best programming libraries directory on the
internet, hosting libraries in any programming language. Its main goal
should be to hold as many libraries as possible and provide powerful
search, ranking and comparison features. Here are some of the features
I have in mind:

1. Each library should have in its description separate fields for
implementation language(s) and target language(s) unlike sourceforge
which has only one language field. To the users of the library it
matters much more what languages can use the library, but the
implementation language is important too.

2. The "supported feature" fields of the libraries should have
rankings associated with them so that users could rank the support for
individual features separately.

3. The users should be able to add new library categories with custom
feature fields.

4. The users should be able to sort the libraries according to their
own ranking criteria like the <a href = "http://
shootout.alioth.debian.org/gp4/index.php">Gentoo Benchmark<\a> or in
some other way.

5. The users should be able to create comparison tables for two or
more libraries, choosing which features to compare.

I think that if such a site exists and contains all important
libraries for the major programming languages it will attract enough
attention to start the ball rolling and become the best programming
libraries directory. Of course a site of this scale will require some
serious funding but I believe this is a solvable problem.

And with this site in place, it will be up to the Lisp community to
start actively pursuing the interest of the other programmers. The key
is to identify the most popular libraries and implement them in Common
Lisp and Scheme. This will provide Lisp with the libraries that people
want thus making it ultimately more useful. And if these libraries are
more powerful than the original and are made available to other
programming languages, they will have the potential to start to draw
people towards Lisp.

Of course there is a reduced version of this agenda, which is to use
existing software project sites like Sourceforge and implement the
most popular libraries there in Lisp and post them on Sourceforge. But
existing project sites are not targeted at libraries specifically so
they don't provide the tools to highlight the key features and compare
them. Furthermore, a good libraries site for Lisp is needed anyway,
and it will only gain if it allows libraries in other languages
because it will draw the attention of non-lispers.

There are many reasons.

Though it is good for a newbie to think of popularity, etc.,
it does not really help that much. What you are writing
about comes up quite often.

You have a better position to rate the usefulness for Lisp
and where it is applicable when you have some experience
using it. That means you should have written some
software. Currently your position is like looking at
a Mercedes Benz brochure, really liking the cars, and
wondering yourself why not everybody drives a Mercedes.
Then you talk to the engineers how to make Mercedes
more popular. You can imagine that this will not
change much...

Better:

Dive in, write some software, see where it lacks libraries,
contribute, etc. If you want to help on Usenet, get
some experience and help people solving problems. Help
other newbies to get over the first hurdles.

Starting points for you:

Community Wiki
  http://www.cliki.net/

Projects
  http://common-lisp.net/

IRC channel for Common Lisp programmers
 #lisp

Though Lisp (Common Lisp) is not that popular, it is still
quite active, there have been excellent contributions
from younger programmers in the last years, several
implementations are actively maintained and there
are implementations that are extremely good. So there
is something to it that lets it survive even though
it might not look 'popular'.

Lisp is still very useful for:

* complex software written by small teams
  (actually the worst thing you can do is write
   complex software in a large team) with high
  productivity

* software that grows incrementally and evolutionary

* interactive software development

* software that needs a very flexible language that
  can incorporate new ideas, styles and domains.
  You don't have to wait for the language designer
  to implement a new loop construct, you can
  write your own with any complexity you like.

* as an extension language. See Emacs.

If that kind of describes your needs and capabilities,
then Lisp is for you. Check out the wiki or talk
to people at the IRC channel and see where you can
contribute...

What would be useful is to have more maintainers for this - i.e., people
who go through the existing entries and check whether there is missing
information and/or information that needs to be updated, as well as, of
course, making new entries.

Volunteers are highly welcomed.

Pascal

If you started talking about how great a language is _before_ you have
used it for a while, I wouldn't be more polite to you either.  I would
be rude and tell you to stop wasting my time.

Get some perspective - you have watched a video and started reading a
book, and now you are ready to tell the world how great Lisp is, and
tell the lispers how to make Lisp better and more popular.  You are
simply not a credible source of ideas on either.  Stop wasting your time
- just learn Lisp and start programming.

1) Ones favored by large corporations, favoring programmer
   replaceability way over language expressibility. The obstructionist
   compiler and interface is designed to make the code comprehensible
   for the next drone in line after the current one asks for a sick
   leave or a raise^W^W^W^W^W^W^W^Wjust kidding.
2) Languages designed by self-proclaimed "language design architects"
   for hobbyists programmers. Perl's a great example, reading just a bit
   lets an uneducated hobbyist create (fsvo) useful programs, comprising
   instant gratification. Major version revisions later, the syntax and
   semantics resemble an inanely-knit cargo cult of features borrowed
   from all over the paradigms.

The ones not being popular:

1) Languages designed for expressibility with no regard for market value
   or the affection of the Free Software mob. Examples include Lisp and
   Smalltalk.

The lists are not exhaustive.

Popularity's not that much of a problem. Protocol support can be
implemented from scratch for NIH value, bindings can be autogenerated.
Newcomer supply exists and existing users tend to stick with Lisp.

- Use cells-gtk if you like the spreadsheet model, Kenny's implicit
  declaration of macros (^foo) for accessing cells a'la defstruct and
  Kenny's deliberate lack of documentation in the goal of supporting
  Kenny's business model.
- Use ltk if Tk is good enough for you. AFAIK it's pretty stable and
  ready for development.
- Use McCLIM if... well, I don't know much about McCLIM. It's been
  usable for all intents and purposes since the Genera times.

Recommend asking questions directly instead of through a veiled
reference to a "potential newcomer user".

The fastes way to implement something is to have good tools to
implement it yourself.  This is a problem of specifications.

It's the other way around generally: it is easier to call _foreign_
libraries from lisp.  With ECL, an easily "embedded" CL
implementation, it's easy to call lisp from the foreign languages.
I heard commercial implementations make it easy to call them as DLL.

It's not really relevant: there are a lot of IPC, direct function call
is less and less relevant, given the network, distributed and
parallelized architectures.

Why would we want something as horrible as boost in CL when we
already have the COMMON-LISP package?

The best proof is the number of Lisp libraries that have been
translated into other programming languages.

The idea is plain silly  and just show that you don't know lisp yet.
Please spend a few month studying and come back to tell us what you
think of this next year...

A library is like a casted object.  It may be very useful to have a
fork or a coat hanger, but this is nothing compared to efficient tools
to make the molds needed to produce these objects.  Of course, you can
also make molds with inefficient tools, and it will make absolutely no
difference for the coat hanger or fork user.

Clearly, you didn't understand what "meta" in "meta programming" means.

The benefit of Lisp comes from the process of YOU developping new
solutions to new problems.  If you're doing cut-and-pasting coding,
which is no programming, then Lisp is of no use.  Here is one concrete
example of the examples I mentionned above.  Apple's (ex NeXT)

Interface Builder is an application that is written in Objective-C.
It allows non-programmer or dumbed-down-programmers to build user
interfaces, connecting objects that require little additionnal actual
code to make an application.  There is no Lisp benefit to be seen here.

However, Interface Builder wouldn't exist if it had not been developed
by Bertrand Hulo in Lisp in the first place.  Thanks to using Lisp, he
could write an Interface Builder that was hundreds of times better
than the user interface editors of that time.

What you could do however is everytime you see something done in
foreign programming languages, mention how it's much more easier to do
in Lisp.  The result will be the same, the difference is that instead
of spending hundred of time units you'd spend only one, instead of
hiring hundreds of java monkeys, you'd hire only one lisp brain.

I think you forgot how good is Lisp.

I would at this point refer you to the many RtLs that include the
sentence "I knew at once I had found The One", but the black helicopters
are still looking for them.

And yes, I know I need more time to learn Lisp, before making
statements about it. I never said to anybody "Lisp is great", I just
said, "I'm learning about Lisp. I'll have a definite opinion when I've
tried to use it for a while, but this far it seem to be great."

About popularity - I think it is of great help for any programming
language to be popular because this means there's a stronger driving
force to maintain it.

Maybe I'm wrong about the amount of libraries - from browsing sites
(including virtually all sites you referenced me to) I got the
impression that most libraries are targeted towards web development
and AI.

And about trying to propose a way to popularize the language without
even having started to use it - that's true, these were just some
thoughts which I wanted to share to people who might find them either
interesting or extremely stupid. It turned out to be the later. These
thoughts were to a great extent provoked by the discussions I quoted.

Instead I just started working in it.  Lo and behold, two colleagues
have already asked about Common Lisp.  But I don't really care if they
will eventually start using it -- _I_ am using it, and it helps _me_
enormously.  I don't see the point in convincing people about Lisp.
If they care about implementing complex programs efficiently, they
will look for it and eventually find it.  If they don't, there is no
way I could convince them to use Lisp.

Recently I started working on a project that automates k-order
perturbation solutions of functional equations.  I know of another,
similar system built in C++, which is a total nightmare of
Greenspunning (imagine manipulating symbolic expressions in C++.  No
wait, don't imagine, you will have bad dreams).  I will eventually
make this work public.  But will go around convincing people to use
it?  No, I couldn't care less.

Best,

Reading passively reading will never teach you any Lisp (or any other
programming language, or mathematics, natural sciences, economics, etc.
for that matter), you need to get your hands dirty and _do_ stuff.

HTH,

Lispers generally don't care about popularity because they can already
do what they want already. At least a few see it as a waste of time to
have lots of newbs around.

When I was even more of a newb, I took the view that transition code
should be written to allow people to use ugly stuff while they
transitioned to lisp, but now go with the view that you should just
ignore newb wants and have your own super productive higher order and
macro code as normal. That gives something worthwhile at least for
people to see as a reason for learning lisp.

OTOH, for the newb who finds macros and other niceties, an early
thought is, "omg, what if I had never taken the time to learn it? The
masses must be saved!", and I sympaphise with this view. An old-timer
will probably have less attachment to this feeling partly because it
was so long ago.

There are many people at university and otherwise who do have an
interest and all of the 2 required brain cells, but are simply unaware
of what they are missing. Heck, I came _this_ close to evangelizing
macros and linking to macro primers at my uni, I was just shocked that
all these bright people were unaware of their power.

But at the end of the day, the things I'm talking about are of little
interest to those who just want a degree, and of little interest to
those who just want a job (for the meantime). Most of the other people
who program out of interest will find lisp eventually anyway and might
even be super awesome enough that their employer lets them get on and
use lisp.

What I did instead, started translating various small "C/C++" code -
mostly libraries to Common Lisp - decompression, math, rendering, opengl
stuff. Currently I'm porting my Voxel Space Application for the iPhone
to Common Lisp - I would like to maintain the code in it, not in C. -
http://picasaweb.google.com/malkia/Mont

Probably not the best around, but I decided that for me to find the road
to lisp is to start from somewhere where I'm experienced (non-functional
imperative languages, semi-objective, close-to-the-metal etc.) and reach
my goal by using functional features more and more.

For example I've started right away using dotimes, dolist, and haven't
touched map functions for a while, until I felt comfortable. I'm barely
now scratching the macro-code, first took big steps of transforming
large pieces of duplicate code to be generated into one (mainly for
matrix operations), but now I'm trying little more iterative steps -
write some small macro, that calls a function to expand something, check
it on the REPL, go back, etc.

Later when I'm ready with my "written & driving" common lisp test, I'll
start digging more into PAIP, and SICP.

Certainly 15+ years of Basic, Pascal, X86 Assembly, C/C++, pointers,
manual memory management (well Basic had GC, but I was unaware then of
pointers), DMA and other "wonderful" machine related tasks are hard to
take out of me, but I'm trying. I'm still imaging every bit & piece I
put in the code, and how it would look in assembly.

This is also due to my professional career - that of being a console
game programmer. I learned to care about every memory allocation, every
bit that went to a structure, the layout of the structure in memory,
etc. It made me a cripple - I should stop worrying about such details,
and just do it, without thinking much how it would be in the machine.

So what I do expect, and I'm already benefiting, from Lisp is exactly
that - To unlearn the practice of close-to-the-metal programming, and
think more about expressing the ideas easier - e.g. being more
close-to-the-human.

So to me that's lisp - a close-to-the-human language, human in it's most
average case - someone who at least can do (+ 1 2)

...

For the record, here is a paper that the describes the use
of the Interface Builder of ExperCommon LISP:

Signal Constellation Design Tool: A Case study in User Interface
Synthesis
Gabriel Robins

http://www.cs.virginia.edu/~robins/papers/Signal_Constellation_Design...

Here's a few notes of my opinion you might be interested.

-----------------------
★ I don't think Lisp will ever be popular. I thought it would
eventually, 10 years ago, but now i think never. For detail, see:

• Will Lisp Ever Be Popular?
  http://xahlee.org/UnixResource_dir/writ/lisp_be_popular.html

• Proliferation of Computing Languages
  http://xahlee.org/UnixResource_dir/writ/new_langs.html

----------------------
★ Judged on the language itself from a academic point of view, i think
there are 2 problems of lisp that caused it serious damage. The
irregularity in syntacx, and the “cons” as list abstraction. The
irregularity prevented lisp to grow in many directions (compared how
XML is received today). However, the syntax irregularity does not
hamper lisp's use no more than say perl's syntax hampers its use.
However, the cons problem is a serious damage, that is almost
unfixable. The cons problem is the number one almost unsurmountble
problem for lisp, in fact, it is killing lisp today amid verdant
growth of functional langs. For detail, see:

• Fundamental Problems of Lisp
  http://xahlee.org/UnixResource_dir/writ/lisp_problems.html

• My First Encounter And Impression Of Lisp
  http://xahlee.org/PageTwo_dir/Personal_dir/xah_comp_exp.html

----------------------

Personally, i like lisp for basically 2 reasons:

• It is functional. Functional programing, in my opinion, is the
simplest, most versatile, easy to use and learn, paradigm. (but too
often the functional programers, esp academics, makes it 10 times more
difficult with lots of lots of opaque jargons)

• Lisp was extremely well designed with respect to its time. The
lispers, are thinkers. (however, today, lisp the lang when compared to
other langs today such as Python, Ruby, or the tens new functional
langs, i think lisp the lang is actually NOT any better. Even not
counting the cons problem, it has lots of historical baggage and
ugliness that shows)

I basically only use emacs lisp, as a practical tool. I learned some
scheme in a academic context in 1999 (having read the sicp and R4RS),
and had some thoughts about learning Common Lisp, but today, i have no
interest in these whatsoever. See also:

• Xah's Emacs Lisp Tutorial
  http://xahlee.org/emacs/elisp.html

You can also find book-length tutorials on Java, Perl, Python on my
website.

  Xah
∑ http://xahlee.org/

It's interesting that you find the number of Lisp libraries lacking.
Wanting to do some web programming, I experience the opposite: an
overwhelming number of selections and "the paradox of choice."  Your
other point - that there's no de-facto "standard" set of libraries - I
agree with whole-heartedly.  I like the batteries being included.

I think the network effect helps us all, and I applaud your desire to
help realize that.  Trust that the barriers you encounter will be
encountered by others, and do what you can to tear them down.  By
leaving a trail of breadcrumbs (so to speak) you'll help those who
follow you.

Riffing on your initial ideas, I'd love to see a cohesive set of
"batteries included" Lisp libraries.  Even the products of an attempt
- e.g. write-ups of comparisons of similar libraries, or just
additional information posted to http://www.cl-user.net/ or http://cliki.net/
- would be invaluable.

Any Lisp implementation is going to need a garbage collecting memory
allocator. However your C program is not forced to use it. The Boehm
GC may coexist with your use of malloc/free or new/delete, if
configured properly. Indeed, ECL deactivates a feature of Boehm GC
which is to intrusively scan the data sections of the program in which
ECL is embedded, so that memory is not accidentally retained.

Dunno, maybe something changed, it was more than a year ago...

- Lisp in a Box
- Lispbox

and IIRC, recently somebody posted on cll something about some
distribution or package set, but I can't find it right now.