Subject: Re: ACL 6.0 Trial Edition ships with non ANSI reader behavior.
From: Erik Naggum <>
Date: 2000/11/05
Newsgroups: comp.lang.lisp
Message-ID: <>

* John Foderaro <>
| All developers at Franz work in a case sensitive lower case Lisp
| (i.e. now called a Modern mode lisp) yet all our code works in  an
| ANSI (upper case) lisp (except that just recently code to  interface
| with case sensitive things (e.g. XML and Java) doesn't work well in
| ANSI mode, but that's off topic for this discussion).

  There is nothing in the case sensitivity of these languages that
  requires a that a case-insensitive reader be killed.  We have been
  able to work with case-sensitive readers for a very long time -- it
  really is no big deal.  When you lower-case all the symbol names,
  you make that much, much easier for all of us and I thank you for
  this, I really do, but I hate you for breaking the standard in the
  process when that is so _obviously_ unnecessary and a hidden agenda
  against the standard and the committee sticks out like a sore thumb.

| Why don't we set readtable-case to :preserve in a Modern lisp?  It's
| because that would harm the ability to import ANSI code and make it
| work in Modern mode as well.  It would make it harder to write code
| that works in ANSI and Modern modes.

  *boggle*  You have _broken_ readtable-case so it is hard-wired to
  :preserve no matter what it reports or I set it to.  If what you are
  saying is true, then _you_ have harmed the ability to import ANSI
  code and make it work in Modern mode as well by doing that.  Except
  you aren't telling anyone about it, which you would if you did make
  that change.

  What you're saying is pretty obviously false, but by now I realize
  that I'll never get through to you, which means I shall have to
  fight _against_ your Modern mode.  Pretty stupid move, John.  I want
  lower-case symbol names.  I want a case-sensitive reader by default.
  I _don't_ want to have to get rid of the case-insensitive reader in
  the process because I actually _need_ that functionality, but since
  you force me to accept that package deal, I simply _cannot_ work
  with the stuff I want, and I'll have to go back to the only mode in
  which readtable-case actually works as standardized.  What _are_ you
  so bone-headed about this?  What _would_ it cost you to keep within
  the standard on the rest of these issues?

  If you had set readtable-case to :preserve, which is its real value,
  anyway, the standard says to ignore all the other case settings,
  which is also precisely what you do, so the Modern behavior is all
  _within_ the standard.

  If people set the readtable-case directly, they know what they are
  doing.  If they want to read Lisp data in standard syntax, which is
  but one _effect_ of choosing :upcase, they are supposed to use the
  macro with-standard-io-syntax, not roll their own just because they
  can.  That would be a violation of intent, and Kent Pitman has made
  a very good point about accidental truths and necessary truths.  It
  is a _necessary_ truth that if you use with-standard-io-syntax, you
  will be able to read Lisp code in the standard syntax.  It is an
  _accidental_ truth that you may be able to do so if you set the
  readtable case to :upcase.  This is f*cking obvious.  Why do you
  fight this and refuse to get it?  What do you gain by antagonizing
  the standard and me and everybody else who would like to seee a Lisp
  with lower-case symbol names, a case sensitive reader, but still
  have the _choice_ we have come to love about Common Lisp?  What _is_
  it with you that makes you work so hard to remove that choice?  It
  really and truly does move the choice in a particular readtable with
  case-insensitive upper-casing behavior to a choice in Modern or ANSI
  Lisp, and that is not the choice I want to make just because I want
  a simple, straightforward, well-defined functionality in ANSI CL
  _with_ your new decisions, and there _is_ no technical reason you
  don't want to give it to me.  It's _political_, and although we have
  one of those "choose the idiot with the nicest teeth in his grin"
  contests right now, that doesn't mean I'm willing to buy any package
  deals based on similarly irrelevant criteria.

| The reason that it would cause problems is that it brings
| readtable-case into play in Modern mode.

  So you have created another, global, variable instead with exactly
  the same semantics as the readtable setting, forcing people to fuck
  with that instead of the standard interface to the reader for no
  other reason that you historically hate the decisions that led to
  their inclusions.  Good stuff for religions.  Bad engineering.

| ANSI code may create a readtable, and then set its case to :upcase
| so it can read in some data that it had written before.

  It may _also_ create a readtable and set its case to :upcase because
  it really wants the symbol names in upper-case.  You disallow that.
  I'm not objecting to what you have achieved.  I object to the fact
  that you force me to duplicate functionality with non-portable code
  for no good reason only to achieve what I used to achieve: upcasing
  symbol names in the reader.  Because of your obnoxious and personal
  dislike of the case stuff in ANSI Common Lisp, I have to redo what
  is supposed to be in there for those uses where case-insensitivity
  is well-defined and actually useful.  I'm beginning to hate your
  decisions on case for _that_ reason, not because you try to preserve
  some other property of the environment that I disagree with.

  If you have to break something to get something so fundamental and
  relatively simple changed, you're guilty of bad engineering, as in:
  Changing the world before you change your tools.

  What kinds of written data would your claim actually work out on?
  Because you have ripped out the case-translation in the reader, it
  would have to be all lower-case in the _input_ to get the right
  symbols, but that is _not_ the canonical case, so you end up with
  all upper-case symbols, anyway, since that _is_ standard, as in:
  produced within the body of a with-standard-io-syntax form.

  What you could do is take this back to the drawing board, declare
  yourself unfit to make technical decision because of too much
  personal involvement, and let other people find ways to reach all of
  your (technical) goals while breaking none of other people's goals
  and needs.  That is what mature standardization is all about, and
  that's how mature people interact when they have conflicting needs.
  You may think you won't find enough lower-case-friendly people to
  get the committee around if you had to, but that is _irrelevant_.
  You're already going ahead to implement something outside of the
  standard, so you should _minimize_ (as in: _good_ engineering) the
  effects upon the rest of the system with your change.

  E.g., with-standard-io-syntax should print in lower-case, escape
  upper-case letter in symbols (no harm done in case-sensitive mode)
  and lower-case symbols on input.  Just reverse the case in a fully
  consistent, predictable way and you'll be surprised how little of
  the language and environment actually _does_ change.
| This isn't going to work in Modern lisp since standard symbols are 
| in lower case.

  So the readtable-case has to be :lower, instead, because symbols are
  now all lower-case.  Big deal.

| So when porting you're going to have to search for all uses of
| readtable-case and insert conditional code to make it work in ANSI
| and Modern mode.

  *boggle*  What?  Excuse me?  You cannot possibly be serious, John!

  We have with-standard-io-syntax to get standard syntax.  If people
  meddle with the readtable-case, they do that on purpose and must
  accept full responsiblity for it.  No need to look for anything.
  Their settings correspond to their input requirements.  If they set
  :upcase, they will look for symbols with upper-case names and they
  will have interned them with upper-case names, and if they are not
  the complete morons you expect them to be, they will write code that
  names them in all uppercase, too, simply because that is so much
  less confusing to the reader of the code.  (We agree fully that it's
  a royal mess to deal with case translations in your head while
  reading the code.  Case sensitive makes maximal sense across the
  board, but that's _code_, not input from the outside world.  You are
  _reversing_ the code-is-data paradigm of Lisp with this move, John!
  You force me to treat external data as if it code, but it's really
  the other way around: It is code that I may want to treat as data.)

| The conditional code has to be runtime and not compile time
| conditional since the decision as to which mode to run in is made at
| runtime and a given fasl file can be compiled in one mode and run in
| another.

  I wonder who you think you're fooling with this joke of an argument.
  I wonder if you realize how much you insult people's intelligence by
  pretending that this is valid reasoning that they are supposed to

  You have made a number of decisions that impact the effect of your
  desire to change the symbol-names to lower-case and the reader to
  case-sensitive.  Those decisions are obviously not disconnected and
  the effect upon the whole system that you detail so painstakingly
  tell me one thing: They were made with blatant disregard for the
  standard and the possibility of operating _within_ the it to the
  extent this is possible with such a change.  _Obviously_ you then
  end up with a design that has disregard for the standard built-in
  and fundamental to it.  You could have made different decisions and
  that is what I urge you to make.  Go back and fix whatever it is
  that you did that caused this important aspect of Common Lisp to
  break for no good reason just because you want to switch the case of
  the symbols.  You're normally an excellent engineer, John, but this
  stuff is as silly as it gets.  I have seen your work and I'm truly
  impressed with what you can do when you set your mind to it, but I'm
  equally unimpressed with what you do when you set your mind not do
  something.  I can be a stubborn son-of-a-bitch myself, but at least
  I can be shown to be mistaken or have my assumptions challenged and
  then I'm a son-of-a-bitch with the new position, instead.  I pride
  myself with that combination of qualities.  (We shall hear from Xah
  Lee, shortly, of course.)

| So what we did with set-case-mode is akin to setting up a virtual
| machine.  If you run in Modern mode your program still sees
| *print-case* set to :upcase and readtable-case set to :upcase and
| happily goes on it way, thinking that it's running in a normal ANSI
| lisp (unless it checks the value of *current-case-mode*).

  Except that every time it looks at symbol-names as strings, it gets
  the wrong results because you lied to it.  Since people often make
  the mistake of hard-wiring case into their code and do not follow
  the fairly simple rules that Franz Inc has set for their code not to
  _know_ the case, there is simply no way you can win with such people
  and consequently it is irrational to try.  The problem is that those
  who do _not_ hardwire the case into their code might still want to
  know what to expect from the reader by _querying_ it for what it
  does, in that portable way that you hate and fight.  And then you
  lie to it, pretending to be something you aren't: in ANSI mode.

  Really portable ANSI Common Lisp _will_ query and set the readtable-
  case because it is a known factor of the language.  That is what you
  break, simply because you don't _want_ that factor to be there.
  This is not only irrational, it is hostile to rational programmers.
  This is just like that dumb-ass politician who tried to come off as
  a Latino by changing his name in the campaign to get Hispanic votes.
  Just how dumb does he think those people are?  Just how dumb _do_
  you think people who actually respect the standard on its case
  issues are, John?  Is that why you show no respect for them?

  I'm telling you just how _unhappily_ my code goes on its way when
  you broke readtable-case for me so case translation no longer works.
  If you tell me to go fuck myself because I'm unhappy about this, I
  have no choice but to be your worst enemy in this case business when
  we have very similar goals, except I don't have an urgent personal
  need to piss off the Common Lisp committee because I don't think
  they did such a terribly evil thing as you think they did.

| I can only state that 20 years of experience has show that this kind
| of thing works.  I've yet to find a single ANSI program that I can't
| import and make work in both ANSI and Modern modes.

  Don't piss me off with bullshit like this!  Damn it!  If this is the
  level of respect you have for me, you can go to hell, John.  If you
  think I'm making up this story about needing readtable-case :upcase
  (or :lower, for that matter) because I'm processing Lisp data and
  _want_ it to be case-insensitive and you're telling me that you have
  never met an ANSI Common Lisp program that didn't want case not to
  matter for its Common Lisp or Lisp-like input, _your_ credibility
  has hit an all-time low, way below several presidentail candidates.

| So  while what we have may not be pretty, it does the job that it
| was designed to do.

  Really?  So what I'm telling you that I need was explicity excluded
  by design so I can't get those two nifty things you did that I want,
  namely lower-case symbol names and the _choice_ of a case-sensitive
  reader?  I had the choice, I wanted the lower-case symbol names.
  You gave me the lower-case symbol names but took away the choice.

  As we had a choice with upper-case symbol names, how come we can't
  have a choice with lower-case symbol names?  You admit to the fact
  that you can write code in all lower-case and have it compile in
  both modes -- in fact you boast about this.  What would change if
  you only changed Common Lisp from upper-case to lower-case symbol
  names and adjusted the relevant settings accordingly?  _NOTHING!_
  (Or probably "_nothing!_".)  You would be able to do exactly what
  you have been doing in a Lisp with upper-case symbols.  The reason
  you make a big stink about this is that your way of dealing with a
  lower-case Lisp was _designed_ to piss off the people you still bear
  a grudge against for what you see as a major screw-up in the
  language standardization process.  Get the hell _over_ it, John.

  There is _no_ technical reason why we can't just flip the case and
  make the necessary changes as they propagate through the standard to
  get this right.  Moreover, a position _in-between_ the two extremes
  would work for far more people than your bone-headed, political
  position: case-insensitive-lower, or just what a readtable-case
  value of :lower instead of :upper would do in a Common Lisp with
  lower-case symbol names.

| If the decision hadn't been made to make Common Lisp case
| insensitive upper (and I tried my best to stop it), then there
| wouldn't be *print-case* or readtable-case in the language.  They
| are just kludges to fix a botch in the language.

  Yes, this is definitely your real agenda.  You _are_ breaking the
  language on purpose because you think it has a kludge to fix a
  botch.  That's stupid of you, John, just plain stupid, and it's on
  purpose, too.  You have made up your mind to be stupid and annoying
  and obnoxious about this issue instead of getting what you want:
  Lower-case symbols and a consensus about it.  I fear that the reason
  is that you think the people you imagine yourself up against are
  criminally insane and so you cannot use what they opened up for.

| If you really think that you want case transformations in the reader
| in Modern mode then we have to do them in a different way (i.e. a
| different function name would have to be involved (e.g
| readtable-case-modern) so that it didn't ruin the virtual machine
| effect we've got going.

  This may come as a surprise to you, but you don't _have_ a virtual
  machine effect.  It works only as long as the input obeys the very
  strict protocol that Franz Inc code obeys.  What we actually need is
  something that works _well_ for people who don't work at Franz Inc,
  too, and they are more than very likely to think the standard ranks
  higher than your/company coding standards.  Sorry about that.

| And to implementors of other lisps: I  encourage you to add support
| for a Modern mode in your lisps as well.  If I can help you achieve
| this send me email.

  Oh, God, please don't.  Don't ask John.  Get it right, instead.

  Just flip the case, change all the corresponding references to
  :upcase in the standard to :downcase, and let the abstraction
  represented by with-standard-io-syntaxa work its magic with
  lower-case symbols and a case-insensitive reader first, then add
  case-sensitivity or let people make that choice as _they_ see fit
  and have had time to work out the effects of the case change, if any
  -- I doubt there will be many.

  Let me wax political, too: I urge all Franz Inc customers to write
  to them (on real paper) and request that they continue their work on
  a Common Lisp with lower-case symbols and work to continue to make
  Common Lisp case-sensitive about it over time, but in exactly the
  same way Common Lisp has upper-case symbols today.  Appeal to their
  sense of evolution and bringing together a community, instead of the
  splinter group revolutionary attitude that only threatens to bring
  people into awareness of which "faction" they must belong to and
  which to fight against.

  Does anyone remember where I parked Air Force One?
                                   -- George W. Bush