http://www.prescod.net/python/IsPythonLisp.html

-Tim

  What is there to counter?  The guy has completely lost it.  His rant
  about Java (Java's Cover, dated April 2001) is the worst piece of
  dishonest argumentation I have seen outside of U.S. racial politics.
  Clearly, we no longer have to actually read what he writes, it enough to
  "feel" something about it and talk to others who have not read anything
  he writes, either.  Consequently, it is sufficient to argue that:

1 He has been so energetically hyped.
2 He is aiming low.
3 He has ulterior motives.
4 No one loves him.
5 People are forced to listen to him.
6 He has too many arguments.
7 He is bureaucratic.
8 He is pseudo-hip.
9 He has a large organization.
A The wrong people like him.
B His daddy is in a pinch.
C The DoD likes him.

  See http://www.paulgraham.com/javacover.html for how he treats Java
  exactly this way.  (It is obviously irrelevant whether any of this is
  true or not.  Arguments like that are not _true_, they are arbitrary.)

  It is highly disturbing to watch a person progress from what appeared to
  be a clear and successful thinker to his defending his right to be a
  prejudiced idiot.  Everyone looks at something and makes decision like
  "this stinks", but who is presumptuous enough to write an article with
  this as the premise?  The whole piece is an immature stunt, the likes of
  which you expect from 14-year-olds who just came to the Net.  He sort of
  defends his crap thusly:

    Some people who've read this think it's an interesting attempt to write
    about something that hasn't been written about before.

  But this, too, is hogwash.  The prejudice of ignorants has been the
  subject of much serious and unserious writing alike over the years.  When
  not desired, it takes the form of racism, homophobia, and other forms of
  bigotry.  When the prejudice of ignorants is highly desired, however, it
  is called "marketing", "campaigning", "user-friendly", and "popular".

  _Not_ managing to figure out that ignorant hackers have prejudice, too,
  and thinking it has not been written about before is haughty at best.
  But more importantly, should we listen to people who make arguments about
  something based solely on the other peoeple who are behind it, the target
  of it, and who may like it?  Perhaps in a bar, perhaps when trying to
  find out which courses to take at a university, but as a world-wide self-
  published statement?  No.  I say: Turn away!  This is a man who has come
  to his position too quickly and have not a clue how to deal with it.

  A similarly unfortunate incident happened to the brilliant mathematician
  U. J. J. Leverrier, who computed the position of an additional planet
  beyond Uranus to account for its unexplained orbital irregularities
  according to Newtonian mechanics.  Having found Neptune this way (it was
  independently confirmed in 1846), he set out to find a planet inside the
  orbit of Mercury to account for its irregular orbit according to the same
  Newtonian physics that had given him so much well-deserved success and
  high acclaim.  The planet Vulcan the he false predicted numerous times
  obviously does not exist, however.  Instead of another success at what he
  was obviously very good at, he paid with his life and carreer to prove
  the very theory on which he built his standing _wrong_ and paved the way
  for Einstein's much more _accurate_ theories.  (This story is recounted
  in the introductory essay Why and When Are Smart People Stupid by Ray
  Hyman in Stephen J. Sternberg (ed): Why Smart People Can Be So Stupid.
  ISBN 0-300-09033-1.)

  Leave the tragic ranting on Java or Arc or whatever alone.  Remember Paul
  Graham for his very useful contributions to Common Lisp (and try to
  ignore his misinformed opinion masquerading as fact about `loop').
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.

Evaluating the relative merits of languages is hard.  There are two
kinds of contributions one can make in this regard.  The first is
facts about features.  The second is stories about experience with
language features that support thoughtful opinions.

Much of the content of this article is unhelpful to me in
understanding the relative merits of python and lisp, including
sarcasm, vague attributions and a need to discredit or attack someone.

From the "rant about Java [sic]":

"This article developed out of conversations I've had with several
other programmers about why Java smelled suspicious. It's not a
critique of Java! It is a case study of hacker's radar."

That's the first paragraph.  The article explicitly disclaims any
pretensions of being an academic attack on the Java language.  To
criticize it in that light is therefore both misdirected and
misleading.

-Tim

Cheers,
M.

* Tim Daly, Jr.
| That's the first paragraph.  The article explicitly disclaims any
| pretensions of being an academic attack on the Java language.  To
| criticize it in that light is therefore both misdirected and misleading.

  An academic attack?  How misguided can you _get_?  You have divulged that
  you "agree" with this immature cretin's misplaced, prejudicial ranting,
  whatever it means to "agree" with something so devoid of content and
  meaning apart from the pure destructiveness that emanates, if not reeks,
  from this pile of shit, and therefore do not see it as a validation of
  the most base, most unevolved of human emotive responses, of what you so
  aptly called "herd thinking", but it is precisely because this septic
  tank overflow is dressed up in the formal wear of an academic attack, a
  nicely published form by a supposed non- nutcase, that it is so vile.
  Had it been written on public bathroom stalls with creativ spelling like
  "JAVA STINX!" it would have been more less dishonorable.

  There is nothing wrong in gathering a bunch of your sophomoric friends to
  laugh at how something somebody else has done "stinks" and at Ada and the
  DoD and whatnot (lowlives who could not program in Ada if it would save
  their lives generally dislike it because they are too randomly wired to
  accomplish anything useful) in order to have the most fun before you run
  out of moonshine.  It could be quite an enjoyable party, too.  Publishing
  a transcript of this party, however, is not a good idea.  Allowing others
  to use your party comments as the basis for their _judgment_ about Java,
  simply indicates a seriously vindictive and destructive personality -- it
  has turned from drunken party fun to published opinion.  Out of all the
  useless newbies who have opinions on things they do not know, we should
  get Paul Graham to stand up and speak for the clueless anti-intellectual.

  Even if he had chosen to attack Scheme or Perl, a whiff of either is
  sufficient to call for backup, would this have been seriously misguided.
  Validating idiotic prejudice is bad for all parties involved.  After all,
  what better argument do people who think Java (or, hypothetically, Scheme
  or Perl) might be a good idea need to avoid Common Lisp than to point to
  this raving lunatic and his ad hominem-style to show that Common Lisp has
  a jerk who actually believes that you should judge a language by those
  who seem to argue in favor of it.  Luckily, Paul Graham also hates Common
  Lisp, so at least we get rid of any guilt by association if anyone should
  notice his various ranting.

  So not only is this childish stunt hurtful because is _approves_ of the
  worst human flaw, the tendency for people to _want_ to turn off their
  brains, and give into fear and emotion and become no smarter than sheep,
  it is _directly_ damaging to Common Lisp.  Of course, if you are the same
  kind of lamebrained herd animal that really care what others feel before
  you make up your mind about something, why are you using Common Lisp?

  Just because someone has done something good and decent in the past, does
  not mean that they should continue to be treated as an authority after
  that if they do something fantastically stupid and destructive to the
  community that respected them.  The irrational attacks on Common Lisp and
  the "loop" coverage in his book are fairly strong clues about uninformed
  opinionating and confusion of personal and professional opinions, of
  which this "Java Cover" stunt was an amazingly atrocious example.
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.

    I know Scheme and Python, but not Common Lisp. Paul Graham knows
    Common Lisp and Scheme but not Python. Don't trust us.

He criticizes Lisp, then says he doesn't know it and shouldn't be
trusted, then says (to paraphrase) "Oh, but these other people know it
and don't like it."  It's too bad people who don't understand
something, and know they don't understand it, still feel obliged to
publish a paper critical of it.

W3C contributor to XML design... I thought he did not like nested
expressions?

Also a Canadian.

I say "Blame Canada".

:)

--

I found Graham's article better than most of the foolishness I've seen put
forth by those promoting Java or Python or Ruby or VB as the greatest thing
since sliced bread. I don't buy into all of his published points of view (I'm
a big fan of LOOP); Lisp (CL) is my language of choice when its my decision to
make, so I'm a little prejudiced. I don't know for a fact that its better than
the other "popular" languages out there, but it seems to get the job done
quite elegantly. It does seem to me that all good languages should eventually
evolve to an isotope of "Lisp."

I thoroughly enjoy your commentaries.

Returning to Paul Graham's article, the issue is whether he's using
reasonable
heuristics or it's just uninformed bigotry.   To use an analogy, I could
say that I won't drink American Budweiser because it's heavily
advertised,
and swigged by trendoids straight out of the bottle.   Or I could say
that
I won't drink it because it's an American beer and they're all gnat's
piss.
The first is IMO a good reason, the second would be highlighting my (in
reality, nonexistent) ignorance, and (given the facts) be little better
than
racism.   You may point out that the only way I could know for certain
is
by drinking the stuff.   But why should I offend my taste buds?   Also,
my
heuristics work quite well.   If they didn't, I'd change them.   Java,
ISTM,
is like American Bud.   We all make decisions based on imperfect
information,
particularly when, as would be the case with Paul Graham mastering Java,
the
costs of perfect information are so high.

There's an undercurrent in Paul Graham's writings -- a quest for an
understanding of quality (in the Pirsig, rather then the ISO, sense).  
In
that respect, he's following in the footsteps, quite some distance
behind,
Richard Gabriel, and even Christopher Alexander and Pirsig himself.  
This
is worthwhile in its own right.   What may be slightly more misguided is
his attempt to make a popular Lisp, or a better, Lisp.   Lisp is
unpopular
_because_ it is so good.   A better Lisp would be only slightly better,
and not worth the switch for Common Lispers for much the same reason as
a
QWERTY to Dvorak switch is not worthwhile.   And Arc would still be
perceived as a Lisp by non-Lispers, just like Scheme is.   My belief,
and
I've thought about this long and hard, is that a better language than
Common Lisp would be (a) very different from it, and (b) even less
popular.   Arguably, and I'm not saying I accept the argument, it exists
in the form of Prolog.   So, unless it's tailored to a particular
system in which it resides (like Emacs and AutoCAD are), or is extended
to
support a specific kind of application (like XLispStat is), there is
very
little point in inventing another Lisp, except perhaps as a testing
ground
for new ideas for Common Lisp to adopt after they have proven
themselves.

(setf (get 'suit 'material) 'asbestos)

  Would you want the same thing to be done about yourself or something you
  had done?  Would you want it to be done about Common Lisp?

  If you have different rules for different people, I do not care about
  your rules.  However, if you would as happily accept the same treatment
  of Common Lisp, let me know, and I shall consider your opinions.

  Whether you "agree" with such a load of crap or you think Java "deserves"
  a treatment like that is wholly immaterial.  If you allow it to happen to
  other people and other things, you must allow it to happen to yourself
  and to things you value.  If you let someone trash Java this way, you
  have opened the door to trash Common Lisp this way.  Because Paul Graham
  does it, he has directly invited people who think Java is a good idea to
  think Lisp is bad because _Paul Graham_ is associated with hit.

| Lisp is unpopular _because_ it is so good.

  Nonsense.  (Common) Lisp is unpopular because of the exact same crappy
  "reasoning" that Paul Graham applies to Java.  It has nothing to do with
  quality.  It has everything to do with ignorant fucks who plaster their
  prejudice all over the place, without ever looking at it on their own.

  Paul Graham has done to Java what most sane Common Lisp defenders argue
  is so wrong to do to Common Lisp.  That is the issue, not whether Java
  sucks or not.  Incidentally, he also thinks Common Lisp sucks.

  Please, just think.  People generally think better if they take off their
  asbestos suits, because the mortally frightened generally do not think.
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.

I doubt if the writings of Paul Graham even register with the Java
crowd.
Googling on "Java's Cover" reveals little, and nothing unfavourable.  
When
you're popular, you don't worry about being good.

A better-informed critique of Java's contents would of course have been
preferable to "Java's Cover", but it's high time someone spoke out
against
the hype surrounding Java.   It's positively dangerous (see below), not
merely scary.

(a) by-products of its quality -- it's hard to learn (true, so you can
be
sure that programmers who master it are good), unpopular (and when did
that
indicate lack of quality?) and old (but it's survived the course);

(b) misinfomed claptrap ("it's interpreted", etc.)

(c) the parentheses.   These are the first impression, and usually the
last,
programmers get when they look at Lisp.   I like to think of the
parentheses
as the things that scare away the bad programmers.   But we can point
out that XML has twice the number of angle brackets, that unlike Java,
you can change Lisp's syntax to get rid of the parentheses if you want
to,
and that this has been tried at least three times (Lisp 2.0, CGOL and
Dylan)
but didn't catch on.

Much of this, I get the impression, is because of the treatment Lisp
gets
at universities, though I have no more than hearsay evidence for this.

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

Lisp hasn't been hyped at all since the 1980s, and even then it
benefited
from only a small fraction of the hype that Java currently enjoys.  
Lisp
paid heavily for that hype -- Lisp machines are no longer made, and only
a
handful of companies still offer Lisp as their product.   Companies
employing people as Lisp developers are now very thin on the ground.

Hype in general is a serious problem.   In the 1980s, when AI and
expert systems were all the rage, people had unrealistic expectations
of machines with near human-level intelligence, which could not be met.
And when they duly weren't met, companies went bust, and Lisp's brief
popularity ended.   (Prolog fared even worse.)

Then, in the 1990s, it was the turn of the WWW to be hyped.   Java was
very much part of that hype.   This time round there were differences --
such as no noble ideal of technological advancement -- after all,
distributed hypertext was invented in 1945 (Memex) and realized 30 years
later (INFO on ITS).  All the web did was add pictures to the text,
and enable programs to generate HTML.   No, this time it was pure greed
-- making money from nothing.   Otherwise intelligent people believed
that the rules of economics had miraculously changed, as they did in
17th century Holland when tulip bulbs sold for fantastic prices.   And
Java has been the snake oil which has fuelled this "new economy".

Meanwhile, back in the real world, people realized that Adam Smith was
still right.   Disillusionment started around two years ago.   This has
coincided with Java's slow decline from its peak.   When disillusionment
is total, as it was for AI by the mid 1990s, the computer industry could
well find itself in the most severe recession it has ever experienced,
and people will look for something to blame, and that something could
well be Java. The Java hypers will deserve much of the blame when this
happens, as they inflated the bubble more than most.   Lisp will likely
survive Java, because good things last unless they're very unlucky.
Things which are merely fashionable, such as Java, don't last, and
aren't missed when they go.

Note that I wouldn't be rounding on Java if it hadn't been relentlessly
hyped.   It's not that bad a language.   It's just not anything like as
good as its advocates make out, and better alternatives already existed
well before Java was released, or even conceived.

  This is so nuts that there is no point in trying to reason with you.
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.

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

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

Ot, to quote the Red Electroid ate the end of "The Adventures of Buckaroo
Bonzai Accross the Eighth Dimension", "So what?  Big Deal..."

And now back our normal programming - the programming language debate.

****

Lisp unpopular because it is powerful, and be used for programming in
areas such as Artificial Intelligence and the Semantic Web, a step up
from base language (is this alchemy?). I have often felt that the
syntax has been a factor. "Unthink" our years of programming {Perl,
Java, Python, C, Cobol, Fortran, Basic, PL/1} and see that clarity of
thought that went in to designing Lisp.

  So, evidently, you think there was a measured debate prior to their use.
  This is downright _frightening_.

| These types of remarks usually demonstrate sloppy thought and hasty
| delivery.

  That you arrive at such conclusions by counting words on a word list
  instead of understanding them is evidence thereof.
--
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.