Subject: Re: MD5 in LISP and abstraction inversions From: Erik Naggum <email@example.com> Date: Thu, 15 Nov 2001 01:17:09 GMT Newsgroups: comp.lang.lisp Message-ID: <firstname.lastname@example.org> * 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 (puzzle.cl), 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.