That said, I have not yet seen anything brought up that makes me less satisfied
with the solutions common lisp provides.  I looked over Paul Grahams Arc page
and while I find all of the goals he expresses fine, the examples he has so far
of things he wants different from CL strike me as very trivial and very
personal.  The points raised so far in this thread about #f vs nil and '() etc
are interesting and I believe support the idea that there is another approach.
But Common Lisp has not taken that approach and I see no problem as it is.  If
things were broken enough that you had to start from scratch, these are
interesting issues, but with such a fine and established base as we have now,
these are moot points.

Common Lisp doesn't have if*; in Common Lisp nil == '() == false; Common Lisp
has too many parens in its cond form; Common Lisp has a loop macro that is very
un-lispy......so what?  *Nothing* there is even _remotely_ unuseable or
unsupportable.  And the flexibility is built in to the language to to modify so
much to your own personal tastes.  All the energy spent trying to sugar coat
lisp for the masses would be so much better spent developing all those huge
libraries Java and Perl people miss so much.

I do not beleive popularity is a bad thing and I would honestly like to see
lisp grow its user base.  But it is not worth _any_ sacrifice in the integrity
of its design.  Jan Derzen said something along the lines of "if they have to
be converted, who wants them".  While I can't agree with that as stated, I do
feel that if you show someone the light and they don't see it, that is there
problem.  Too many parens is *not* what keeps people from appreciating lisp.

Andreas

Have *you* ever tried to change a law?

What I want to captialize on is sharing experience with other Lisp
people about the common foundations.  You can hardly blame me for
that.

It's just that I don't think that *a* wrong answer is *the* wrong
answer, for precisely the same reason.  That's what I have written
above, and it would suit you well to address this argument, instead of
handwaving.

Andreas

By the way, the URL of the poem on the topic did a lot more to
enlighten me on the subject: it showed me a typical construct where
nil == '() is useful, and that I need not worry about Dylan doing it
in a way I consider more consistent, because the concerns don't apply.

All I've seen from you, on the other hand, is hundreds of lines of
insult against my person and intelligence, sprinkled with a couple of
interesting, but unrelated insights.

This is based on observation of the problems (especially security
problems) of software that violates these rules.  Prominent examples
are Blueboxing (the ability to make fraudulent calls in C5 PBX systems
by generating tones) and denial of service against modems by sending ICMP
Echo packets with +++ATH0 in them.

I even think there was a security problem in X11 that was based on
sending 2^32-1 bytes of data to the server.  That made some counter
reach -1, which was treated special.  The poor C program promptly
mangled the return pointer on the stack, and an attacker could inject
exploit code.

So anybody who thinks that CL is better off violating this rule either
doesn't believe in it, or believes that there are more important
rules.  In both cases, I am curious to know why.

Using the former when meaning the latter fails to communicate the
intent.  

Too bad this isn't true for the (when foo) case, it only works for
lists.

By the way, please forgive the use of the Dylanesque empty?.  I'm so
used to working in a language where I can express operations on
collections independent of their implementation that I completely
missed the fact that there is no empty? in Common Lisp, and that it
can't be implemented in a way that would have equal performance to
(when foo).

Quite often, what they produce makes the world a better place. Common
Lisp certainly has served it's purpose.  The citation above is just a
nightmare haunting me :)

But I think I'm able to judge other people's designs up to a certain
degree.

But I think slightly improving existing languages is a more realistic
target.

I've had several opportunities to demonstrate my technical skills, for
instance leading a development effort for digital TV software with a
team of 40 developers (and my design worked), and recently as a member
of the team winning the second prize at the ICFP2001 contest.

And sometimes agreeing to disagree is the only reasonable outcome.

I don't pretend to speak for the Lisp community, but for myself I
don't ever want to have the language change out from under me in
incompatible ways again.  I have thousands and thousands of lines of
CL code which I use *all the time*, and I want to get on and live my
life and not ever have to worry about whether I've made some
possibly-now-invalid assumption in code I wrote at 4am, barely
understood at the time and definitely do not understand now.  There is
simply nothing that is wrong enough with CL that I want, ever, to see
incompatible changes. And the amount of code I use is pretty small by
many standards.

You have to remember that many people have been through this process,
moving code from MACLISP to Zetalisp to CL to ANSI CL or from
InterLisp to CL to ANSI CL, and doing it all over again just is not
attractive *especially* when the kinds of changes people are
suggesting are fixes to things that many do not regard as broken in
the first place.  There was a compelling reason to move things to CL,
there really is no compelling reason to make random small incompatible
tweaks to the language now.

It's like the side of the road you drive on: I mean it's just obvious
that driving on the wrong side is this stupid, dangerous idea.  It's
not like there's disagreement like there is with NIL/false - everyone
knows driving on the left is just *better*.  But it's really an
incompatible change, and it would be quite expensive to make, so it's
not generally considered worth it.  Indeed people who spend a lot of
time worrying about it are generally regarded in the driving community
as fools, especially when they insist on posting in
comp.driving.right.

Another thing people don't want to happen is fragmentation, and again,
that's because people have *seen* this happen before and they don't
want it to happen again.  CL was this heroic, hugely expensive (how
many millions of dollars I wonder? less than 1000?) effort to unite a
fragmented community which ultimately succeeded but in the process
just destroyed great areas of stuff. What happened to all the
InterLisp stuff? - it's all largely just vanished, because porting it
to CL was too hard.  I'm really too young to remember this, but I was
there when the InterLisp machines were going away and it was painful
to see how much stuff got lost, even in one fairly small project.  I
*still* don't have some of the tools I had then.  And, althogh you are
probably too young, a lot of people remember the bad taste left by
Dylan, which was seen as an attempt to fragment the community for no
very good reason: that was really a nasty experience.  So people don't
react too well to suggestions that involve incompatible new dialects,
and it's not really surprising.  And especially they do not react well
to suggestions of incompatible dialects based on something that many
people do not see as broken.

Here's another example: SunOS 4 to 5.  Again, you may not remember
what this was like, but many do (especially a lot of people at Sun I
bet).  SunOS 4 was really a mess, 4.0 was hopeless at the user level,
4.1 was kind of OK for users but internally horrible (there were,
seriously, things in the kernel like `x=x;' with a comment saying
`this makes it work').  SPARC support was wedged into it, and there
was basically no real chance of getting decent multiprocessor
performance because the architecture was so broken.  And lots of
commerical people wanted SysV, so there was hacked-in SysV stuff both
at user and kernel level.  It must have been horrible for Sun.  But
SunOS 5 took *years* to be accepted, because lots of people had all
sorts of stuff which really depended on SunOS 4 and *really* did not
want to change things, because from the user level 4.1.3 / 4.1.4
worked really OK, and early SunOS 5 was buggy and slow. I remember the
horror when Sun came out with machines (ultras? or was it before that)
which *would not run* SunOS 4, and the relief when we found that you
could, in fact, get SunOS 4 for them if you asked the right people.
This must have cost Sun *enormous* amounts of money.  You can see how
bad it was by the fact that they've now renumbered things so no one
ever worries that there might be a SunOS 6 some day.  And that was a
change which - even though I'm a BSD person and it hurts to say this -
needed to be made.

Finally, the question is *why*?  Why are people obessing away about
NIL/false or other incompatible changes which have little benefit and
much cost, when instead you could be working in *compatible
enhancements*, which would have little cost and huge benefit.  I mean
there must be *millions* of things you could add to CL which would not
break a single line of existing conforming CL code and would provide
cool new stuff.  Tie down the MOP, for instance.  Design and get
agreement on a MP interface.  URIs.  Standard sockets.  FFI.
Defsystem.  I can just keep typing these things in for ever.  *Why*
are you worrying about some trivial little design issue when you could
be doing something cool and new?  Come on, get *over* it, this is just
*STUPID*.

  Precisely.  This is your problem, and you should just go fix it.  Nobody
  is so fucking stupid as to regard a standard as "gospel".  Grow a clue.

| The "you must believe in it, because it was written by God^Wpeople much
| smarter than you" argument.

  Where is the "believe in" part outside or your mind?  Just because you
  have a personal problem with your incredibly low reading comprehension
  and an overactive imagination that fills in the blanks when you do not
  understand what you read, does not give you the right to assume that you
  reach valid conclusions.  In fact, it is typical of inferior thinking
  skills that you _do_ think you can fill in the blanks and reach any
  goddamn conclusion you want.  Rational people do not lie about their
  observations in order to arrive at their pre-conceived conclusions.

| The "it's not Lisp unless it is Common Lisp, and everybody deviating from
| Common Lisp is a heretic, even if he doesn't claim

  Nobody says this, either, you dimwit.  Notice how you introduce all the
  religious terms -- because that is _your_ language.

  But because _you_ make up your mind that somebody is religious, and you
  are the first to relinquish rational argument, _you_ are in fact the only
  irrational and religious person around.  You will never understand this,
  any more than most criminals accept that they are guilty.

| I'm not lacking evidence, there's enough in your postings.

  Only for the association in _your_ mind.  That has nothing at all to do
  with me.  For all your fascination with logic, you sure do not know how
  to arrive at valid premises.   When you accuse me of something when in
  fact you are only accusing me of causing associations in a deranged and
  religious mind, it is important to point out that every monster you see
  is your own creation.  Religious people, especially those who have turned
  their back to religion for the wrong reasons and who have a huge personal
  authority problem as a result, tend to assume that _all_ authorities are
  religious in nature, or want to be.  This happens only to stupid people
  who are too goddamn slowwitted to figure out what they really object to.
  Because they can label everything they do not like "religious" after this,
  they will also never mature or develop beyond this infantile rejection of
  authority.  In short, mentally underdeveloped and rebellious children.

| If I sound like a religious zealot to you (which of course is just a
| pattern in *your* brain), and if you think religious discussions are
| pointless, stop listening to me.

  A person who talks about "gospel" is ipso facto a religious zealot.

| I'm only reporting my impressions, honestly and faithfully.

  My _impression_ of you is that you are probably the stupidest person to
  come visit us in several months.  What value does this impression have?
  Should I share it with anyone?  I am trying to cause you, the stupidest
  person around, to revv up your dysfunctional brain and stop accusing
  people of your own mental problems that cause you to think anybody but
  you think in terms of religion and gospel.  This is _your_ problem, and
  only _you_ can solve it.  Here is how: Figure out that people who look
  religious to _you_, are in fact _not_.  Then read my signature and be
  enlightened, or at least start to think.

| If this annoys you, maybe you should search the reason on your side.

  Of course, it is also Common Lisp's fault that you have problems with it.

  Dylan seems to breed clueless idiots faster than applications.

  Yes.  I also succeeded.  Next moronic question, please.

| All I'm saying is that if I fail to conform to Common Lisp, it is still
| Lisp.

  This is sheer idiocy.  Implying that you believe something so
  fantastically moronic is not a very smart move on your part.

  A typical moron response.  "Fail to think things _through_" cannot be
  countered simply by arguing that something "usually involves thinking".
  In fact, you _support_ my argument that yo do not think things _through_.

| Because *you* treat me that way, and I suggest this is *your* problem.
| Seems to be hard for you to understand.

  When a criminal gets caught, it is always whoever catches him who is to
  blame for his predicament.  That you react this way supports my image of
  you as someone who has not learned to subordinate his desires to that of
  an authority.  Usually, this is due to massive immaturity or arrested
  development, but sometimes, it is a kind of arrogance that actually has
  concluded that society can go to hell.  How do you make people change
  their mind once you have given them this "impression"?  You _THINK_ and
  provide them with counter-evidence.  Of course, trying to give you any
  counter-evidence to your religious lunacy has made you even _more_
  certain that you are right.  This indicates that you retarded or have
  never actually _observed_ that you have been wrong at any time in your
  whole life.  This goes with the arrogance and maturity problems you have
  so far made a point out of underlining.

  If you do not like this "personal touch", quit accusing people of being
  religious simply because you are too stupid to argue against them.

  Dylan is a Lisp the day Perl is a Lisp.  For the same reason.

| If he says Scheme is a Lisp, and that Lisp has shortcomings, he's saying
| that Scheme has shortcomings.  So there's no point.

  Sigh.  You probably even believe this.  I feel sorry for you the day when
  you figure out what marketing is made of, indeed human communication.

| What I want to captialize on is sharing experience with other Lisp people
| about the common foundations.  You can hardly blame me for that.

  I can blame you for not inviting people into your little pond to discuss
  them there, and that is what I do.  Go back to comp.lang.dylan and talk
  about your favorite Dylan things there.  Invite Lisp people to your forum.
  Obviously, you know that this will fail to have any desired impact, and
  still you have not figured out why Scheme people talk negatively about
  "Lisp" and positively about "Scheme".  Pretty amazing, really.

| I don't believe that *a* right answer is *the* right answer.  It's
| hard to find out how you read that from my above comment.

  Really?  A moron who finds evidence of religion at the drop of a hat has
  problems figuring out how his own arguments look to others.  Dude, how
  have you managed to stay alive so long?

| It's just that I don't think that *a* wrong answer is *the* wrong answer,
| for precisely the same reason.  That's what I have written above, and it
| would suit you well to address this argument, instead of handwaving.

  If _a_ wrong answer was _the_ wrong answer, it would mean that every
  _other_ answer would be right.  Such is the implication of "_the_ right
  answer", but I am not surprised that you do not get this.  I think I have
  had enough of your idiocy, now.  You clearly cannot think under pressure,
  much less logically, so I asusme that your brain actually only functions
  when your ego is massaged sufficiently, so it can only be used when you
  feel safe and secure.  That is pretty useless -- thinking hard should be
  most available because it is most _useful_ when you are under pressure.
  You are not even smart enough to hold back from posting until you can
  start to think clearly.

  Dylan seems to breed idiots faster than it breeds applications.

I'm interested in learning the facts of what the differences are between
CL and Dylan, and what the reasoning is behind those differences (from
both sides), and to then make my own judgements about whether anything
of value has been lost in creating Dylan from CL.

Please note that I'm posting in the generic "Lisp" newsgroup, not a
specialized one for Common Lisp such as c.l.clos.

This has no bearing on the question here being discussed, of "nil qua
false".

Every time I or Andreas or someone else is interested in learning about
and comparing the way CL does something with the way that other
langauges do similar things, you for some reason I don't fathom
immediately think that they want to *change* CL.

Quite apart from being false, it is a preposterous idea to imagine that
I have the *power* to bend the CL standard to my will even if for some
strange reason I *wanted* to.  I would never have thought of it as a
possibility.  I'm astounded that you seem to think it's a possiblity.

Astounded.

Furthermore you don't seem to acknowledge the fact that value is
always relative to people.  Things aren't of value in themselves.
They are of value, because they are valued by someone.  People often
don't agree on what they value.

Some people have stated here that they do value that (eq 'NIL '()) in
CL.  You obviously don't value such a thing.  So, lucky you that Dylan
does what you value [leaving aside the question that it isn't the
other way around (for all of us)].  CL provides what I value.  Now
that we are aware of the fact that we value different things, can we
move on?

Ah, but we can't, because you need support for your view that Dylan
didn't leave out anything of value from CL.  Maybe we could get the
current NCITS/J13 to publically declare "Dylan has everything that was
good and great about (Common) Lisp, left out all the crap.
Furthermore it wasn't designed by some steenking Committee, so
therefore we declare the whole Common Lisp standard superceded by
[insert Dylan "standard" here]".

Maybe this would get the world to finally see that Dylan is the way
forward, and everything else is just the delusional ranting of people
who just have the _wrong_ values.

Regs, Pierre.

Your hash of integers is presumably the concrete implementation of some
abstraction.  This implementation might some day change as you realize
that another implementation technique has better characteristics.  So
you don't want to have client code explicitly depending on the
representation.

There is also no reason to suppose that 0 is always the appropriate
default value for a numeric value -- that depends on the abstraction
being modelled, and perhaps on considerations such as minimizing storage
usage by avoiding explicitly storing data for the most common case.

What I would do is to write a getter and setter that do the right thing
for the domain being modelled, and get them hooked into the
GET-SETF-EXPANSION mechanism.  The getter might be as simple as
element(a, b, default: 0).

- "collect" clause in the loop macro ("for" macro in Dylan)

- incf/decf.  The Dylan ":=" is equivalent to the CL "setf", but Dylan
lacks incf/decf in particular and the C'ish modification operators ++,
--, +=, -=, &=, |= etc in general.  I miss this.

[rest snipped as flowing from an incorrect premise]

You came here and proclaimed that CL seems to have a problem because it does
not distinguish nil/false/'() and Dylan has done this better. You then *got*
your answer that no lisper here ever had any problem with this issue and
that it is even counted as a feature in some contexts. But instead of
learning from that, you annoy people by insisting that lispers should have
a problem if they think so or not only because you think it fits your bill
and CL is wrong and Dylan is right completely forgetting the fact that only
the community itself is able what is counted right or wrong.

You criticize that this facility is restricted to lists while Dylan has all
this generic container stuff - completely forgeting the fact that lists are
of *much* higher value in a language that got not crippled by omitting
s-expressions.

One thing you both seem to completely forget is that your silly little
language-war is really a disservice to Dylan. Many lispers may try out
Dylan from themselves but if they get insulted and annoyed by some language
fanatics I think the chance for that is quickly decreasing against zero.
(This is at least the effect this discussions had to me so far...)

Jochen Schmidt

I don't want to change CL.  I certainly don't have the power to change
CL, even if I wanted to.  It is, as you say, "done".  Fine.  Can we
please move on from this false premise?

What I want to do is to *understand* CL, just for my own pure
intellectual curiosity.  I want to know not only what *is* in CL, but
*why* it is.  If there's a logical reason then I'd like to know it.  If
there are special advantages conferred by something that make certain
things easier to do then I want to learn about that too.  And if
something is just historical accident and it hasn't been judged worth
the pain of changing then that answers my question too.

Far from wanting to change CL, what I want to do is to see if there is
anything that should be changed in Dylan.  And *that* I believe I have a
strong chance of doing.  I can implement new things in CMU Gwydion
Dylan, try them out, and if they work well there is an excellent chance
of them being propogated to the other implementations.

Andreas

Thomas F. Burdick made that claim, purely about CL with no reference to
Dylan, in <xcvpu6bvky7....@conquest.OCF.Berkeley.EDU>.  I later came
into the thread to offer my experiences and thoughts.

* Andreas Bogk
| Well, it extends to a general dislike against any use of inband
| signalling in a lot of other contexts.

  Where did this "dislike" come from?  When does your "dislike" begin?

  I would have assumed that you dislike everything that computers do with
  that attitude, since they practically _embody_ the principle of inband
  signalling these days.  Digital transmissions practically _forbid_ real
  out-of-band signalling -- it is all done by in-stream encapsulations and
  encapsulation these days, precisely what "in-band" refers to.  Sheesh.

| This is based on observation of the problems (especially security
| problems) of software that violates these rules.

  Ah, the good old argument from "my experiences of fear and pain", again!

  The best solution to some people's severe personal problems with all
  things painful is simply to ask them to increase their pain threshold --
  nothing else will actually help.  Wimps and whiners will never amount to
  anything in a world where the expectation that everything be painless is
  routinely disproved.  An experience of pain means that _you_ do something
  wrong.  If you are the arrogant type, you will blame somebody else for it
  or the universe in general if you are _real_ idiot, but arguments based
  on "it hurts, so I won't do it" are actually _wrong_.  It was _not_ what
  you did that made it hurt, except in such trivial cases that you never
  talk about it.

  If you design crappy software and something dies on you, the cause is not
  because the language violated some stupid rule of in-band signalling --
  it your own, personal ineptitude that was the cause and your own goddamn
  fault for not being able to deal with it when you implied to yourself and
  the computer and your superiors that you could.

| So anybody who thinks that CL is better off violating this rule either
| doesn't believe in it, or believes that there are more important rules.
| In both cases, I am curious to know why.

  Or they do not actually violate it, because you are simply _wrong_.

  Your failure to grasp what you want to accuse others of is repeated with
  an alarmingly high frequency, and it seems to be increasing rapidly when
  you are chastised for it.  The world is not at fault for not obeying your
  rules.  You _really_ need to grasp this.  Rebellious idiot students could
  perhaps get away with such cluelessness in the late 1960's, but rebelling
  against the authority of a programming language standard is simply _nuts_.

  You _know_ this kind of thing?  You show no evidence of doing so.

  This is stuff that is _measurable_ and which has been studied over and
  over.  "Cognitive load" is actually a well-known phenomenon, and it is
  one of those things for which ignorant newbies are _not_ the standard by
  which everything is measured.  When I said "as a matter of fact", I did
  not mean your kind of fact, I meant _fact_.  Do you understand this?

  I also demonstrated that (empty? foo) is the _wrong_ replacement, that
  empty? must be true of much more than lists, but that none of these are
  false.  In other words, you are just _wrong_.

  People who are psychologically prevented from accepting anything that
  other people tell them is the rules they have to follow, will get upset
  for no reason about _their_ "rules" being violated.  This is _curable_,
  but not by changing the rules in long established standards.

| Using the former when meaning the latter fails to communicate the intent.

  The former means that one is testing for a non-nil value.

  You are testing for "a non-empty something".  You have misunderstood the
  intent and this causes you to communicate something else.  Most of your
  conclusions come from making similar mistakes and not listening when
  people tell you to pause and think.  This makes you look _tremendously_
  retarded to those who _do_ know.

  This is actually wrong in Common Lisp.

  It might be right in Dylan, but it goes to show how Dylan is _not_ a
  Lisp, that you are not discussing this in the proper forum, and that you
  are not listening when people talk to you.  If nothing else, this alone
  makes you stand out like a prize moron.

| Too bad this isn't true for the (when foo) case, it only works for lists.

  You demonstrate only your arrogance from ignorance

  I am a little amazed at your lack of will or ability to introspect.  You
  are reacting in a way that demonstrates that you do not listen at all,
  but react only to what your "impressions" tell you is happening.  This is
  the modus operandi of prejudicial _idiots_.

| By the way, please forgive the use of the Dylanesque empty?.  I'm so used
| to working in a language where I can express operations on collections
| independent of their implementation that I completely missed the fact
| that there is no empty? in Common Lisp, and that it can't be implemented
| in a way that would have equal performance to (when foo).

  Yes, paying attention is evidently too high a price for your arguments.

  Maybe you will pay more attention in the future?  That would really help.

  Why go to such lengths to confirm what I just said about you?

  Why do you think your extraordinary ability to generalize from painful
  experiences produces _true_ or _useful_ results?  You do not even seem
  able to recognize that having been to "some meetings" does not give you a
  right to conclude _anything_.  This implies that you think the painful is
  the normal, and that there is nothing you can or should do about it.  And
  that explains why you dig yourself in deeper all the time, too.

  Part of the ability to generalize correctly is the ability to weed out
  exceptional situations and not confuse noise and signal.  If you think
  what you have observed gives you grounds to believe it is the _normal_
  situations, you are as mistaken as you are about this forum.  You simply
  do not get normal reactions when you poke people in the eye, and you
  _should_ be able to understand this.  However, I doubt that you are.

| I've only been using programming languages for the last 14 years, and
| I've only been studying programming language design for the last 5 years,
| so I'm certainly neither the most experienced language designer nor the
| best.

  Yet such incredible immaturity after so much experience is _alarming_.

  No.  Reading comprehension is not your strong suit, is it?

  Does your dysfunctional brain realize that as you go wrong with such a
  mindless accusation, you need to try something else, or will you just
  think you have proved your argument _because_ I deny it?  Really stupid
  people tend to consider their prejudices proved the stronger their victim
  objects, proved when the victim does not object, and proved when they
  agree.  That is what stupid prejudice is all about.  You sound like one
  who suffers from this particular problem and post your stupid prejudice
  because you think this will win a debate for you, when what _would_ have
  helped is simply using your goddamn brain to _THINK_.

  Smart people recognize other smart people.  Stupid people do not.  This
  means that failing to understand one's "ranking" is an indication that
  one is stupid below an important threshold.  Your persistent failure to
  read what people write accurately, however, is a pretty good sign you are
  a very unobservant person in general.

  You are not most people, nor do "most people" hate me, you dipshit.

  That you are not most poeple _should_ be an important realization for
  you.  You cannot extrapolate your experiences to other people, not in
  normal situations, and especially not in abnormal situations.  Every
  argument that appeals to statistics about what other people think are
  ipso facto _invalid_ and merely tells others that you are immensely
  stupid.  But you will not understand this, either, will you?

  But you seem to reject the answers you get!  You keep asking even when
  you get the perfectly honest and full answer.  That is the insanity.
  Despite what you say, you do not appear to be satisfied with the truth.
  In other words, you communicate that you think people are guilty of
  hiding something from you, and that is actually _very_ offensive.

| If there's a logical reason then I'd like to know it.

  You, too, seem to think that you can have logic without premises, or at
  least different premises from what _you_ have.  Why is that?

| Far from wanting to change CL, what I want to do is to see if there is
| anything that should be changed in Dylan.

  Then why are you not discussing this in comp.lang.dylan?  And why are you
  talking about how Dylan does things all the time if you want to change
  Dylan?  Sorry, this does not compute.

  But why are not posting in the specialized comp.lang.dylan?

| > | Are you saying that you're brighter than Moon?
| >
| >   Please think about what you are _actually_ saying.
|
| What I'm _actually_ saying is that the argument "CL was designed by
| genuises, you're not one, so shut up" is not useful.

  Nobody has ever said anything even remotely similar to that, and it is
  offensive to attribute such rampant idiocy to people just because _you_
  have a hard time coming up with intelligent arguments.  That you see the
  world in such terms is something you just have to discuss with someone
  who cares.

  And if that _idiotic_ line of yours was not whining, nothing is.

  Easy.  Just be a moron.  You do a good job of this so far, toghether with
  that other Dylan lunatic, so it is not particularly unlikely that you
  actually are illogical farts who have come here only to annoy people.