* John Foderaro
> If you don't understand why it's not because I haven't tried repeatedly
> to explain why. I even have a web page explaining it and I'm sure
> you've seen references to it in my source code.
> http://www.franz.com/~jkf/coding_standards.html
that makes me _not_ want to use Common Lisp. I think that document says
much more about the religious fervor and irrationality of a supposed
"personal taste" which shows disregard and disrespect for every other
Common Lisp programmer on the planet than any concern for good code. I
happen to *like* Common Lisp just the way it is, damnit!, and both the
language and the tone and the wider implications of the statements in
this file are insults to everyone who has ever thought Common Lisp was a
great language. This file is like a "personal statement" on why women
should have breast implants and other cosmetic surgery, because, frankly,
they are _all_ butt ugly as a matter of course ("one can go on and on
about how bad natural breasts are, but we'll try to be brief") unless
_modified_ to fit the "personal taste" of particular misogynic. Repeat
the experiment of reading this document as if it were about something you
happen to _like_. Do you want to deal with a person who goes out of his
way to insult something _great_ and who thinks marring it is necessary?
But it gets worse, much worse. The exact same kind of religious fervor
and irrationality applies to several other areas. I could deal with the
IF* abomination and the exaggerated hatred for LOOP for a long time,
until I saw that the same thing happen to case in the reader. It is not
that there is a difference in taste, it was that _disresepct_ for those
who held other opinions, the _dishonesty_ of the arguments that there was
only to do this and that and not to worry about a thing, which any smart
Common Lisp programmers would know to be false, and finally, we saw that
reckless abandon that it was the _caller's_ fault if he had failed to
bind *print-upcase* back to the only value it apparently should have
around a call to a low-level function, because *print-upcase* and the
whole case stuff is somehow _wrong_ and thus removed from the language
that has been subject to cosmetic surgery. So this disrespect for Common
Lisp boils down to a pretense that Common Lisp is something it is not.
I have no idea what programming language these "coding standards" really
apply to, but it is not the Common Lisp I would like to use, and I can no
longer trust the purported Common Lisp code that whoever adheres to these
"coding standards" write because I have no idea how many other areas have
been subject to this looney programmer's "personal taste".
Until Sam Steingold got on the CLISP team and apparantly caused it to
move towards ANSI compliance, I had the same kind of distrust in Bruno
Haible's massively arrogant attitude problems towards the standard. I
want to program in Common Lisp, to use the available resources to see
what Common Lisp programs _should_ do (that is what conformance is about
-- screw portability of code -- it is portability of _knowledge_ I care
about), but here this punk goes out of his way to break with the standard
in areas that make absolutely no sense, also denouncing the language as
misdesigned and broken. Why could he not make his modifications as small
_additions_ to the standard? Something _optional_? A case for _choice_?
Why make it so _personal_?
* Alain Picard <apic...@optushome.com.au>
> FWIW, the "standards" referred to at the above url just sound like a
> codification of personal preferences to me, with no convincing argument
> in their favour.
Oh, I think it reads like very convincing arguments in their favor,
provided that you are willing to share the arrogance of a person who is
pretending that Common Lisp is not a defined standard, but just a matter
of personal taste and dislikes. If you assume up front that the people
who wrote the standard and agreed on everything in a political process
are idiots who should be kicked in the ass, of course you listen to such
swaying arguments as calling if, when and unless "bogus-tree-conditional".
> Don't get me wrong, you're ALLOWED to have personal preferences! But
> so is Jochen.
You know, I do not think this is a personal preference. It is an attempt
to be a _professional_ preference. Everybody is entitled to their
_personal_ opinions, but for those of us who think _professionalism_ in
dealing with _professional_ issues is a major mark of quality in any
_professional_ programmer, personal opinions are set aside in favor of
making things work together and abiding by professional agreements.
That "coding standard" document is one of the most _unprofessional_
statements of an opinion I can think of right now. It has tainted my
previously good impression of John Foderaro's _professional_ conduct and
it makes him look like a crackpot unaware that he is a crackpot in his
profession, as well. When I work with people, I do not want to _have_ to
care what their personal issues are. I may want to for personal reasons,
but not for professional reasons. It is our _work_ that matters in the
end, and as professional programmers, that means we set aside personal
preferences that get in the way of good professional conduct. Inventing
a stupid new macro with keywords while you denounce the grammer of some
other macros with keywords because of them, only because you don't like
cond and progn and default indentation rules would have been OK if you
confined it to your personal projects, but to _publish_ it? That is like
insisting on an alternative spelling of some words you think look silly
in published literature. Certain authors get away with this because they
sell their _words_, such as poets. But when you do not sell your words,
you sell the information they are trying to convey to a general public,
you abide by community standards and spell them the standard way. If you
do not, you are telling people that you do not care what information you
are selling, you are really in the business of selling your new words.
This is why I urge Franz Inc to remove IF* from their published code. If
you are in the business of selling Common Lisp products, just follow the
standard. If you are the business of selling IF*, proceed as you have.
If John Foderaro makes it as abundently clear as I get the impression he
does that he would never write cond and progn, much less if, when, and
unless in production code, have somebody else (preferably some software)
convert his _personal_ style into _professional_ style for publication.
(This is in fact something several publishing houses do for their wacky
authors, who amazingly accept that they can blame the publisher for the
lack of artistic integrity that is required by the process of publication
and the filthy requirements of money and all that artistic crap you can
get away with as a celebrated author. However, I fail to see how bloody
"artistic" IF* can be that it would mandate a similar acceptance of an
author's attitude problems.)
IF* and its disturbed origin has become a blemish on the community. Any
community can and must deal with weird people, because that is just what
life is like, but when it becomes a weird _profession_ because some are
unwilling to put on a suit and tie when it is _required_ of them, the
whole community suffers. Common Lisp is already considered weird by
some, and the personal conduct of some Lispers does not help, but we
really do not need to deal with irrational _professional_ conduct.
> I think Lisp is really lucky to be so clear as to need so few of these
> "coding standards".
Well said.
///
