A survey on demographics of open source developers.
98.9% male, 41.4% single, mostly in 20s, largest
number aged 21, majority (48%) use Debian with Red Hat
a distance second (13.8%), majority got involved in
open source in second half of 1990s, 70% living in Europe.

This made me wonder...

How many of these people are Lisp programmers.
What does the next generation of Lisp programmers
look like, assuming there is even such a thing.
Are the schools producing them, or is it now
mostly learn-it-yourselfers, a few refugees/stragglers
from the mainstream languages.
Where, if any, will they take Lisp in the future?

Or, despite Lisp being a programmable programming language,
supposedly a DNA-like language and all that, could it
just stagnate and fade into irrelevance from lack of users
and evolvers.

Another thought I had was, back in late 1980s there
was a SLUG conference in I think Univ. of Pennsylvania,
Philadelphia, where the new Symbolics head (J. or Jay
something, what was his name, anyone remember?) gave a
speech saying that "there are only so many lines of Lisp
code in your body"?  Anyone remember the number that he
cited?

100% male, single, almost in the 20s, using FreeBSD, living in
Joymany, I mean Germany :)

So I guess, I am quite average (except being a BSD user perhaps). Any
other members of the new generation here?

Male, single *sigh*, 32 (am I a young lisper or not? ;), using Mac OS X
(and Windows at work), also living in Germany.

I have started to take a close look at Common Lisp in the past few
months (since March) - so I am certainly quite new. ;-)

Pascal

Male, married, mid 30s, in the USA, using Allegro and CMUCL on Windows and
Linux respectively for my job.  I am primarily writing web based applications
(a database editor, and a reporting system) using aserve and portableaserve,
with the occasional data mining or data feed type program.

I'm also a 10 year DOS/Windows, Visual C, Visual Basic refugee- I quit
that ratrace in 1997 because it was literally making me depressed.

I'm young by age, but am also very young by my computer age and more
specifically programming and CL. I have started using computers in 1997
(because of my financial situation, I could not afford to buy a computer
until I moved to USA in 1997); has been using FreeBSD since 1998, took up
programming around that time as well and has been teaching myself to
program in CL since 2000. Despite the fact that I have supposedly spent 4
years learning to program, I haven't done anything significant (read
"anything besides book exercises"), so in that respect it's like I've
been born a few months ago.

Regards,
  Richard

I am 18, single, and presently alone. I have mostly used scheme to a more
minor extent in some of my projects, largely I use a mix of c and scheme
(with a vm I wrote).
most of my larger (where I actually bother to put code on my site) projects
are almost entirely in c though.

I have many practices and wants which I did not feel were being totally
fulfilled by scheme, I had wanted to use a single language once again. I
could have just implemented most of what I wanted in scheme, but I had
figured this was my chance to get creative. my language design currently
borrows a lot from cl, but I am also adding in details from other languages
I have seen.

probably by most people's standards are am a relative newbie to the lisp
experience, so far I have been exposed to lisp for about 4 or 5 months... I
am still much more comfortable writing things in c than either cl or scheme
though...

  I do not consider myself "next generation" anything, but I have contributed
  to GNU Emacs just short of a decade, was a world-renown expert on SGML and
  related standards until I wrote a book about it and realized that 97.5% of
  SGML is braindamaged and I could not gloss over it, anymore.  First serious
  programming job in 1978 in MACRO-10 on TOPS-10 on PDP-10 -- still in love
  with its design.  Claims to fame include the four-digit year in Internet
  mail (it used to be two, until RFC 1123 in 1989).  Began writing in C under
  Unix in 1980, discovered Lisp same year.  Have written more than 1 million
  lines of code in various languages since then.  Most of it has been shared
  but predates Open Source.  Oldest still running application was written in
  1982.  Hardware history includes Altos and Xenix from 1984, SPARC and SunOS
  from 1993, Intel and Debian from 1997.  Current systems have 1G and 512M
  RAM, dual 600 and 733 MHz PIII, 368G and 40G disk -- literally unthinkable
  when I started out, and I still marvel at the low prices for hardware and
  the low cost of most software and that I can make a living having fun.  Yet
  I got sick and tired of C++ after 1993 (SGML project) and spent 1994 through
  1996 becoming an expert in Common Lisp, supporting myself as a writer and
  journalist.  Franz Inc have supported me with Allegro CL on SunOS then Linux
  since late 1996.  Have also used Scheme actively for a number of years, but
  don't tell the Schemers.  Other languages include Ada (83, 95), ML (sml-nj,
  ocaml), Java, Perl, Python, SQL, SDL, Erlang, Dylan, Smalltalk.  Education
  in mathematics, phycics, computer science and telecom, philosophy, law,
  medicine.  Have contributed to international standards in numerous areas
  (the authoritative version of Open Source) within ISO, ANSI, IETF and ETSI.

  However, I no longer share code with other people by default.  My experience
  and problem-solving abilities have become the bread and butter of my life,
  not just "fun" until something rewarding comes along.  Like many older fans
  of Free Software and Open Source, I have discovered that it is really only
  free in the sense that the time you spend on it is worthless.  When people
  refuse to help pay for the roof over your head and your meals when you help
  them do their well-paying jobs, sooner or later you get seriously pissed.
  So since I refuse to help people /significantly/ for free, I get paid well,
  instead.  I think many Open Source adherents will discover the same over
  time and that it does not pay to help young people of today the same way it
  was mutually rewarding for old-timers to help young people in the past.

  I have remarked here on comp.lang.lisp that Common Lisp is the language you
  graduate into.  When you have done all the compulsory exercises and you have
  acquired the discipline needed to write C++ code that actually works all the
  time, you appreciate the better languages.  Undisciplined people who write
  code that works only some of the time will not understand the point with a
  much more powerful language and relinquishing control over the hardware.
  (Like, I have not upgraded the CPUs and motherboard on my system because I
  would gain nothing from a faster CPU.  100MB/s disks and a 100Mb/s network
  connection are still the major bottlenecks for my work, not to mention the
  /amazingly/ slow bandwidth to and from the human brain.)

| Where, if any, will they take Lisp in the future?

  I think that people will remain focused on making things work with their
  current tools as long as these tools require constant upgrading and yet more
  expenditure of brain time to learn them.  You have to make a conscious
  decision to jump /off/ the bandwagon to realize that it was neither going
  very fast nor anywhere.  XML, for instance, I have called "a giant leap in
  no direction at all" and I really do have the credentials to say that.

| Or, despite Lisp being a programmable programming language, supposedly a
| DNA-like language and all that, could it just stagnate and fade into
| irrelevance from lack of users and evolvers.

  Nope.  When you realize that the tools are getting in the way of getting the
  job done (of which Perl is a downright /marvelous/ example), you embrace
  Common Lisp or its descendants because they do not get in the way.

| How many lines of Lisp code can you produce before you conk out, and have to
| leave it (for better or worse) to the next generation?

  Several million, I should say.  If there is anything to this argument, the
  number is smaller for other languages.  I found that about 10,000 lines of
  C++ was enough for my lifetime.  I can write SQL only as part of a much
  larger solution in another language.  If I were to write SQL all day, I
  would burn out completely in less than three months.  The reason Perl is
  used mostly for small programs is that the immune system kicks in if you
  overdose on it and although Perl looks like bat barf, most people will just
  stop coding before they actually Herl.

  I think Common Lisp is a very safe choice.  I also think Common Lisp is many
  people's last programming language.  Perhaps the line you allude to means
  that you would never run dry if you wrote in C because the truly unsolved
  problems are out of reach, but your creative genius has limits that Common
  Lisp may help you exhaust.

--
Erik Naggum, Oslo, Norway

I discovered lisp a few years ago when I picked up EOPL at the
recommendation of a python programmer.  At first I was wondering what I was
looking at and now I'm totally addicted.  My mind is forever bent.

I code in Perl and C by day, and Lisp by night..  Until I find that elusive
Lisp programming job at least.

Currently toying with a dialect of Scheme for "enterprise" programming.

I started programming when I was 15, but didn't have much time to
study as I
ended up in dotcom as soon as I was elligible to work. My brother
OTOH, had all
the time in the world pursuing what he loves, he is a game programmer
for the
Nintendo Gamboy advance.

When I got laid off from dotcom and I returned home, I got back with
him and now
we are cooperating. He learnt Lisp first, he was playing with scheme
because he
wanted to make a resident gui-scheme sorts of thing for the gameboy,
and I was
learning functional programming on haskell and ML.

I got into Common Lisp after reading Kent Pitman's slashdot interview,
then I
asked by brother around to see if he has any Lisp stuff .. he only had
scheme.
Now I code in CL almost for everything, and he looks over my shoulder
all the
time to see what I am doing. He knows scheme well, so he thinks he
knows CL.

We plan to cooperate and write something substantial together. I want
that thing
to be in CL, he is language agnostic but leans towards C.

He is as crazy as I was about computing; he has 9 computers, none of
them have
the same family CPUs and loves assembler. He collects every kind of
old system
software (OSes, and programming tools) He learns almost everything
new, as soon
as it is out, and hence more susceptible to FUD and hype, just like I
was :-(

  virii and hacks spread about (some undone),
  but only when the network purports it.

  every string can be re-knotted!
  every line can be re-slotted!

  when brothers grow old, yet still share the fun,
  it's nice to hear when someone reports it.

I'm building tons of websites using CMUCL, Portable AllegroServe and
UncommonSQL.  And having fun in the meantime, since Lisp is the only
language that makes working with the web a pleasure.

Greetings,
Wojtek

Male, 24, single (well... sometimes not sooo single ;-) ). Using mainly
Linux and living in Nuremberg, Germany.

When I'm not hacking I spend my time with Gothic/Industrial/Independent
Music, reading, watching movies and playing Roleplaying Games (Shadowrun,
AD&D, Freestyle).

It seems that what some here wrote they are doing is parially my fault...
at least if they use for example Portable AllegroServe. Not so well known
here in c.l.l is another freetime project of me "WeirdIRC" a little IRC
client with CLIM GUI which is one of the first applications which runs on
the continuously growing McCLIM. I personally use it with LispWorks CLIM as
my main IRC client.

On http://www.dataheaven.de/weird-irc/ you can get the source a Linux x86
binary and you can see some screenshots of WeirdIRC running on
LispWorks(Linux), MCL(Mac), Symbolics CL (Genera) and CMUCL(Linux).

ciao,
Jochen

I first learned Interlisp at the feet of Mark Stefik
many many years ago (late 70's). During the rest
of graduate school, though, I spent much more time
with UNIX and C. Since then, I've done a lot of
software development in C and C++ and a smattering
of Smalltalk. About 20 years worth of UNIX-based
development, all told. Probably a half million lines of code.

The past two years I've bounced from one startup
to another (as they collapse...). The development tools
in one were mostly C and Visual Basic. The next used Java.
The next used Python. The current company is an MS shop,
relying primarily on C++ (for the legacy apps) and C#
for the new work.

About a year ago, the president of the company-at-the-time
asked a couple of us, "If you could only program in one language
the rest of your life, what would it be?"

My immediate answer was "Lisp", based on my fond memories
of the power and fun of the Interlisp environment.

In the past 15 years, I hadn't followed the development
of Common Lisp much. But after the recent revolving door
of jobs and technologies, I decided it was time to get off
the treadmill and take another look at the language and
environment I believed was probably going to be most fun
for me going forward. Which meant going "backwards" to Lisp.

I read CLtL2 and as much of the HyperSpec as I could fathom
at the time, Graham's ACL, and many of the Common Lisp
tutorials and style guides on the Internet. Took up emacs.

I couldn't believe how much more the language had become
since I last wrote in it. Generic functions, macros, conditions,
CLOS, the deeper numerics, etc., were just awe inspiring.
I couldn't believe my eyes.

It felt much like when I first played with Smalltalk,
but it goes much deeper. It's like coming home
after a long journey.

I know some of these other languages I've mentioned
have their own little things that make them interesting.
But the raw power and beauty of Common Lisp stands alone.

So I count myself, too, among the new generation
of Lisp programmers. I haven't written much Lisp yet,
but it's all I will be writing in from now on.

Trying to learn at the feet of the masters here,

gak

Most of those who claim that Lisp is dying probably don't do enough
research, or base such research on inappropriate assumptions, such as
applying to Lisp the success and popularity metrics of consumer products.

I prefer technologies that are inherently flexible, stable, and mature.

I primarily use Linux and FreeBSD now.  I stopped chasing the MS upgrade
train many years ago, as I got tired of learning a "new and improved"
way of doing the same old thing I already knew how to do 10 different ways.

Given the near death of the American IT services industry, I'm using
some of my "free time" to rediscover "programmable" programming
languages such as forth, CL, and Scheme.  I had previously used both
Lisp and Scheme in graduate school.

I was an early user of C++ and at first appreciated the OOP syntactic
sugar over C.  As time went on, C++ increased in complexity.  Java
seemed nice at first, but it is and has been one big moving target.

CL and Scheme appear to better fit my criteria (inherently flexible,
stable, and mature).  I'll know for sure after I use them to implement a
few projects.

Peter
--
Peter Santoro, LLC Member
Peter Santoro Computing LLC
(860) 648-2091
Internet e-mail address: pe...@pscomp.com
Web address: http://www.pscomp.com

  To start from the end, the ideas survived unchanged in XML, neither improved
  nor weakened.  The first core idea is hierarchical structuring of information.
  Lisp has had this forever.  The second is textual representation.  Lisp has
  had this forever.  The third is validatability of the structure.  Lisp has no
  notion of this separate from the semantics of special operators or the usual
  evaluation rules.  The fourth is an entity structure that allow documents to
  share components.  Lisp does this by loading things into the image and the
  `require´/`provide´ pair of deprecated operators.  From there on it is all
  downhill for the SGML family.

  The really grave mistakes include the element-attribute dichotomy, the new
  syntax for every meta-level, such as the attribute-value syntax, the qouting
  conventions, character entities and references, document type definitions,
  and ultimately the sgml declaration, the primitive language for content
  models, the changing syntax according as features are supported or not, the
  redundant end-tag, and failure to use a simple escaping mechanism for
  characters that could be confused as markup with the character references as
  data adding additional complexity.  The sheer complexity of parsing SGML and
  XML and presenting it to the caller lies mainly in the syntactic mess and
  the utter lack of an intelligent model for in-memory representation.  (DOM
  is completely braindamaged with no redeeming qualities.)

  Furthermore, the more you think about things in SGML terms, the more you
  realize that fully explicit hierarchical structure is not /enough/.  You need
  macros that take parameters and that expand into commonly used forms and you
  need a content model language that is amenable to changes and support layered
  transition from one version to another.  The straitjacket that SGML presents
  to your information structuring is actually a serious limitation and not at
  all the freedom from implementation-dependence that it set out to be.

  In brief, you are better off just grasping that you need a uniform syntax, a
  hierarchical structure, and a macro mechanism that produces a different
  structure in memory when processing it -- and the implement this in Common
  Lisp, instead.  Simplicity and elegance are found in getting rid of the junk
  and moving the complexity to the processor instead of the source language.
  What SGML has that is not braindamaged and that was not taken from other
  languages before it is basically limited to the validatability and the entity
  structure.  The latter is underrated and large misunderstood and misused, so
  it takes some effort to understand how to use it properly, but it should grow
  to become a fully-fledged macro system before it becomes fully useful.

--
Erik Naggum, Oslo, Norway

It's a very long time since I've thought hard about SGML, but I
remember that there were all sorts of things that you could do in DTDs
which would help you express things (`inclusions' and `exclusions' are
the only placeholders my memory has left but I'm not at all sure if
these were actually to do with this).  I also remember that these
features were so hard to use that no-one actually did use them.

XML DTDs seem to have been simplified to the point where you can't
actually express anything useful at all, and instead you are meant to
start climbing some spiral of standards and semi-standards and just
plain non-standards like schemas (of which there seem to be many
kinds) and so on, which might actually end up by allowing you to
express the constraints that matter, but probably actually don't.  The
end result is something even more complex than SGML was, and rapidly
evolving to boot.

Maybe I've missed the point of what you are saying, or of what SGML
could do, but my impression is that while validatability is clearly
very desirable goal, SGML/XML don't actually provide it in a way that
makes it useful. Of course, there are examples where what they provide
*is* useful (maybe the HTML DTD are examples of mostly-useful one).

When I generate HTML, I normally _do_ expect _MY_ HTML to in fact be
conformant (or at least very nearly so).

But in practice, HTML is nothing more than a "tag soup," where you
throw in a <B> somewhere near where you want bold text to start, and a
</B> somewhere later.  

If part of that needs to be <it> italicized, </it> people typically do
not much want to care if they are doing totally illegitimate things
like having <b> badly <it> nested </b> structures </it>.  

If you try to point out that that is <em> wrong </em>, you'll just get
<blink> flamed </blink> because you're being a foolish pedant.

  Please note that I listed "the primitive language for content models" as one
  of the grave mistakes.  Validatability is a /good idea/ in SGML that is not
  achieved with SGML.  XML did not go anywhere useful with any of this.  I am
  continually amazed that people do not see through the crap.

--
Erik Naggum, Oslo, Norway

learn the technology that all dot-com use (ie, jsp and other perl cpi)
for web application, and thought there must be a better way to build
that category of application.
Then came across Graham's 'beating the average' article,
following the light and digging lisp since.

Anyway, I think what I *meant* to say was that HTML could have been a
case where the DTD actually is a reasonable description of the
structures that made sense.  In practice, as you say, it's tag soup
all the way.