On Aug 12, 2005, at 8:36 PM, Michael Halcrow wrote:
Ladies and Gentlemen, may I invoke... The Wisdom of Crowds:
Crowds are sometimes wise, but they are also sometimes unwise.
Witness stock market bubbles, riots, etc. The dumb crowd behaviors
arise when people make their decisions based on what everyone else is
doing. Smart crowd behaviors arise when everyone makes their own
decision.
I don't think Sourceforge is a very good indicator of crowd wisdom,
because of these reasons:
1) It's primarily full of open source/free software projects.
2) Open Source projects rise largely from a community who consciously
set themselves apart from the mainstream and into a peer group by
using particular open source tools.
3) Open Source followers typically subscribe to one of a few closely
related philosophies that are given by community authority figures
4) There is a large amount of peer pressure to use particular tools
in the open source community
Thus, I don't think the individual decisions represented on
sourceforge are representative of a diverse enough community to make
a 'group wisdom' judgement. You can still disagree with me, of
course, but that's my reasoning.
In my compiler theory course last semester, my professor really had a
thing for Lisp. He just couldn't stop extolling its virtues. So I
pulled up this list and called him on it right in the middle of one of
his Lisp diatribes. ``If Lisp is so great, why is it that Lisp only
has 300-some-odd projects on SourceForge, whilst C, C++, and Java,
respectively, have 15,000-some-odd projects?''
He stammered a little, and then gave an answer along the lines of,
``Uh... well... it has to do with momentum. These other languages are
just so popular that other, clearly more superior languages, like
Lisp, just don't stand a chance! And then schools fail to teach this
great language, and the cycle continues...'' The skeptic in me
stirs... Lisp has been around much longer than Java. If Lisp is so
much better, why did Java trump it so decidedly in the marketplace,
being such a relatively new player on the field?
Let's think about this a little bit. Sourceforge is the open source
community project list. The whole open source movement centers
around Unix. Unix is heavily biased towards C. C, C++, and Java are
all in the same family of languages. Perl is also a very unix-
oriented language.
Now consider the history of Lisp. It was once the hacker language of
choice. Read stories about the early history of computing, and
they'll be filled with stories of the MIT AI lab, the ITS operating
system, etc. This was a strong Lisp community. But Lisp Machines
(which rose from the MIT AI Lab) went commercial and proprietary, and
thus the hacker community was forced away from them. Lisp was
dominated by commercial entities for a long while, and enjoyed great
commercial success in the 80s.
So, with cheap unix workstations on the rise, and a new hacker
community arising from unix, C, etc., the market naturally shifted
that way. Most accounts of that transition I've read about are
filled with grumbling from lisp machine programmers who had to
transfer to the far less elegant and far less productive, but way way
less expensive unix workstations. With the hardware limitations of
general purpose computers and the commercial nature of most Lisps
that ran on general purpose hardware, Lisp just wasn't available for
the rising generation of hackers to play with.
So, basically, your perspective on this is wrong. Lisp never had a
chance to compete with Java. It was thoroughly marginalized by C and
C++ on cheap unix workstations and DOS PCs by the time Open Source
and Java came around. The majority of the workforce and hobbyists
had missed Lisp's heyday. I would guess that a large percentage of
sourceforge projects are from people who've been programming for less
than 5 years, and who haven't looked much back into computing history
beyond when they began.
So thus any language that merges most intuitively with the human
experience is the best. Any language that requires radical departure
from human thought patterns or -- if you will -- templates, while
theoretically more efficient for implementing certain algorithms, are
simply incompatible with our natural way of thinking. Thus, less
capable languages may be better fit for use by mere mortals.
Ironically, Lisp was the first computer language that attempted to
program the computer from the human's point of view rather than the
computer's. The languages around when it was developed were assembly
and early Fortran, which was rather primitive. I believe 'spaghetti
code' first described Fortran with lots of gotos, and Fortran code of
that period also prompted the infamous 'Goto Considered Harmful' paper.
For that reason, Lisp was the language of choice for tackling hard
problems. It says a lot that people chose to use Lisp over Fortran
back in the early days of computing when Lisp was interpreted and
horribly slow.
--Levi
.-----------------------------------.
| This has been a P.L.U.G. mailing. |
| Don't Fear the Penguin. |
| IRC: #utah at irc.freenode.net |
`-----------------------------------'
