Subject: Re: MD5 in LISP and abstraction inversions
From: Erik Naggum <>
Date: Thu, 15 Nov 2001 01:17:09 GMT
Newsgroups: comp.lang.lisp
Message-ID: <>

* John Foderaro
| What good is it establishing a standard if you don't follow it?

  Funny you should ask...  But it clearly applies only to your own.

| You may note that one of the example files (, a very cool
| aserve application written by another developer at Franz (Charley Cox)
| actually uses when and unless.  Some day I plan on converting that over
| to use if* but I don't feel an urgency to do so.

  Someone should convert the "ported" AllegroServes and other open source
  from your end to use the standard conditionals, because what good _is_
  having a community standard if one does not follow it?  Publishing source
  code for others to read is all about letting people who want to find good
  programming style and quality design learn by example, after they have
  found textbooks teaching or standards defining the language they are
  reading -- that is not what they find in if*-infested code.  If they have
  to deal with some wacky old historical accident that transports them back
  to pre-Common Lisp times with every programmer's own version of basic
  language constructs, we have gained nothing with the standard, and that
  is clearly the _purpose_ of the if* form.  We were _supposed_ to have
  progressed beyond random user macros for fundamental control structures
  with the establishment of the standard, but some have still not accepted
  it.  I do not think they should be rewarded for their retro-rebellion and
  nostalgic pining for a time when we _had_ no standards.

  The Open Source community does not have to accept anyone's very personal
  "coding standard", especially when it proves to be a _liability_ to the
  community.  Quite the contrary, the Open Source community should strive
  to make its projects acceptable to as many people as possible, to be
  inclusive of tastes -- which, contrary to the childish whining of those
  who have no concern for anything but their _own_ taste, to mature people
  means finding a point of _common_ agreement that offends as few people as
  possible and thus allows people to make _serious_ improvements instead of
  petty ones that only annoy lots of people.  One such obvious common point
  of agreement is the _standard_, within its scope; outside its scope, we
  must strive to find other points of agreements, obviously, but still the
  respect for such agreements must be established and maintained.

  The Open Source community is already loaded with political issues that
  tend to exclude people who could have contributed serious improvmenets,
  so finding the intersection of those who accept the political issues and
  those who accept the irrationality of refusing to deal with standard
  conditionals and community-accepted coding practices, will of necessity
  be quite hard.  Furthermore, does any part of the Open Source community
  _really_ want to marry into the anti-standard political agenda of someone
  who expresses strong disdain for _many_ clauses and committee decisions,
  disrespect for and hostility towards central committee members, and who
  refers to the upper-case symbol names of the standard as "braindamaged
  mode" as opposed to the "modern mode" of his own design?  I certainly do
  not want to help further such agendas, so if I find bugs or some features
  I do not like, I just drop it or do not use it at all, just like some
  Microsoft "operating system", rather than try to make it better, which
  would simply mean making it better at hurting what I value.  Sharing code
  with people who have agendas that are contrary to mine would be self-
  destructive -- I _really_ want ANSI Common Lisp to survive, and more than
  that, to be _the_ point of agreement for the whole commnunity.  I want to
  work _within_ the accepted procedures to make changes or improvements if
  any are necessary, not undermine the standard by changing the language
  people see, indeed, to make sure that _textbooks_ and _references_ on
  Common Lisp really teach people the language they can expect to see
  _used_.  By changing the conditionals, which John Foderaro says he thinks
  of as _fundamental_ to a language, he exposes people to a _different_
  language, regardless of how much he keeps claiming that he is writing and
  using "Common Lisp".

  Getting rid of the personal idiosyncrasies of individual contributors
  does in fact improve both readablity and acceptability of the source code
  to a large number of people, just as it does for prose text.  As I have
  pointed out repeatedly, publishers and _responsible_ companies ensure
  that their _published_ materials follow standards that are far more
  _inclusive_ than some "style" of a wacky employee, because the use of
  slang, sociolects, etc, in technical documentation, code, and the like
  _excludes_ all those who do not appreciate it, who do not want to be
  members of a freak show just because they want to use or take part in
  something.  Considering the "sterility" of technical documentation and
  the sheer absence of "personality" in such material, one has to grasp the
  intent to communicate the ideas as cleanly as possible, understandable by
  as many people as possible, and thus is nearly devoid of idioms, local
  vocabulary, slang, poetic expressions, etc.  It is considered hard to
  write good technical documentation because it has be "alive" despite all
  the usual means to keep prose text alive.  But not only technical stuff,
  _every_ author has to deal with the kind of "ego bruises" that come from
  dealing with a serious publisher's copy editor, and most authors who are
  serious about being published _understand_ that their editors know a lot
  more about this than they do as authors -- after all, the author knows
  the subject matter while the editors know the publishing business, and
  that includes the language to use.  Those who are too stupid and arrogant
  to listen to expertise, who refuse to consult dictionaries and style
  guides or who refuse to learn from those who have been published, do not
  get published -- it is a matter of "I know everything best" versus "I
  know _my_ stuff".  The Net has unfortunately had a dramatic effect on the
  publication rate of trash and documents that scream "Look at my personal
  style!" instead of whatever they were trying to communicate, the same way
  many documents screamed "Look at what my Macintosh can do!" back when
  that was the measure of ridiculous hipness.  But still we have publishing
  houses that manage to break in their authors and cause the whole stable
  of authors to agree to publish books using the same style, the same font,
  the same layout, etc, even though you can be dead certain that very few
  of them would have chosen it on their own, and some of them probably had
  a pet style that did _not_ get used.  Those who go bananas over the use
  of certain quotation marks, say, are simply dropped by the publisher.  A
  renegade author costs so much more for these publishers that you have be
  a _real_ big name to pull any such stunts.

  There are parts of Common Lisp that one Common Lisp programmer or another
  most probably does not like, would have designed differently, etc, but
  out of deference to the community of readers of _published_ code, they
  understand that it is actually _preferable_ for their _own_ personal
  goals to work towards community coherence over getting their personal ego
  stroked, because that means fighting people all the time, every time.

  Just in case there are _still_ some people who think this is about any
  "technical" aspects of the if* macro: It has never been.  It is certainly
  not a smart macro -- is just a sugar-coated cond.  What it has been about
  all along is the arrogance, disrespect, stupidity, egotistical attitude
  problem, and giving the finger to the community, that the primary (if not
  only by this time) user of if* has ensured has become the community-wide
  connotations of if*, but these connotations will not go away -- if* has
  to go away for people to forget this and return to value the community
  created by the standard, the textbooks, the editor and development system
  support, etc, that they share.  This is just like those who have read
  Scheme texts that never use iteration because the authors think their
  readers will figure out for themselves what their recursive style is a
  _variation_ upon, since they are expected to know languages that do
  iteration already, but instead these readers believe that iteration is
  somehow evil and recursion is divine.  In particular, if the readers of
  if* code do not know how Common Lisp can be used to define new control
  structures and accomodate any random lunatic's or smart programmer's
  desires alike for personal macros, especially when the macro definitions
  are not even included in the published source, they will not understand
  any point about the supposed "power" of the language being used -- what
  they will go away with it is the same kind of hostility that the author
  of the if* macro first made explicit: using the standard conditionals is
  _bad_.  Even thinking that using such a bogus historical accident will
  tell people anything new just by example unless they were shown a number
  of such variations, is just silly, and yet that is precisely what they
  are _not_ shown.  If if* was supposed to be an exercise in pedagogy, it
  was the most astonishingly incompetent such exercise in the history of
  pedagogy, so let us just dispell with the notion that it was.  It was and
  remains a political vehicle for filibustering against the standard.  This
  is what I oppose, just as I oppose the equally idiotic notion that loop
  is inherently bad, that upper-case symbol names are bad, that iteration
  is bad, etc.  _This_ is why if* is bad.  Since if* also has no inherent
  value for anyone besides those exposed to it in the past, meaning only
  "historical reasons", there is no point it keeping it along everything
  else, either.  The end result is that when a vendor promotes if* in their
  published code, they are _actually_ saying "screw the community and its
  standard", whether they understand it or not, and admit to it or not --
  it should, however, be fairly hard to ignore the consequences by now.
  They can say whatever they want, in fact, about how much they treasure
  the standard, but actions speak so much louder than words.  The only
  reason they keep publishing code with if* in it, is that they do not care
  about those who want the standard to be the common point of agreement in
  the comunity.  Customers and users of their open source offerings should
  take note of this and make their concerns explicit, just like the
  perpetrator and perpetuator of the if* stunt tells everybody else to do
  when they do not like something.  The other possibility is that John
  Foderaro is able to hold Franz Inc hostage to his insane requirements.  I
  would hope that this is not very likely, but by now, I no longer know.

| I may not even be able to read and understand the extended loop code
| though.

  Good!  So you _do_ understand what using if* in your code _does_ to its
  readability and understandability and acceptability!  I thought you never
  would.  But keep it up, and maybe you can grasp why your keyword-laden,
  unnavigatable, unformattable, and generally ridiculous macro does to its
  non-fan readers _just_ as you have a hard time with loop, but probably
  even more so, since anyone can read up on what loop does in any number of
  references and get multiple views on its merits and demerits, including
  the ability to combine extended loop with do forms, mapping forms, simple
  loop, iterator functions, etc.  Since there is no combining if* with any
  other conditionals, however, one has to buy the whole package deal, and
  that by itself is revolting to many people.  Additionally, seeing that
  you are going to change their contributed code to use a bogus historic
  artifact instead of the _standard_ conditionals, will turn people away
  from contributing to source code that is full of if*.  _None_ of this
  political baggage comes with using loop, so understanding that if* is
  much worse to readers who do not like it than loop is to you might be a
  good starting point if you really want to understand why it is rejected
  and why you and the vendor you _represent_ are hurting the coherence of
  the community.

  I really wonder what you get out of using and promoting if* at this time.
  All it is telling the world is "screw you all!", which you have also said
  in tone if not in words in every single one of your recent messages.  How
  can that be of value to you?  How can it be of value to your employer?  I
  cannot be the only previously happy customer whose impression of your
  employer has fallen dramatically because of your insistence on publishing
  offensive code.  It is clear to a lot of people that you would sacrifice
  the standard any minute if you could get away with it, because that is
  precisely what you _do_.  That you obviously do not see this yourself is
  a problem that at least _some_ of your colleagues must recognize, but
  from what I understand, several people agree with you that upper-case is
  "braindamaged" and probably agree with you that whoever wants when and
  unless and extended loop are equally deranged, so you are _unreachable_.
  That nothing happens to your insistence or even to your arguments in what
  you probably believe is rightfully defending yourself, is not a good
  sign.  It frankly has me worried.  At some point, the personal value of
  continuing to publish if*-infested code will be less than the value of
  keeping your job, your customers, your membership in the _Common_ Lisp
  community, etc.  This is not a threat, it is a simple prediction, which
  you are of course free to think will never come true.  We all choose what
  we value higher among our options, and dedication bordering on stubborn
  is generally valuable, except when self-destructive.  Some realize this
  in time to get help.  Others self-destruct and take a lot of other people
  with them in the process.  I care about those other people.

  Norway is now run by a priest from the fundamentalist Christian People's
  Party, the fifth largest party representing one eighth of the electorate.
  Carrying a Swiss Army pocket knife in Oslo, Norway, is a criminal offense.