« prev · plain text · next »       2001 · Erik Naggum comp.lang.lisp archive       search · random

Subject: Re: the "loop" macro
From: Erik Naggum <erik@naggum.net>
Date: Wed, 29 Aug 2001 05:25:39 GMT
Newsgroups: comp.lang.lisp
Message-ID: <3208051533652127@naggum.net>

* John Foderaro <jkf@unspamx.franz.com>
> Does anyone else feel that I don't have the right to define my own macro
> to express the conditional statement?

  That is not the issue.  Such rights have never been questioned.

> Does anyone else feel that I don't have the right to criticize: if, when,
> unless and loop?

  That is not the issue.  Such rights have never been questioned.

> If it's antisocial to extend the Common Lisp language ...

  That is not the issue.  Nobody has ever even indicated that as the reason.

> An extension that big puts my little if* to shame.  Surely someone who
> designs something like that is the most antisocial of all.

  To those who have studied criminology and recognize the behvioral pattern
  of somebody who is determined not to understand why what he has done is
  under criticism, your chosen line of defense is the most incriminating
  and revealing.  You did this the last time you tried to defend a piece of
  buggy code, too, and it showed us that John Foderaro does not back down.
  Clearly, having the right to denounce the standard that your company is
  asking its customers to trust it to implement for them is more important
  than realizing that by your denouncing what people want to purchase from
  you, you undermine your own livelihood.  Further, distancing yourself
  from the process and pretending to be a victim of conspiracies against
  your "superior solutions" indicates that the standardization process,
  which people trust to produce standards that vendors are supposed to
  agree to implement, is actively _distrusted_ by you and by Franz Inc.

  The message you send is not "we have something better", but instead "We
  hate Common Lisp as it became standardized by a bunch of morons, but do
  come talk to us if you want an implementation of that crock of shit."

  Apparently, you fail to understand that you can improve upon something
  without denouncing what you improve upon.  You do not make something that
  is better than what people already like -- you have to make them hate
  what they have in order for what you have done to be better.  Such is not
  actually improvement -- it is the childish game of "not invented here".
  This is the dangerous part of your personality and what I react to most.
  The dangerous _consequence_ is that you are fully willing to sacrifice
  your professionalism and other people's trust in your competence as a
  programmer with a serious vendor to your personal opinion about matters
  of _zero_ importance to the future of Common Lisp and its market share
  and ability to solve real problems.  Clearly, it is much more important
  to vent your spleen about if, when, unless, and loop than to help build a
  business case for Common Lisp and to help attract people to the language
  ("Use Common Lisp and come join the Common Lisp community and take part
  in the hate campaigns against the best language on earth.").

  Clearly, you do not appreciate that my trying to push Common Lisp to
  people who have the money and the trust in me as a consultant that could
  land Franz Inc another large contract should cause you to beam with love
  for the language your products implement, but instead you spend your time
  denouncing the standard and the process that created it, creating the
  very strong impression in every reasonably intelligent reader of your
  rantings about language misdesign that you have gone elsewhere yourself,
  so why should anyone new to the language ever stick with Common Lisp?

  You will probably never understand this, since you continue to believe
  that you are "innovative" the same way Microsoft is, but the way you ask
  people who actually happen to like Common Lisp to hate it insteead, lest
  they be branded religious zealots and worse, is telling people to stay
  away from John Foderaro's sick mind and anyone who keeps him employed in
  a position where his blind hatred for irrelevant features causes him to
  write and publish buggy code and refuse to understand that it needs to be
  fixed because he thinks the problem is in the specification.

  It is not your changes that causes me to react.  It is your arrogance.
  It is not your desire for improvements more to your liking that causes me
  to react.  It is your intense denunciation of everything that I need to
  entrust my own livelihood and professional reputation to your products.
  It is not the fact that you are a deranged lunatic that makes me want to
  terminate my business dealings with Franz Inc.  It is the fact that they
  keep a deranged lunatic employed in a position where his utter lack of
  professionalism and professional integrity may cause serious damage to my
  own or my client's software in a production setting where bugs you have
  introduced because you do not consider my trust in the specification you
  distrust a valid concern or a reason to write correct code or to fix
  bugs, and hence I will lose money and possibly face lawsuits if I _do_
  trust you.

  I am a businessman, John Foderaro.  You are not.  I deal with people's
  trust in me and my competence every single day.  You have never grasped
  that I question your trustworthiness.  To my paying clients, the only
  thing that matters is my professionalism.  They do not care whether I
  have personal opinions about the products we use or not.  I may thus love
  Allegro CL _personally_ and I may grief in _private_ about the idiocy of
  your self-destructive behavior, but I would be criminally unprofessional
  if I asked a client of mine to invest USD 100,000 in my love for a
  product that cannot be trusted to perform as required by specification
  for such a fantastically stupid reason as one idiot engineer giving a
  higher priority to his dislike for language features over correct code.

  This is a bigger issue than you appear able to understand, John Foderaro.
  Nobody cares what you think about if, when, unless, and loop when they
  face a delay in deployment because of one of your bugs.  Nobody cares
  about your silly coding standards when a project folds because a feature
  in the specification is not supported for "political reasons".  We have a
  standard, and nobody cares where it came from, God, Devil, committee, or
  John Foderaro, but everyone in the kinds of businesses I deal with care
  that it is actually and faithfully implemented.  Based on the evidence
  that you provide about your priorities for Common Lisp and your own code,
  I _must_, because I am a professional, decline to suggest that people who
  would be willing to invest several hundred thousand dollars over the next
  few years on their trust in my word, invest it in Allegro CL.

  In short, your insistence that you be allowed to denounce the standard,
  the standardization process, us "zealots", and everyone who disagrees
  with your fantastically stupid "improvements" and "coding standards", has
  a pretty hefty price tag.  Your employer needs to understand that your
  desire for a John Foderaro Lisp instead of a Common Lisp has caused me, a
  fairly strongly devoted fan of Allegro CL, to abandon Allegro CL as the
  choice implementation platform.  I do not personally consider there to be
  viable alternatives, which means that we will probably use a different
  language.  Now, this has not just happened this once, the last time we
  had a fight over your prioritizing your personal opinions over correct
  implementation of specified language features, I did not even bother to
  waste my time arguing for Common Lisp.  That project went with Java,
  simply because I was too personally exhausted by your idiotic behavior to
  want to fight for Allegro CL.  I know I could have won that project.

  The question I put towards you, John Foderaro, is this: Does it matter so
  much to you to be able to denounce that which people come to you and to
  Franz Inc to purchase that you are willing to let go of customers who do
  not like that denunciation and who get the impression that you will do an
  unprofessional job if asked to implement something you have some personal
  issue with?  If it matters that much to you, good riddance to both you
  and Franz Inc.  If you can get through your thick skull that maybe you
  can get what you want if you back down and start to behave professionally,
  maybe, just _maybe_, it is possible to get Franz Inc to take conformance
  seriously and actually put fixing deviations from the specification on
  top of the list of prioritized tasks and thus help rebuild its trust.

> You readers of this newgroup set the tenor of the lisp community.  Shall
> it be as Erik wants where criticism of the standard is squelched, that
> new ideas are forbidden?

  That is not the issue.  That is not what I do.  It is not criticism that
  you engage in, it is a political campaign of distrust in the process that
  created the standard.  If it were criticism, you would respect the
  process and its results.  You do neither.  If it were criticism, you
  would trust the process to yield better results with better input.  You
  very obviously do not believe this, but instead take it upon yourself to
  do what you will, regardless of process or procedure.

> You the lisp community has to decide.  Erik may speak the loudest but
> don't be put off by that.  Speak your own mind.

  Yes, let us see a show of hands from the all people who do understand the
  issues of trust, conformance, respect for procedure, and compromise in
  order to gain something _higher_ than immediate personal satisfaction.

  I used to have doubts that you were mentally incapable of understanding
  the issues that surround your antisocial behavior and your strong disdain
  for the community standardization process, but I have been forced by the
  sheer mass of evidence that you yourself provide to conclude that you do,
  in fact, not have the mental apparatus to understand what standardization
  means for a community and for the trust one may have in products.  The
  concept of trust in professionalism is probably also forever beyond your
  reach as you continue to behave in the most _unprofessional_ way I have
  seen anyone in any community ever do.  Your immense lack of honesty and
  personal integrity when it comes to representing the views and opinions
  of others contributes to your lack of understanding of what other people
  are trying to address.  This are further strong indications of a deeply
  antisocial personality.  Your behavior in regard to the case issue and
  the line of defense you choose when under criticism for your rampant
  disregard for community "compromise" in favor of "John Foderaro's way",
  whatever the cost may be, indicates that you are incapable of dealing
  with more advanced concepts of cooperation than "do it my way or no way".
  Since this is also how you interpret any criticism towards you, it seems
  highly unlikely that you have the ability to understand what the issues
  are surrounding your conscious and willful destruction of the public
  trust in Franz Inc's commitment to implement a conforming Common Lisp
  implementation and the construction of a reciprocal distrust towards the
  antisocial behavior of Franz Inc when it comes to breaking the standard
  in order to push some miniscule changes for personal reasons.

  I concluded that I could not trust you or _any_ of your code when you
  flat out _refused_ to recognize the bug in the piece of code you posted,
  because I understood the full implications of your political agenda: It
  is more important for John Foderaro to denounce people than to help me
  and anyone else who wants to make money programming in Common Lisp with
  Allegro CL.  It is fairly obvious that I have the exact reverse priority.

  And people wonder why Common Lisp does not "win"?  It is not because of
  the language, it is because of the self-destructive morons in this
  community who think it is conducive to their personal goals to denounce
  and ridicule and fight the common goal.  John Foderaro and his case,
  pathname, character vs integer, if-when-unless, loop, etc, etc, issues.
  Bruno Haible and his large bunch of issues.  Paul Graham and his bunch of
  issues against the language.  People who appear, on the surface, to have
  done good work for Common Lisp return time and again to denounce the
  language, its community, and everything that _could_ bind us together.
  Why would anyone in their right mind want to use Common Lisp when the
  people who do (seem) use it are so negative towards the language?

  Over the years, people have asked me how I can make money at all doing
  the things I do for a living.  I have always been way, way off mainstream
  and still made a reasonable living.  I think the reason is pretty clear:
  I love what I do and do what I love.  People pick up on it and trust me
  professionally because of the fact that I have a high personal investment
  in what I do.  Likewise, I think people pick up on those who hate what
  they do and do what they hate.  Judging from the behavior of a large
  number of Lisp people, it seems clear to me now that the problem we have
  is that people do not love Lisp and the do not use it, because it is more
  important to them to hate some miniscule little misfeature than to love
  the whole of it and live with the "warts", if any.  It also seems to me
  that people are reluctant to leave, but prefer to hang around and be
  nay-sayers and negative influences on those who _want_ to like Lisp.  We
  see it from people who come here, too, they pick up the negative attitude
  towards the language _very_ quickly.  I am probably very fortunate who
  can do what I do, but I honestly think that if you do not do what you
  love to do, it is because you decided at the wrong time that you would
  quit searching and settle for the money or something.  That is _poverty_.
  If you cannot love more than the money you get for doing something, at
  least be smart enough to love that, and it should be easy to pretend that
  you love your work so you can continue to make money.  If you cannot even
  pretend, why are you not searching for something better?  How much effort
  can it _be_ to learn a new trade or a new programming language?  I mean,
  _kids_ learn these things.  Kids are _not_ smart.  Kids do not have tons
  of experience and stuff that makes things easier to learn.  Kids absorb
  stuff faster than grownups, but they still need a lot of time getting
  used to _working_.  Grownups _work_.  When grownups _want_ to learn
  something new, they do it way faster than kids do.  At least if they are
  pretty intelligent, and Lisp people are ipso facto pretty intelligent, so
  there simply is no excuse for a disgruntled Lisper to hang around and be
  so negative about Lisp.  This makes me wonder what kind of personal value
  it has to a disgruntled Lisper to hang around in the Lisp community and
  denounce the language, the standard, the people behind the standard, and
  nigh everything that says a _positive_ word about either or all of them.

  I trust that people smarter than John Foderaro understand that criticism
  is not the same as denunciation.  Criticism has a fundamental respect for
  that which is criticized and a desire to see it realize a potential that
  it may not yet have realized fully.  Denunciation is disrespect for the
  potential _and_ its realization, however incomplete.  Good criticism will
  always see how the current realization reflects the potential, not deny
  that it does, which denunciation would do.  Good criticism embodies an
  understanding and appreciation of how something came to be, because
  nothing can really be "improved" by first breaking with its genesis --
  that would be replacing a lot more than that which needs improving.  This
  is why "X is broken, here's an incompatible fix" is _not_ good criticism,
  but bad.  Bad criticism presumes that the current realization defeats the
  potential without actually establishing that premise to be true.  (It
  does happen, unfortunately, as it does with attributes in SGML.)

  John Foderaro has made this into an election and a popularity contest.
  My take on this is that people who have nothing better to do than to
  denounce the standard, the process by which it was created, and the
  people who did it, be shot down and thrown out of the community.  Let
  those who _like_ Common Lisp use it, and let the nay-sayers leave us
  alone to do what we think best.  Those who _like_ Common Lisp will have
  lots of ideas for improvement, too, but at least they can trust that the
  other people they sit down with and compromise with are all good people,
  instead of disgruntled nay-sayers who did not get their will last time
  and never got over it.  Maybe there even are things that are broken and
  not well thought out, but if you like the language, you will care for it
  and its users, not chop off parts according to personal distastes and
  scare people off because _they_ liked the part that got chopped off.

  Now I have a Common Lisp application to update with new requirements that
  are easily met before its users get to work in a couple hours.

  And since this is an election: Remember to vote for Common Lisp with your
  heart -- it is the good language for good people.  Remember who _likes_
  Common Lisp when you want to trust people to take care of its future.
  
///