Subject: Re: Which one, Lisp or Scheme? From: Erik Naggum <email@example.com> Date: 1997/02/01 Newsgroups: comp.lang.lisp,comp.lang.scheme Message-ID: <firstname.lastname@example.org> I find it symptomatic of Schemers attacks on Common Lisp that they are ignorant, arrogant, and so devoid of correctnes and precision as to merit no other badge than "prejudice". * Ray S. Dillinger | In scheme, a function is simply a value, like a number or a string. In | CL, a function is in a separate class -- it has to be funcalled for | example if you're evaluating to it. Ray, you don't know what you're talking about. it also looks as if you don't know what a namespace is. a namespace is simply a mechanism to refer to objects by names taken from different sets of possible names. whether an object is found by a name in one namespace or in another makes no difference to the object. you seem to believe it does. let me paraphrase your complaint with an example of a similar complaint about Scheme: in CL, a function is simply a value, like a number or string. to use any value as a function, apply `funcall' to it. in Scheme, a value has to be placed first in a form if you wish to call it as a function. this is unlike the use of any other variable, which do not need this special position in a form when using their value. I guess you will automatically think the above is a specious argument, and will ignore it, without having taken the care to examine the fact that it is entirely valid, and that its main function is to show that your position is not one of understanding. occasionally, we hear that syntax is unimportant, that what matters is the semantics of languages, indeed that arguments about syntax are _invalid_ because all languages are Turing equivalent. however, when some Scheme users need to debunk Common Lisp, it is tragically common for them to stumble in the syntax, and make such utterly false accusations as the above complaints about namespaces. let's look at one of your ignorant, invalid examples: | ((function-that-returns-another-function) argument1 argument2) vs | (define-function ?foo (function-that-returns-another-function)) | (funcall ?foo argument1 argument2) I find it interesting that most Common Lisp users who criticize Scheme do so with syntactically correct Scheme programs or real examples, whereas Scheme users who criticize Common Lisp generally don't have a clue. here's how it would be done by somebody who had actually _seen_ Common Lisp: (funcall (function-that-returns-another-function) argument1 argument2) | I'm just guessing about the use of the define-function syntax; I must | admit it's darn weird as far as I can tell to have different defines for | everything when it's only one operation. maybe if you didn't guess as much, you wouldn't make a fool of yourself. and if you had paid attention, you would have known that it isn't only one "operation" that is performed by differently-named functions, unless you define "operation" so generally as to make all computers perform the same operation, namely heat their immediate surroundings. I wonder why so many people who love Scheme tend to be so unbelievably arrogant in their belief that Scheme is superior that they don't even bother to _learn_ anything about the languages they compare to. this really makes me wonder what made them love Scheme in the first place. it surely cannot be intelligent, rational, or informed balancing of features. it cannot be based on a desire to study and learn languages. instead, Ray, explains to us, it's based on "a trifling effort of memorization and practice", if I understood what he meant by that, alien as it is to me. | But the point is that functions are treated differently than other values | in CL. that may be your point, but it is a _fact_ that functions are treated just like other values in Common Lisp. the difference between Common Lisp and Scheme is that Scheme evaluates the first element of a form to find which function to call, whereas Common Lisp regards the first element of a form as a constant symbol, and looks up the function definition of that symbol. I'm rather surprised by the many Scheme users who fail to understand such a simple _fact_, instead preferring to make various bogus "points". every such "point" reduces the credibility of the entire Scheme community. | You can't insert a subexpression evaluating to your function in place of | the function the way you can with any other value. yes, you can. the problem is that you're very confused, mostly because you treat Common Lisp as if it were Scheme, and then complain when it isn't. Common Lisp does not _evaluate_ symbols to a function. period. | You can't use your standard assignment statement to assign a value to a | variable if that value happens to be of type function. Ray, you don't know what you're talking about. | And numerous other warts and inconsistencies. I'm sorry to say that you seem to produce the warts you wish to attack straight out of thin air, and that you wouldn't find half as many if you had bothered to study Common Lisp before your ignorant attacks on it. | But Scheme has the cleanest, simplest, and most consistent rules of | operation and evaluation of any language I've ever come across, and that | enables me to write correct programs much more easily; I always know | exactly what an operation means, because it always means exactly the same | thing, and doesn't have weird exceptions like "you can always substitute | an expression evaluating to a value for the value itself in any | expression -- UNLESS it's a function..." and "the value of ?foo is 27 -- | UNLESS it's the function ?foo instead of the variable ?foo -- and so on. I find this entertaining. you don't know diddlysquat about Common Lisp, yet speak with a stunning degree of certainty in which you prove beyond _any_ reasonable doubt that you don't even care to look things up, yet you know _exactly_ what Scheme does. yeah, right. I think the latter is pure hyperbole -- that the degree to which you "know exactly" what Scheme does is the same degree to which you know vaguely how Common Lisp works. perhaps the difference between Scheme and Common Lisp programmers is that the Common Lisp programmers _know_ they need to look things up, whereas the Scheme programmers always _think_ they never need to. I guess that's also why Common Lisp has documentation strings and Scheme doesn't. the lack of documentation strings has always bothered me in Scheme. (yes, it's been rehashed a few times. I know all the arguments.) | That, I suppose, is why I love scheme -- no other language gives me such | returns of precision and capability for such a trifling effort of | memorization and practice. this is _very_ amusing. your utter lack of precision in your description of Common Lisp really drives a stake through the heart of your arguments. but I guess that's the _real_ return you get from a trifling effort of memorization and practice. why do so few Scheme users seem to care enough to be accurate? could it be influence from the language? or could it be that people who _don't_ care flock to Scheme? I'm led to wonder by the many Scheme proponents who like to attack strawmen and problems only of their own imagination. #\Erik -- 1,3,7-trimethylxanthine -- a basic ingredient in quality software.