Subject: Re: ACL 6.0 Trial Edition ships with non ANSI reader behavior.
From: Erik Naggum <>
Date: 06 Nov 2000 01:51:07 +0000
Newsgroups: comp.lang.lisp
Message-ID: <>

* John Foderaro <>
| I'm too shell shocked to know where to begin so I'll just go back
| a bit and reiterate that the goal our our case mode switching code
| was to painless permit ANSI code to be imported into Modern lisp.

  I don't see the point of that if it means I can't use Modern Lisp to
  write ANSI CL conforming code.  But the whole point of this exercise
  is that I'm not supposed to write ANSI CL conforming code, anymore,
  is it not?  At least as far as case is concerned, anyway, because
  _you_ think the ANSI standard should be disregarded on that count.
  If you consider this something a friend would do to a friend, _I'm_
  shocked -- screwing a basic trust is how you _create_ enemies.  If
  you haven't known about my strong stance on the standard that first
  we implement it faithfully, accurately, and completely (during which
  we shall learn about many problems that need attention), and then we
  make changes that _do_not_break_ it, but navigate within the space
  charted by the standard.
| Likewise telling people to change their code to use with-standard-
| io-syntax rather than hacking readtables would be possible but would
| make the mode less popular.

  So why are they hacking readtables?  Is it because they don't know
  about with-standard-io-syntax?  

| It may even prevent some code from being ported.

  I'd like to see the kinds of code that is portable and the kinds of
  code that is not portable.  I have shown you one particular example
  that is not going to work in your new setup because you break the
  functionality of readtable-case.  Still, you keep telling me that
  you don't give a flying fuck about my needs.  Is that how you tell
  your friends they are your friends?  Let me know when you understand
  that I'm pissed as hell at what you have wantonly and needlessly
  _broken_ so I can't get something I want very much: lower-case
  symbol names.

| The current situation is that most people out there are using  lisps
| in ANSI mode and producing ANSI-only code.

  Precisely, and they would query readtable-case for its correct value
  if they know ANSI Common Lisp.

| At Franz nearly all of our code works in ANSI or Modern mode.

  I'm telling you it would work if you didn't break readtable-case,
  too.  Why are you not getting it, JohN?

| There are probably some people developing in Modern-only mode (we
| see messages from them on occasion).

  And what does this mean?  "Modern-only"?  It does _not_ mean just
  lower-case symbol names and a case-sensitive reader.  It means using
  some language that is _gratuitously_ different from Common Lisp as
  defined in ANSI X3.226-1994, simply because you have the chutzpah to
  think you can get away with breaking random parts out of personal
  likes and dislikes.  That's not how we operate in the civilized
  world -- either we think the law is the law and we don't break it
  even if we disagree with it, or we make that crucial decision to
  disregard the law and just do whatever the hell we want and hope to
  get away with it.  I don't deal with criminals, John, and I don't
  deal with people who tell me that they have a product that conforms
  to a standard that is being undermined and destroyed by that company.

  You are very, very close to becoming a vendor that has made that
  crucial decision to scream "fuck the law and the standard!" and go
  your own way because you think you can.  This isn't about some case
  cruft, John, this is about whether Franz Inc has started to think of
  itself as so powerful that the standard doesn't matter, anymore,
  that personal animosity towards some parts of the standard and the
  people who made it shall be more important than the contractual
  obligation you have to supply your customer with a conforming ANSI
  Common Lisp implementation.

  We all know that Franz is the biggest remaining Common Lisp vendor,
  and we all know that whatever you do is watched very closely by the
  whole community precisely because you can endanger people's work and
  our future reliance on the community effort of standardization.  If
  you decide to be renegades, say so.  If you think carefully about
  what you are doing and decide that it is in the best interest of
  both the Common Lisp community and Franz Inc that you stick to the
  standard as much as we can, however you feel about it personally,
  you will most probably be able to get people to join your movement.

| What I'd like to see is a movement toward Modern mode.

  That's one thing we agree on.  So far, you have alienated me.  I
  hope to have caused a lot of people to regard the bogus ways you
  have decided to implement your Modern Lisp as something that they
  should _not_ follow, but rather should fight until you listen to
  your customers and your contractual obligation to provide people
  with a conforming ANSI Common Lisp implementation.

  As it is, your first move towards Modern Lisp was to break the Lisp
  reader's case conversion.  You would like people to move away from
  ANSI Common Lisp towards Modern Lisp, which translates to one thing:
  You are hell bent on ignoring people who actually want the standard.

| I'd like to see other lisps support it and I'd like people to start
| making their code work in ANSI and Modern modes.

  I'd like to see other Common Lisps switch to lower-case symbol names
  and case-insensitive readers.  That would mean we expose code that
  assumes too much about symbol names and _incorrectly_ construct them
  at runtime.  Yes, that code will break.  It will also break in your
  "virtual machine" version.  It would break less if it could know
  which case to expect and use.  Please realize this: Code that uses
  strings of uppercase characters to build symbols is _not_ going to
  work in your "virtual machine" gizmo, John.

| The way we deal with readtable-case makes it easy to convert code
| into a mode where it works in ANSI or Modern mode.  That's a
| critical first step.  If we scare people away and make it too hard
| to do the conversion they won't bother.

  OK, so you really don't give a flying fuck what I think about this.
  I'm amazed, nay, _flabbergasted_, again, that you think you have
  _not_ scared me away.  That you invoke the "friend" word when you do
  that is no less insulting.  Do you think I'll just accept anything
  from you?  I don't.  You knew that _long_ before you posted your
  bullshit about your virtual machine approach not breaking extant
  code.  The longer you insist that you have the right to break some
  of the functionality in the standard, the more you scare me away,
  and I hope as many people as will inflict real pain and suffering on
  your bottom line if you don't relent will follow me.  Yes, you read
  that right: I'm so fucking pissed with your disrespect for the
  standard and the whole community that goes with it that I'm looking
  for alternative technologies to Allegro Common Lisp as we speak.  I
  _amazed_ that you have the gall to do this at this time.

| Clearly you've got a problem where doing case conversions in the
| reader is critical.  The question is whether that can be solved in
| another way.

  Yes, it can be solved by not breaking the standard.  You never had
  to do that to begin with, either.  I know, because I've spent a
  hundred hours or more pouring over your symbol reader and printer
  code.  It's twice as complex as it needs to be because of your own
  broken design.  I spent an inordinate amount of time just getting
  Allegro CL to print symbols correctly according to all the printer
  variables, and .  I'm happy that you cared enough about this to fix
  it, but that it had not been done correctly speaks volumes about
  what you care about.  It still doesn't work correctly for any value
  of *print-base* greater than 10, however: It fails to escape the
  characters of a symbol that would be read back as a number.

  I want you to get off that "the standard is broken, so fuck it" high
  horse of yours and start to respect the standard.  It's a community
  document and _you're_ the outsider when you disregard it, break it,
  or implement redundant functionality.

| A question for other (human) readers of this is: given that you are
| working in a case sensitive lisp, is readtable-case something you
| need for your application.

  It's part of the standard.  You're a vendor who has a product that
  claims to conform to the standard.  We don't take polls whether
  people think the Constitution of the United States is important in
  everybody's life or whether we can ignore some sections that stupid
  people only save bad people from getting caught.

  I have requested a commitment from Franz Inc that you will honor and
  uphold the ANSI Common Lisp standard, and I very nearly quit working
  with you over not getting a decent answer to this question some time
  ago.  I'm pissed as hell that you think you have the right to throw
  out some pieces of the standard.

  Perhaps you should go back to call it Franz Lisp and let the rest of
  the world know what you're really selling?  I'd drop the product in
  a millisecond if you do, of course, so you're guilty of fraud if you
  keep up this charade that you're producing a conforming ANSI Common
  Lisp implementation when you really are out to hose the parts of the
  standard you personally dislike.

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