Subject: Re: why we have cons?
From: Erik Naggum <>
Date: 1998/01/06
Newsgroups: comp.lang.lisp
Message-ID: <>

* Xah
| I wasn't complaining, nor was I arrogant.

  OK.  if you say so.

| Comparing our posts in this thread, I think it's fair to say you are the
| one complaining and arrogant.

  I think it's fair to say that you don't listen to what people tell you.
  if there is a definition of arrogance, it must include such behavior.

| I was just trying to illustrate how they are uniformly represented in
| Mathematica.

  it seems that you don't differentiate between what something looks like
  and what it is.  how something internal is shown to the user is (often)
  called the "presentation".  how something external is implemented
  internally is (often) called the "representation" since we're talking
  about using concepts and means different from the ones we're trying to
  _represent_ and making them take on the meanings we want, as something
  essentially very different from what they _are_ per se.

  e.g., a machine word is just a number of bits.  we _represent_ an integer
  with them by multiplying each bit by a weight according to its position
  in the word and summing the results.  we _present_ this machine word as a
  string of digits to the user when the user has decided that a particular
  machine word is to be used as an integer.  then we ignore the number of
  bits in a machine word and talk of integers that may require any number
  of machine words (as many as are necessary to maintain the bit with the
  highest weight) as an "integer".  this is a successful abstraction.  is
  it inconceivable to you that somebody might want to know about the value
  of a particular bit and thus would have to know about the weight if he
  could not view the integer as a number of bits?  now, ask yourself what
  you would do in a language that hid the implementation of integers as a
  number of bits: you would have to _recover_ the implementation.  Common
  Lisp has a function `logbitp' which reports on a bit value by position.
  is this as much a no-no as the cons cell to you, or can you think in
  terms of integers as values even though `logbitp' exposes internals?  I
  know I can think in terms of both integer value and bits at different
  times even though there is no difference to the computer.  that's why I
  talk about using `first' instead of `car' when the object is a list, and
  using `car' instead of `first' when the object is a cons.  do you get it?

  however, since you keep clamoring about how Mathematica _represents_ this
  and that, I must assume that you don't listen to what you're being told.
  you don't _know_ how Mathematica _represents_ anything at all, since you
  aren't allowed to look inside it, right?  so you confuse user interface
  with implementation.  this is sheer ignorance, and it has not abated one
  millimeter since you asked to be illuminated.  if you were blinded by the
  strong light, you could still have been illuminated, and there are other
  ways to express this than those you have chosen.  I do get both irritated
  and sometimes downright hostile to "newbies" who don't want the answers
  they get because they didn't understand the questions they asked.  I did
  try to be helpful and set the stage for your illumination, but _noooo_,
  you rejected all helpful offers and were instead _only_ offended.  in
  contrast, I do something useful when I'm offended, but I don't turn off
  the irritation, because I think people who are irritating should be told.
  I very rerely flame people without solid technical contents alongside it
  that also indicate that flaming will cease if they get the ideas.  if you
  can't see this, don't blame me for it.  you choose what you react to just
  as much as I do.

| It is apparant to me that no one so far indicated a familarity with
| Mathematica.  Otherwise, the context of my question would be recognized
| clearly without doubt.

  this is another clear indication of your arrogance.  you came to us to
  tell us that some notion of ours was redundant.  you're wrong.  then you
  tell us that it's our fault that we don't agree with you because you are
  ignorant of Lisp and you accuse us of being ignorant of whatever you
  think is ideal.  (but don't you listen?  ideals are _never_ universal,
  because they depend on the ideas they are embodiments of, and those ideas
  differ according to context and individual preferences.)

  if somebody had come to your ideal Mathematica world and made as much
  fuss about the implementation of lists as you do in Lisp, what would you
  have thought about them?  could you please try to listen to what you're
  saying as you best can imagine it would be heared by those you talk to?

| (now, is there a limitation to the caadadadddaadr length?)

  in the predefined functions, c[ad][ad][ad][ad]r is the longest it gets.
  you are free to define your own, longer names, if you so desire.  the
  _usefulness_ of this is highly debatable, however, since you should name
  them according to your needs, not according to the implementation.

  but why _does_ this implementation issue bother you so much?  I get the
  distinct impression that you cannot think in higher-level terms unless
  the lower-level concepts are removed from out of your sight.  you even
  accuse _me_ of such a shallow-minded attitude, when it is instead obvious
  that you don't make _any_ effort to understand what I'm talking about.  I
  have shown you that by a switch of names, your problem would go away, but
  you still continue to hang on to your confusion and insistence that we
  should listen to your misguided "ideals".  _why_ don't you listen?  do
  you suffer from prestige?

| In Erik's last message arguing point-for-point style to my message, many
| points are really pointless, philosiphical, and cheap shots.

  I'm really sorry, but you have to realize that the questions you asked
  just don't have the answers you want them to have.  so, some of them will
  _have_ to be answered philosophically because you don't understand the
  philosophical underpinnings of your questions, only the implementation
  issues that you are used to from Mathematica.

  consider this: it's an artifact of the implementation of the Mathematica
  language that causes you to believe that there is not a cons-cell-based
  implementation underneath, and an artifact of the implementation of lists
  in Scheme (and CL) that causes you to complain about the implementation.
  whether to provide access to lower-level aspects to an abstraction is
  _not_ a language issue, but an implementation issue.  whether to focus on
  the implementation issue instead of the abstractions they implement is a
  user attirude issue, not a language issue.  when you ignore the fact that
  there are other artifacts of the implementation that any reasonably good
  Lisp programmer would employ that would not expose the implementation,
  you argue very strongly against yourself -- you really want to deal with
  an implementation issue: "how much of the internals can an implementation
  show before it bothers Xah to death?"  I don't ask that question.  I ask
  the question: "how little of the implementation do I have to worry about
  if I want to worry as little about the implementation as possible?"

  you claim that you don't want to think or talk about the implementation
  issues, but you talk of nothing else!  now, quit that.  talk about the
  abstractions you want to talk about.  _I_ have written (at length) about
  the fact that you _can_ think in terms of the abstractions regardless of
  how the list abstraction is implemented.  you have _ignored_ this and
  focus only on whatever you don't like, so I have revised my opinion of
  you.  I think you are beyond hope and that your arrogant ignorance is
  really due to stupidity.  I also think it was stupid of you to force me
  to revise my opinion of you.

| In summary, I think he is too deep into computer engineering than
| computer science, and too enamored with perhaps CL.

  well, you have demonstrated that you can't think, so it's immaterial what
  you say you think, but let's hope that you will take the time to listen
  to what I have said, instead of what your narrow-minded reactions tell
  you to ignore.  you may find that I did lend _you_ a hand while I slapped
  your ignorant comments (did you notice how I differentiated between your
  state of mind before and after reading my explanation?).  you stupidly
  decided to behave as if _you_ were slapped, and now you return with
  moronic accusations that portray your own _obsession_ with implementation
  issues, quite contrary to your stated interests.  whatever did you expect
  to achieve from all this?

  if you want lists, you have them.  if you want to be bothered about cons
  cells, that's your choice.  I suggest you don't get bothered by them.

The year "98" was new 1900 years ago.  |  Help fight MULE in GNU Emacs 20!
Be year 2000 compliant, write "1998"!  |