Scheme vs. CLisp: THE ULTIMATE BATTLE

Alright fellow sinister /prog/s, which is superior, Scheme or Common Lisp?

VOTE NOW

Scheme is conceptually the much nicer languag

Scheme. No contest.

Lisp, No context.

>>2
Yeah, I like Scheme too, becaus

http://dis.4chan.org/read/prog/1257896532


________________________________
http://bayimg.com/image/aadbjaace.jpg
My Blog: http://frozenvoid.blogspot.com/
«Happiness is not achieved by the conscious pursuit of happiness; it is generally the by-product of other activities.»

Scheme is cleaner conceptually, but that's about it.
Common Lisp is based on older Lisp concepts(on which Scheme is based too), and it takes some good ideas from Scheme(such as lexical scope), while retaining older Lisp concepts too, it also adds a cool object systems, proper error handling, a  large, useful and well-thought of "library", optional dynamic scoping, a very nice condition system, fine control over the compiler/evaluator, separate function/variable namespaces, packages, real macros, a large variety of native types, key/rest/optional args, and many more. You can implement a lot of these in Scheme, but that's the problem, you HAVE to implement them, or use some libraries which are not portable across Scheme implementations, to achieve what you get out of the box in any of the CL implementations. This doesn't mean CL doesn't have this problem to a slight degree: networking, FFI and threading is not standardized, which means people have written compatibility layers to achieve this across different CL implementations, but it's not a real problem for most Lispers.

This makes CL an instrustrial-strength Lisp, making it fit for practical usage, while Scheme is a theorethically beautiful, distilled Lisp, which is liked by academics. Since I prefer writing real applications, I find Common Lisp considerably more useful.

Withholding response until "big" R7RS comes out.

>>8
U MENA REVISED REVISED REVISED REVISED REVISED REVISED REVISED REPORT

That's like asking whether gonorrhea or chlamydia is better.

>>7
scheme is conceptually cleaner, but requires actual programming ability instead of canned macros I downloaded from the interbutts

>>7
Scheme is cleaner also practically. It has been designed instead of evolved, which means that the language and standard libraries (SRFI) are consistent and logical instead of just random shit thrown together, for instance in the naming. E.g. SRFI 1 vs CL: APPEND and APPEND! vs APPEND and NCONC, FILTER and FILTER! instead of REMOVE-IF and DELETE-IF.
The CL philosophy seems to be "solve a problem halfway, then ignore or work around the consequences". For example, dynamic variables. In SRFI 39, they are lexically scoped objects with dynamic values, which means you can export/import/rename them etc. In CL, they are simply symbols which may give you a nasty suprise in case two unrelated pieces of code happen to use the same name for a dynamic variable.
Then of course there are macros. In CL you get a bunch of symbols and return a bunch of symbols; in Scheme you get a bunch of bindings and return a bunch of bindings. CL is fragile: you must make sure your symbols don't have another meaning where they are expanded, leading to hacks like "don't ever shadow a built-in function", "generate temporary names with GENSYM" and "always refer to my package variables as MY-PACKAGE:VARIABLE".
Finally, the whole image thing. Common Lisp likes to conflate read-time, macro-time, run-time, eval-time and whatever I forgot. Where in Scheme I might define some crazy language with normal Scheme macros, in CL you either have normal and normal or crazy and crazy. With a package manager like ASDF you never know if you have undeclared dependencies between packages that just happened to load in the right order (until it breaks of course). Distributing compiled code means dumping a >60MB image because you never know what's needed.
I could go on and on, but I think my point is clear:
Scheme is more useful because Common Lisp is a giant mess.

>>11
I think everyone that learns Common Lisp seriously, also learns how to implement most CL features. I would have no problem implementing most of the features presented in the CL standard, except for CLOS and MOP, which I can use, but don't know its every detail.
>>12
The names are there for compatiblity with older CL code, and there's a lot of it, think of the past 20-30 years. Most people will get around to knowing the symbol names in due time anyway.
I never had problems with dynamic variables myself, and neither should you, if you use packages properly and follow the established conventions. It's also possible to implement one's own dynamic variables which work more like those in SRFI 39.
you must make sure your symbols don't have another meaning where they are expanded
Non-problem in Lisp-2, and if in some strange circumstance becomes a problem, you can use the package system to fix it, and good macro writing practice requires one to use gensym's.

With a package manager like ASDF
ASDF is not a package manager. It's a system manager. It doesn't have anything to do with packages, but with the order systems are build and their dependencies. ASDF is not perfect, but it works fairly well, and there are alternatives to it. ASDF is just a defacto community standard and is not specified in the spec. You could implement your own defsystem manager (and there are others besides ASDF out there, some compatible with it) if you wished to.
Distributing compiled code means dumping a >60MB image because you never know what's needed.
Usually it's 5-20mb depending on your Lisp implementation. Some provide tree shakers, if you wish to cut down on the size.
Common Lisp likes to conflate read-time, macro-time, run-time, eval-time and whatever I forgot.
They are separate, but any one can invoke the other, depending on how you write your code. The user should be conscious about what he means when he writes it.

I've had problems with some of the issues you mentioned when I first learned CL, but I don't see most of them as issues at all, now that I have a better understanding of the language.

Did I mention that it's possible to make a hygienic macro system in CL? Pascal Constanza has an example on how to implement it http://p-cos.net/documents/hygiene.pdf
As for the retained names for compatiblity purposes. Doesn't Scheme also have car/cdr/cadr and others? The "modern" names are first/rest/second. I don't think of this as a major problem with the language. If you want a cleaner Lisp, just make your own package and import what you want from CL, and write what you want yourself.

<Riastradh> eli, hey, cool, Pascal Costanza has figured out that you can implement a hygienic macro system on top of an unhygienic macro system without writing a code walker: <http://p-cos.net/documents/hygiene.pdf>;. All you have to do is replace all of the binding forms such as LAMBDA...
*Riastradh coughs.
<Riastradh> I like this line: `To keep things manageable, we have not reimplemented all of Common Lisp, but restricted ourselves to ISLISP, which is mostly a small but non-trivial subset of Common Lisp.'

Scheme has c[ad]+r and the 'modern' names in SRFI 1, but car and cdr are useful because they are meaningless and don't imply the cons is part of a list.

It's almost like I'm reading miniature c.l.s vs c.l.l crossposted flamewars.

>>1
Scheme vs. CLisp
Hmm, you seem to be comparing a programming language with an implementation. Please come back when you aren't retarded (i.e. never).

Clojure.

>>17
Hmm, you seem to be soem kind of elitist fuckwit that thinks you know shit.

>>17(elitist asshole)
>>19(retard)
typical Lisp programmers

I like Python

>>21
I like your sister

>>18
Oh yeah Lisp in Java, GREAT IDEA!

>>23
Actually, it is.

>>24
Actually, it isn't.

>>22
I like your gay

Common lisp may be better for real world lisp usage due to its beefier feature set but this neglects the fact that nobody in their right mind would use lisp in the real world.  Thus scheme wins, but lets face it if your comparing Scheme and CLisp you've already lost not matter what.

>>21
I like turtles Logo.

>>27
Yes, because you've achieved satori and realized the sorry state of affairs in the programming world around you, which cannot be unseen, and requires a zen mind to avoid sinking into suicide.

nobody in their right mind would use lisp in the real world.
At last!