* "Scott McKay" <s...@mediaone.net> | Hey, look, if the only thing that Lispers care about is having | Lisp syntax, then they are as closed-minded as the C and Java | communities. Syntax is trivial. Get over it.
Wow, so much _passion_ against somebody caring about something! But why reduce somebody else's concerns to "only thing that they care about"? How rewarding can it be to beat those strawman arguments?
You may dislike that some people care about syntax and even think they are idiots for it, but at least have the honesty and decency to judge them for what they think, not for some moronic attitude _you_ attribute to them out of malice, OK?
Syntax _is_ important to some people. So, too, is spelling and grammar in natural languages. Some _always_ "disagree" with this, however and it is usually coupled with a hostile "get over it" to whoever points out a mistake. One could psychologize endlessly over the causes of such intolerant hostility.
Syntax evidently forms the ways our languages develop and evolve, if the history of programming languages is at all useful to consider, which would imply that syntax itself in no small part shapes the way we _think_ in our languages, especially when so much of programming is all about making our own thoughts expressible _in_ a language, by extending it in various ways. I therefore find it a sign of general lack of insight into languages and human use of them to make such an unfounded and overly broad claim as "syntax is trivial", especially after having complained about Lisp's syntax. What was that "get over it"? It surely does not apply _only_ to others, does it?
On the other hand, my chief gripe with fixed-grammer syntaxes is that they enforce this artificial separation between the language and any expression in the language, but some people never get past the level where they only "use" a language. as opposed to be able to _live_ with the language. [A weak reference to Richard Gabriel's "Patterns of Software" and _inhabitable_ software.]
Finally, a twist on the old "beware of programmers with screwdrivers": Beware of programming language designers who show disdain for syntax.
#:Erik -- If this is not what you expected, please alter your expectations.
> Syntax is _extremely_ important to many programmers because there > are many times when several languages are "equivalent" in many > respects, and so in the end it comes down to which one's syntax one > is most comfortable with.
I don't want to disparage your (or anyone else's) taste, but for me, syntax rarely matters except when it is designed to maximize confusion. (Eg: Perl and Python -- the two languages have nearly identical semantics, but Perl is awk on PCP and Python isn't, so I use Python for sysadminy things.)
But Dylan and Lisp are both clean enough; I can judge between the two based on their feature sets. I chose Dylan, but there are features that you might need (such as the MOP) that Dylan (deliberately) doesn't have.
> Since you have lots of experience with both languages, would you > agree that the CL syntax is more expressive? more malleable? More > uniform? I would, but if you feel otherwise, I'd like to know why.
Actually, I'd say that Dylan is simpler and more uniform than Common Lisp. There are single features of CL (such as LOOP and the FORMAT sublanguage) that are nearly as complex as all of Dylan.
But Common Lisp has a set of powerful features Dylan doesn't. Reader macros, compiler macros, and the ability to do computation at macro expansion time. Dylan's macros are very close to Scheme's; they are a hygienic pattern-expansion mechanism (plus a feature to deliberately break hygiene).
Since I do need a comprehensive object system but don't usually need the MOP, make frequent use of higher-order functions, and naturally tend to write only the sorts of macros easily written with a hygienic system, I prefer Dylan.
* "Michael T. Richter" <m...@ottawa.com> | That's the first time I've seen someone describe a profusion of | parentheses as "clean".
Congratulations! That's means you have finally opened your eyes to the _existence_ of people who don't share your closed-minded view on syntax. That's no small feat for a man in this day and age! I hear tolerance is such a virtue over in the Dylan camp, so you must feel almost like a white supremacist who saw the first black in his life, or the uptight puritan who first discovered gays and lesbians on his own -- such wild and unbridled expansion of your consciousness is so seldom achieved without drugs these days. Man, you are _so_ lucky.
No wonder Dylan dropped its clean, attractive syntax -- had it retained it, the Dylan community would have had to deal with so much hostility in their own ranks -- as always, it's _so_ much better to find an external "enemy" to ridicule and denigrate, especially when it's someone you think you're competing with because you might have been friends if you were any smart, but if you choose infix, being smart is just _not_ an option.
#:Erik -- If this is not what you expected, please alter your expectations.
Neel Krishnaswami wrote: > But Common Lisp has a set of powerful features Dylan doesn't. Reader > macros, compiler macros, and the ability to do computation at macro > expansion time. Dylan's macros are very close to Scheme's; they are a > hygienic pattern-expansion mechanism (plus a feature to deliberately > break hygiene).
I was interested in Dylan, but this makes me much less interested. I use the power of CL's macros all the time.
> > But Common Lisp has a set of features Dylan doesn't. Reader macros, > > compiler macros, and the ability to do computation at macro > > expansion time. Dylan's macros are very close to Scheme's; they are > > a hygienic pattern-expansion mechanism (plus a feature to > > deliberately break hygiene).
> I was interested in Dylan, but this makes me much less interested. > I use the power of CL's macros all the time.
There's no shame in not liking Dylan, of course, but I still think it's very much worth trying out.
Personally, I think much of the use of macros in Lisp is to avoid using higher-order functions, or to work around non-generic functions in the CL spec. These are both more natural in Dylan. I don't want to over-sell, though: if you are writing something like Screamer, then CL is the only thing that can do it.
Johan Kullstam wrote in message ... >it's not. i like the lisp syntax because of its clean look. more >importantly, the syntax is what lets lisp have such powerful and >useful macros
This is simply wrong. What makes DRM Dylan macros less powerful than Lisp macros is that they can call general procedures at compile-time. The syntax has nothing to do with it, except that Lisp macros at their worst are even more unreadable than Dylan ones. As I have already said in this so-called conversation, the adoption of Keith Playford's procedural macros for Dylan would make them equally as powerful as Lisp's macros.
The confusion of macro power with infix is just that -- confusion.
Erik Naggum wrote in message <3171460328438...@naggum.net>... >* "Scott McKay" <s...@mediaone.net> >| Hey, look, if the only thing that Lispers care about is having >| Lisp syntax, then they are as closed-minded as the C and Java >| communities. Syntax is trivial. Get over it.
> Wow, so much _passion_ against somebody caring about something! But > why reduce somebody else's concerns to "only thing that they care > about"? How rewarding can it be to beat those strawman arguments?
> You may dislike that some people care about syntax and even think > they are idiots for it, but at least have the honesty and decency to > judge them for what they think, not for some moronic attitude _you_ > attribute to them out of malice, OK?
> Syntax _is_ important to some people. So, too, is spelling and > grammar in natural languages. Some _always_ "disagree" with this, > however and it is usually coupled with a hostile "get over it" to > whoever points out a mistake. One could psychologize endlessly over > the causes of such intolerant hostility.
> Syntax evidently forms the ways our languages develop and evolve, if > the history of programming languages is at all useful to consider, > which would imply that syntax itself in no small part shapes the way > we _think_ in our languages, especially when so much of programming > is all about making our own thoughts expressible _in_ a language, by > extending it in various ways. I therefore find it a sign of general > lack of insight into languages and human use of them to make such an > unfounded and overly broad claim as "syntax is trivial", especially > after having complained about Lisp's syntax. What was that "get > over it"? It surely does not apply _only_ to others, does it?
If you took the time to actually learn something about modern linguistic theory, you would see that people like Chomsky have tried to show that surface syntax is a property derived from much deeper underlying rules. Pinker's books are an excellent introduction to this. I find it a sign of general lack of insight that people think that syntax in most languages is the tough thing, because it isn't.
> On the other hand, my chief gripe with fixed-grammer syntaxes is > that they enforce this artificial separation between the language > and any expression in the language, but some people never get past > the level where they only "use" a language. as opposed to be able to > _live_ with the language. [A weak reference to Richard Gabriel's > "Patterns of Software" and _inhabitable_ software.]
> Finally, a twist on the old "beware of programmers with screwdrivers": > Beware of programming language designers who show disdain for syntax.
I have seen evidence of "disdain for syntax". Well, except from you, who evidently could not care less for the genuine effort spent making Dylan's infix syntax reasonable.
Neel Krishnaswami wrote: > Personally, I think much of the use of macros in Lisp is to avoid > using higher-order functions, or to work around non-generic functions > in the CL spec. These are both more natural in Dylan. I don't want to > over-sell, though: if you are writing something like Screamer, then CL > is the only thing that can do it.
My major use is in compiling sets of patterns. This involves nontrivial computation at compile time.
Please keep your comments to yourself if you cannot manage a minimal level of civility. These are not advocacy newsgroups and your flames are uncalled for.
I tried to make this point privately and politely a few hours ago, but my mail bounced. Either there was a technical problem or the mail address you provide when posting is invalid.
For the record, I do not remember any post from Scott McKay where he failed to be professional and helpful. I was expecting at least as much from a Lisp advocate - due to the respect I have for Lisp and its users.
> My major use is in compiling sets of patterns. This involves > nontrivial computation at compile time.
Incidentally, do you know if anyone has written a regexp or parsing package in Common Lisp that uses this strategy to produce really fast matchers?
It seems a natural niche for Lisp, which has a long NLP tradition, and it could plausibly yield results that run faster than C regexp engines, since you wouldn't need the *engine* at all -- you could just compile to efficient custom Lisp for each pattern.
Paul F. Dietz wrote in message <395E8386.E8B99...@interaccess.com>... >Neel Krishnaswami wrote:
>> Personally, I think much of the use of macros in Lisp is to avoid >> using higher-order functions, or to work around non-generic functions >> in the CL spec. These are both more natural in Dylan. I don't want to >> over-sell, though: if you are writing something like Screamer, then CL >> is the only thing that can do it.
>My major use is in compiling sets of patterns. This involves >nontrivial computation at compile time.
FWIW, this is the kind of thing I probably would do in Lisp because (1) you get to use a very simple representation for patterns (lists that you call 'read' on), and (2) you really do get all of Lisp's run-time at compile-time. For me, this sort of thing happens 1% of the time; I'm sure there are people for whom the occurrence is much higher, and they should keep using Lisp.
* "Scott McKay" <s...@mediaone.net> | Perhaps you missed the "if" in that sentence? : | If you took the time to actually learn something about ...
I don't really think I "miss" what you communicate with your "if"s. I perceive your intentions _very_ well, actually: You're here to show off your _personal_ superiority to anyone who dares criticize Dylan, and especially its syntax. By the insulted tone of your messages and your constant insults hurled towards me, it is clear that you have failed to deal with public comments in a public way, but instead prefer to make this a personal issue. Coupled with your lack of observation skills is your inability to deal with what people are actually saying in preference to arguing against incredibly cheap strawman arguments. This imparts an impression of a _stale_ intellect in need of self-defense at the slightest hint of serious criticism. I don't understand what you think you could possibly _gain_ by this, however, but I'm sure _you_ think Dylan will go out of this stupid activity of yours as a clear-cut winner. Maybe it's time to re-evaluate your strategy? Maybe you just ought to deal with the fact that not everybody shares your pathetically unenlightened (why else resort to the stupidity I have spared you from quoting in its entirety above) view on syntax?
| I find it a sign of general lack of insight that people think that | syntax in most languages is the tough thing, because it isn't.
I quite agree -- it isn't, but nobody ever said anything about it being "the tough thing", dude, so where _did_ you get that cheap straman argument? (Does it feel good to knock down strawman arguments, or does it leave you with an empty feeling inside which fits the sheer lack of intellectual accomplishment? Feel free to elaborate on your arrogance and inability to read what people actually write to defend yourself.) If you aren't bright enough to understand that objection to or love of syntax is not even related to the effort required to learn or use the language, I have no resepct for the rest of your similarly shallow opinions.
_If_ you took the time to read what people say instead of believing they said what you can most easily argue (such as it is) against, you might actually learn something, including differences in what people prioritize and value, but I get the impression that it's been a while since you learned anything from anyone other than yourself, and I certainly won't waste any more of my time on you when you are so demonstrably devoid of ability to deal with criticism.
| > Finally, a twist on the old "beware of programmers with screwdrivers": | > Beware of programming language designers who show disdain for syntax. | | I have seen evidence of "disdain for syntax".
Precisely. If you "missed" a "no" in there, perhaps you are going to deny that you wrote "syntax is trivial, get over it", too?
| Well, except from you, who evidently could not care less for the | genuine effort spent making Dylan's infix syntax reasonable.
So you really are _personally_ offended, now, huh? Geez, get over yourself. If you can't deal with negative comments on your work in public, it would be a good thing for you to try to avoid defending _yourself_. But why spend so much _genuine effort_ at something that you claim is _trivial_ towards those who _don't_ like it? Just how do you propose that I reconcile your clear disdain for syntaxes (other than your own) with that whining about respecting your work?
I don't judge your efforts, dude, I judge the results, from a number of aspects and values and premises of my own. You do not seem to have any respect for any such other than precisely _your_ own, which means that communication with you is a waste of time, just like Dylan is a waste of time, from my point of view. At this point, I think I have to tell you that you are free to be personally insulted by my opinion, as well as free to act _professionally_ about a difference in opinion that does not concern you personally at all.
Good luck with you language and your syntax and your efforts. Let's just hope you do a better job communicating with someone who cares what you think, _professionally_.
#:Erik -- If this is not what you expected, please alter your expectations.
> > it's not. i like the lisp syntax because of its clean look.
> That's the first time I've seen someone describe a profusion of parentheses > as "clean".
Well, then, look again. LISP syntax results from the fact that LISP as printed is a very nearly direct representation of the structures that are created in the machine as it is read.
The representation of LISP structures which you conventionally edit in a file has a uniquely direct and simple mapping onto the representation which is held in core - a representation much more direct, much more consistent and much more perspicuous than in any other high-level language in common use. Furthermore, these structures which you edit can be interpreted directly, and one of the great benefits of Common LISP over earlier LISPs is it strives very hard to ensure that the semantics of code when it is compiled are identical to the semantics of the same code when interpreted.
It's this cleanness which makes it so much easier to 'think yourself into the machine' in LISP than in other high-level languages.
-- si...@jasmine.org.uk (Simon Brooke) http://www.jasmine.org.uk/~simon/ ;; If God does not write LISP, God writes some code so similar to ;; LISP as to make no difference.
* Eric Gouriou <egour...@cup.hp.com> | [Some character attack on Scott McKay]
Really? Well, this just goes to show some people can't read anything eyond what they already believe in.
| Please keep your comments to yourself if you cannot manage a minimal | level of civility.
Sure, I'll make sure to ask you every time I conclude that I do, and you probably don't.
| These are not advocacy newsgroups and your flames are uncalled for.
And here I was thinking that what I replied to was a nasty attack, but, hey, this just goes to show that some people will excuse juat about anything if it comes from one of their own.
| I tried to make this point privately and politely a few hours ago, | but my mail bounced. Either there was a technical problem or the | mail address you provide when posting is invalid.
And this shows me that you aren't interested in being helpful or constructive. _Any_ programmer knows that having some user draw his own conclusions about what might be the problem is useless; the _only_ useful thing to do is to report the problem _accurately_, and since you don't do that with something so simple as an error message from SMTP (I got a useful message from somebody else who experienced the same problem), there's now _some_ reason not to trust whatever else you conclude, too.
| For the record, I do not remember any post from Scott McKay where | he failed to be professional and helpful.
Probably true, but I didn't respond to your memory. I responded to an actual message from Scott McKay where he acts incredibly insulted and retorts in worse kind. Most people are nice when they are safe and not challenged in any way. What's important is what it takes to make them feel unsafe or challenged and what they do then. Many people are nice only because they suppress feelings of being unsafe or challenged, and then they turn into veritable psychopaths when they feel they have a "right" to cease being nice, such as when they feel that empathy can be withheld. Don't be misled by someone's history as being nice once they are being pushed -- Scott McKay has obviously never had to defend Dylan and its syntax before, and he turned into a nutcase as soon as he had to. _That's_ important.
| I was expecting at least as much from a Lisp advocate - due to the | respect I have for Lisp and its users.
I'm not responsible for your desire to think in group terms.
#:Erik -- If this is not what you expected, please alter your expectations.
in article 3171546824561...@naggum.net, Erik Naggum at e...@naggum.net wrote on 7/2/00 10:13 AM:
> Most people are nice when they are safe > and not challenged in any way. What's important is what it takes to > make them feel unsafe or challenged and what they do then. Many > people are nice only because they suppress feelings of being unsafe > or challenged, and then they turn into veritable psychopaths when > they feel they have a "right" to cease being nice, such as when they > feel that empathy can be withheld.
So from the tone of your writings I guess you're describing yourself here then :-)
I'm sorry to read you have such a negative view of human nature. People can be so nice when treated with respect. This effect tends to be amplified when they realise you continue to be respectful even when they know they are being disrespectful to you. That's when they will often start to respect you at a deeper level. (That's my reality anyway, hope it will be yours too one day!).
Live well, António
---------------------------------------- Disapprove of sin but not of the sinner! ----------------------------------------
> So from the tone of your writings I guess you're describing yourself here > then :-)
> I'm sorry to read you have such a negative view of human nature. People can > be so nice when treated with respect. This effect tends to be amplified when > they realise you continue to be respectful even when they know they are > being disrespectful to you. That's when they will often start to respect you > at a deeper level. (That's my reality anyway, hope it will be yours too one > day!).
> Live well, > António
Isn't it wonderful how we all teach each other how to behave? Maybe we should consider changing the name of the NG (I hope the second 'we' is not an insult to anybody). J.B.
* António Nunes <to...@euronet.nl> | So from the tone of your writings I guess you're describing yourself | here then :-)
You need to guess less and think omre.
| I'm sorry to read you have such a negative view of human nature.
You need to guess less and think more.
| People can be so nice when treated with respect.
Now, how does that _really_ differ from what I said?
| This effect tends to be amplified when they realise you continue to | be respectful even when they know they are being disrespectful to | you.
Well, I think this is an excellent idea. However, in keeping with the very simple concept of "puting your money where you mouth is", I wait for those who proclaim a principle to apply it to themselves. Anybody can expound on some principle he wants _others_ to apply, but if you refrain from applying it to yourself, you communicate a quality of the advice given that is extremely unflattering: If it isn't good enough for yourself, why should anyone take your advice?
| That's when they will often start to respect you at a deeper level. | (That's my reality anyway, hope it will be yours too one day!).
It amazes me that you start off your "respectful" message with a disrespectful grin, instead of just _doing_ what you recommend. Such hypocrisy is utterly _disgusting_ to watch. Just quit it.
#:Erik -- If this is not what you expected, please alter your expectations.
Erik Naggum wrote in message <3171498017446...@naggum.net>...
I've trimmed all of Erik's lame attempts to hurl insults at to spare everyone the trouble of re-reading them. Since Erik's return mail address appears not to work, it's not actually possible to address any of this in private.
>| Well, except from you, who evidently could not care less for the >| genuine effort spent making Dylan's infix syntax reasonable.
> So you really are _personally_ offended, now, huh? Geez, get over > yourself. If you can't deal with negative comments on your work in > public, it would be a good thing for you to try to avoid defending > _yourself_. But why spend so much _genuine effort_ at something > that you claim is _trivial_ towards those who _don't_ like it? Just > how do you propose that I reconcile your clear disdain for syntaxes > (other than your own) with that whining about respecting your work?
For the record, I had no part in designing Dylan's infix syntax. It was a fait accompli by the time I started doing any work on Dylan. I should have thought that my comment earlier in this discussion about how I was surprised to discover that I liked the infix syntax would have clued people in to that fact. So I don't take any personal offense at all.
* "Scott McKay" <s...@mediaone.net> | Since Erik's return mail address appears not to work, it's not | actually possible to address any of this in private.
This is really interesting. I have logged an attempt to send mail from s...@mediaone.net via chmls06.mediaone.net [24.147.1.144] port 42508 at 2000-07-01 23:40:41.218 UTC, and your posted this silliness 2000-07-03 00:08:47 UTC, more than 24 hours later. This is quite telling, actually, since you blithely assume that a problem properly reported (which a Lisp user did to another address (which anyone who knows about WHOIS would have found in no time), but another Dylan user whined about it in a very useless way in public) would not get fixed for 24 hours, even when it concerns such a terribly important basic network service as e-mail.
With such an attitude towards software problems, nobody should care what that person might have to say about programming _languages_.
#:Erik -- If this is not what you expected, please alter your expectations.
>>>>> "The" == The Glauber <theglau...@my-deja.com> writes:
The> It's bothersome to have to learn the new language-du-jour...
Reiterates my own decision not to trust a language whose age in decades may be counted with a single finger. :-)
---------------------------+----------------------------------------------- --- Christian Lynbech | Ericsson Telebit, Fabrikvej 11, DK-8260 Viby J Fax: +45 8675 6881 | email: c...@ericssontelebit.com Phone: +45 8675 6828 | web: www.ericssontelebit.com ---------------------------+----------------------------------------------- --- Hit the philistines three times over the head with the Elisp reference manual. - peto...@hal.com (Michael A. Petonic)
* Scott McKay wrote: > Hey, look, if the only thing that Lispers care about is having > Lisp syntax, then they are as closed-minded as the C and Java > communities. Syntax is trivial. Get over it.
I kind of agree, but the world doesn't seem to: look at XML. One of the great advantages of Lisp syntax, I think, is that it gives you everything useful that XML does, without the nauseating complexity. Of course Lisp somehow managed to fail to take advantage of this, so people are now busy implementing XML interfaces to Lisp, but that's just the usual Lisp `x, 4 years too late' syndrome.
> That's the first time I've seen someone describe a profusion of parentheses > as "clean".
Hint: Write down a grammar for Lisp. Write down a grammar for Dylan (or C, or C++, etc.). Compare their sizes.
HAND, Jens.
(Oh, and good luck with the C++ grammar ;-) -- mailto:j...@acm.org phone:+49-7031-464-7698 (HP TELNET 778-7698) http://www.bawue.de/~jjk/ fax:+49-7031-464-7351 PGP: 06 04 1C 35 7B DC 1F 26 As the air to a bird, or the sea to a fish, 0x555DA8B5 BB A2 F0 66 77 75 E1 08 so is contempt to the contemptible. [Blake]
> - I like Dylan's type system. I like that the "built-in" types fix into > the type system in a clean and consistent way. I like that you > can use it "typeless" but can then clamp down the types to get > better code,
Up to here, I don't believe there is any real difference to CL. Not that you are comparing...
> and more importantly, better compile-time error > detection. Going back to Lisp makes me fell butt-naked on the > type safety front; as the static-type people have been saying > for years, a lot of errors really are type errors, and Dylan does > a good job catching these.
This I simply no longer agree with. Well, for all I know _you_ do feel "butt-naked" w/o static typing, but I don't believe there is any significant objective reality to the proposition that it really helps find errors or helps clear up design issues, or whatever.
I used to believe that it _did_ help a lot with errors (well, more or less), and it is certainly true that you can give some pretty good arguments that static typing _should_ make a difference here, but in practice it turns out to mean more or less nothing. At least in our experience. Having built some large (and more importantly, _complex_) stuff in statically typed languages (Ada95, Java) as well as Common Lisp, Common Lisp turns out to be significantly better wrt catching and eliminating errors. This is even more true wrt "real" bugs - logic errors. I actually kept a log on the number of errors that a statically typed language would have saved me from at runtime (note: this is the only real difference - it is important to realize that the error _will_ be caught with dynamic typing just as well as with static typing).. This currently amounts to 3 simple typos in 2MB of source.
If you are working on true safety critical and/or mission critical control software, then the very small potential advantage of static typing preventing a runtime error is clearly still worth it. However, in anything else it is more than made up for by the true dynamicism, flexibility, and inherently easier to test (and thus more likely to be fully tested) approach provided by environments like Common Lisp.
> - I am surprised to say that I have come to like the infix syntax. > For one, using type decls in Dylan is a lot easier than in Lisp,
I don't think this has anything to do with "infix syntax".
> - I like Dylan's hygienic macro system. If we adopted Keith > Playford's work on procedural macros, Dylan's macros would > be very nearly as powerful as Lisp's,
Presumably this means these would allow complete use of the entire language and any user defined functions and macros for processing at compile time. However, that didn't happen and (even though you try to claim otherwise) it is likely that the effort to make this all work smoothly with the significantly more difficult syntax had a lot to do with this.
> not to patch it up with kludgy method combination. If you think > you haven't used kludgy method combination, I bet you're wrong.
I haven't, and you'd be wrong. If there is any inherent problem here it is that people use OO for things for which it shouldn't be.
/Jon
-- Jon Anthony Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383 "Nightmares - Ha! The way my life's been going lately, Who'd notice?" -- Londo Mollari
the parens take up very little room and don't get in your way. notice how much more descriptive words lisp allows compared to the required boilerplate of C/C++. with-open-file only looks long compared to fopen, but the former does *so much more*.
in general, i find that lisp programs are *much* shorter and more concise than in other languages. this is least apparent with short program stumps like in the above post. the gap is very wide once you program anything of even modest size.
i admit that the boilerplate mishmash of parens, braces and semicolons can help a human find their way, e.g., i think C's for (;;){} is easier than lisp's (do ()()()). however, C's semi-random assortment of statement seperators comes at a very high cost. look how feeble C's macros are compared to lisp. do not be penny wise and pound foolish.
imho the simple syntax of lisp is a *huge* advantage for lisp.
-- J o h a n K u l l s t a m [kulls...@ne.mediaone.net] Don't Fear the Penguin!
