I think these mesages would not be very far from truth anyway.
J.B.

 Florian> There is a nice spaghetti graph of the influences on Scheme on page 10
 Florian> of the "Detailed history of the Lisp family" linked to from
 Florian> http://lambda.weblogs.com/diagrams
 Florian> But ther is no MDL, only something called  "Muddle",
 Florian> is this the same thing?

 Florian> There is a nice spaghetti graph of the influences on Scheme on page 10
 Florian> of the "Detailed history of the Lisp family" linked to from
 Florian> http://lambda.weblogs.com/diagrams
 Florian> But ther is no MDL, only something called "Muddle",
 Florian> is this the same thing?

Yes, Muddle is how you pronounce MDL.

 Florian> There is a nice spaghetti graph of the influences on Scheme on page 10
 Florian> of the "Detailed history of the Lisp family" linked to from
 Florian> http://lambda.weblogs.com/diagrams
 Florian> But ther is no MDL, only something called "Muddle",
 Florian> is this the same thing?

 Christopher> Yes, Muddle is how you pronounce MDL.

 Christopher> That graph has some things that are correct, and some that are not.
 Christopher> For example, it shows Algol relating to the original version of Scheme
 Christopher> but that didn't happen until later (it should be Revised Scheme).
 Christopher> It also fails to show MACLISP being related to Planner,
 Christopher> and also fails to show it for Scheme.

There is a third, personal point: As I am not an expert I must trust
somebody. I know that you are an expert but then Mr. Abelson and the others
who say they are using Lisp are experts too. Do you think that their claim
of using Lisp is not justified?

J.B.

Here's what I find people learn in a Scheme course:
 - how to cdr down a list
 - lisp is 1 namespace
 - it's ok to nest defines inside each other
 - tail recursion won't get you in trouble
 - declarations are unimportant
 - class systems are unnecessary
 - error systems are unnecessary
 - languages without a written formal semantics are bad
 - the goal of a language is to trivially implement itself metacircularly
Of those, only the first item is also true of CL.

Here's what I find people learn in Java:
 - how to use a variety of datatypes
 - class systems are good
 - the namespace issue is not the main thing in life
 - iteration using conventional operators is ok
 - declarations are useful
 - class systems are useful
 - error systems are useful
 - getting real work done is important
 - dynamic type discovery is cool
Of those, most of them are also true of CL.

  Grow a brain, Janos Blazi.  It was a deliberate spoof of your idiotic
  line.  Too subtle for you, obviously.  Sigh, what a cretin you are.  Of
  course, I also actually mean it.  I criticize people's behavior harshly
  some times, but I do not _attack_ them.

| (1) Anette Stegmann posted some trange views here and then you told her
| that she was an idiot.

  Find the quote.  You will find that not only are you an unintelligent and
  despicably stupid person, you are also unable to remember well enough to
  avoid being exposed as a liar.  I kind of appreciate that you go to these
  lengths to prove what kind of character you are.

| (Now I do not like her too much [...])

  How amazing that you still do not understand that this newsgroup is not a
  forum to talk about what you like or not about other people.  This is the
  only topic of such a staggering amount of your posts that I doubt that
  you can even think in other terms than your feelings for people.

| (2) There was another case more recently where somebody said something you
| did not like and then you started attacking him immediately [...]

  This is an _example_?  Can you _be_ more vague?  You do not even want to
  do the legwork of finding the goddamn articles that are your examples!
  Could you _try_ to relate to the sheer exasperation that every reader of
  your inane babbling must experience?

  But since I remember it, let me tell you what it was: It was an example
  of an _intelligent_ response to criticism considered unfair.  How unusual
  that is!  He also took care to avoid the things he was criticized for.  I
  am sure you missed that.  Of course, you did not understand this, and
  failed to get the point completely.  How amazing that you do not even
  grasp this.

| Finally (now an attack follows) [...]

  What the hell is the _point_ with your annoying behavior?

| I tried to analyze the way you are and myself: [...]

  It is because you are a dog who needs a master who can tug your leash.
  The despicability of your servility is only matched by a behavior that
  only invites harsh responses.

| I think: as well as I can.

  No, you do not.  It would be a tragedy of biblical proportions of what
  you do is the best you can do.  A human being cannot actually _be_ so
  retarded and still find his way to Lisp.  That means there was once a
  glimmer of something that caused your miserably underutilized brain to
  work long enough to find Lisp.  That kind of random spark betrays a
  potential that you have chosen not to realize at all.  Idiot savants
  aside, really unintelligent people simply do not display the amount of
  sustained concentration necessary for them to discover something as out
  of the way and complex to learn (for them) as Lisp.  So you _must_ be
  playing the despicable, annoying moron.  Quit playing, and THINK!

On 20 Dec 2001, Dorai Sitaram wrote:

On a side note, I am starting to see the many differences between Scheme
and CL, but I'm still not seeing how Scheme differs enough to warrant it
not being part of the "Lisp family" (the general feeling I get from CL
people on Scheme).  It looks to me as if neither Common Lisp or Scheme is
very close to (or equally seperate from?) the original LISP language.

  This is nothing but a good reason to tell those who want to learn Scheme
  to study Common Lisp first so they do not waste the time on Scheme, and
  for Common Lisp people to know enough Scheme to help the wayward.

  But why do Scheme freaks argue so strongly against Common Lisp so often?
  Is it because nobody in their right mind switches from CL to Scheme, so
  CL poses a veritable threat to Scheme?

Take a little bit time and use your search-engine in order to search code
(statistics, linear algebra,...) for Common Lisp; and after that, search for
Scheme code (you will not find any). I think this says much and leads to the
next discussion:

This is stupid and stupid and stupid. Common Lisp suffers the same as C++
suffers due to C, because most believe when they know C they know C++ too.

Your devoted friend, J.

Practical people are very interested in CL.  It is an
industrial-strength language with a promise of wealth
creation.  The CL community could reduce the immigrant
fraction in their numbers by having mechanisms to rope
in these people at their first s-expressive stirrings,
instead having them wander around having their non-CL
adventures.  I don't know what such mechanisms could
be.  Hopefully wider publicizing of _Successful
Lisp_, Paul Graham's already famous books, and
user-friendly impls like Bruno Haible's CLISP would
help.  

Failing such mechanisms, one might as well accept these
immigrants as bonus additions.  Getting them on the
first round would have been ideal, but at least
you got them on the second round.

I understand that CL apologists consider it important
to counter this kind of positive coopting.  Again, I am
unsure how people could go about it, and indeed,
whether they are not better off just doing routine
things, like say the Linux people have been doing for
the most part, instead of succumbing to the siren call
of the language-is-a-political-party meme so
effectively and persuasively propagated by big names
like Kent Pitman.  Another big-time Lisper, Guy Steele,
once started a textbook with the short claim, "Common
Lisp has succeeded." That book, despite claims that
it is outdated, is still the most popular CL
textbook today.  Perhaps the CL of today can be as
self-confident and secure in its own undeniable
strength, and not give in to identity panic against a
rather small language like Scheme.  I am not saying the
latter is happening yet, but it needn't even be a
hypothesis.  "Common Lisp has succeeded."

  Nope.

| Actually I am a very balanced person and I pay reference where reference
| is due.

  I am so sure you are the best judge of that.

| And I try to see you objectively as well.  I appreciate Dr Naggum who is
| a fine CS expert and I laugh about and at the same time  feel sorry for
| Mr Naggum who has lost control after drinking some strange potion.

  This is not "objectivity" in any known human language on planet earth.
  Please get abducted again and consult their intergalactic dictionary
  before you return.  Better yet, do not return, teach them Scheme so they
  never get around to implement a sufficiently "pure" invation strategy.

Just go back to the joke: "I'm not sure if it's a _bug_ that Scheme
has no #Erik, or whether it's a _feature_."

Laugh once, because it _is_ funny.  It's worth a chuckle.  Perhaps not
a full-scale belly-laugh of total hilarity, but at least the chuckle
of wondering what the original writer intended.

Anyway Erik: Fröhliche Weihnachten!

J.B. (immediately before getting abducted)

:)

Another complaint I've heard here about Scheme is that the use of call/cc can
lead to unmaintainable code, but the same applies to macros in either language.

On the other hand, for the uninitiated, CL is pretty baroque and consequently
professional code can be harder to read than Scheme due to the additional
syntax and functionality.  The complexity of the standard cannot easily be
reduced at this point, so professionals must make an effort to keep their code
readable.

There must be many thousands of students being exposed to Lisp via Scheme each
year, and this number is increasing.  Part of that tradition is to understand
Scheme well enough to do a (simple) implementation.  This _has_ to be be a win
for the Lisp community, because it promotes a Lispy way of thinking about CS.

Then when those kids gain the confidence to do something big, CL is waiting!
Enough of the internecine warfare! Just tell them, "OK, people, now you're
ready to come over to the big time, welcome!"

And I suspect that neither CL nor Scheme is the 'final' Lispy language.

  Why do you think it was ignored at first?  Jokes are never harmless,
  however, and if someone wants to make them harmful, they will succeed.

  I have not seen you respond well to "jokes" about yourself, yet.

  Of course Scheme is not a Lisp!

| Scheme is, IMHO, a very clean language and easy to read.  That
| contributes to ease of maintenance.

  Of course you are a Scheme fan.  Who could have _guessed_?

| On the other hand, for the uninitiated, CL is pretty baroque [...]

  Of course you are a Common Lisp non-fan.  Who could have _guessed_?

| There must be many thousands of students being exposed to Lisp via Scheme
| each year, and this number is increasing.

  They are not exposed to Lisp when they are exposed to Scheme.

| Part of that tradition is to understand Scheme well enough to do a
| (simple) implementation.

  This is one of the reasons that Schame is such a sucky language.  Real
  languages are so hard to implement that it makes sense to have someone
  _competent_ do that job for you.  You know, that division of labor thing
  that economists tend to think is so useful for advanced societies.  And
  what do people implement?  An interpreter that relies on the underlying
  compiler or interpreter, right?  How _useful_ is that?  If they spend a
  lot of time writing a _simple_ compiler and support libraries, etc, with
  a lot of stuff you simply cannot do in Scheme itself, they will discover
  how to bootstrap a system using another system.  How _useful_ is that?
  _Why_ does the world need more Scheme implementations than programmers?

| This _has_ to be be a win for the Lisp community, because it promotes a
| Lispy way of thinking about CS.

  No, what it tells people is that the most important feature of "Lisp" is
  that professors get to annoy students with a stupid exercise to implement
  the language in itself.  Scheme is a stupid, stupid thing to teach people
  who want to _program_.  It is even more harmful to teach people who want
  to do research.  It is yet more harmful to teach people who do not want
  to write programs for the rest of their lives.

| Then when those kids gain the confidence to do something big, CL is
| waiting!

  This is just plain wrong.  Is MIT Scheme implemented in Common Lisp?  Why not?

  Scheme is a way of thinking that differs from every other language on the
  planet, _including_ Common Lisp, which in important ways is a mainstream
  language with non-mainstream operator names.

| Enough of the internecine warfare!

  Go back to your Scheme cave and the warfare will at least quiet down.

| Just tell them, "OK, people, now you're ready to come over to the big
| time, welcome!"

  This sillitude betrays a misunderstanding of the fundamental differences
  between Scheme and Common Lisp, which only Scheme freaks suffer from.
  Common Lisp people understand that Scheme is very different, since you
  can write Scheme in Common Lisp but not vice versa.  I have seen _so_
  much Scheme in Common Lisp from people who have been brainwashed in
  Scheme that it is in fact _the_ strongest reason for me to want Scheme to
  go to hell.  _Unteaching_ Scheme victims takes longer than teaching a
  person who has never seen any Lisp at all to become a good Common Lisp
  programmer.

  There is an old joke about which platform Oracle ran best on (35 mm slide
  projector), but I think it might need to be revised:

  Q: Which platform is best for running Scheme?
  A: A blackboard.

  As long as Scheme is marketed as a Lisp, it must be fought by every other
  Lisp.  Scheme may be closer to the "roots of Lisp", but if you want to
  write your project reports in the language of Beowulf, or Shakespeare,
  expect to be unemployed.  Scheme is one of the strongest reasons people
  who have a fraction of a degree in computer science loathe Lisp and hate
  parentheses.  For _real_ programmers who want to use large languages so
  their code can be small instead of re-implementing small languages and
  their own large libraries, Scheme is a silly toy, and it taints the whole
  Lisp family with its silliness.

  _Maybe_ if Scheme was taught differently and would be so kind as to avoid
  communicating bad things about the entire Lisp family, it would not be so
  bad.  I am currently reading Structure and Interpretation of Classical
  Mechanics, and it is a _tremendous_ book -- it makes me want to return to
  calculus and analysis with Tom Apostol and Richad Courant and write a
  calculus book with Common Lisp and a graphics library to do 3D plots.
  But, again, Scheme is used to teach.  This time, however, Scheme is used
  productively to teach mechanics, not mastubatorily to reimplement Scheme.