[jrq]

R7RS large is underway now! CL also has unhygienic macros, non-lispy loop grossness, lots of cruft, lots of poorly named functions that are named two different ways in two different places, and generally reeks of the 70s.

Scheme actually tried to compete with CL once, with a language called T. It had something sorta similar to CLOS and if I recall it was aiming for optimized performance per Sussman and Steele, but it eventually languished.

SBCL is the only thing keeping CL alive and they don't have the wherewithall to begin a modernized spec.

I don't hate CL, but I LOVE scheme. It is much more pleasant to actually work in, and feels cleaner. All the potholes of CL leave me checking under my fingernails for grime.

[lispm]

> generally reeks of the 70s

Scheme was implemented as a clean toy/educational Lisp on top of Maclisp in the mid 70s.

Scheme was defined too small upto R5RS and in R6RS is got unlispy.

> Scheme actually tried to compete with CL once

It never really did, since all implementations were different. There are lots of great Scheme implementations (MIT Scheme, Chez Scheme, ...) - but all were different. Then a bunch of extension were bolted onto Scheme - but the base was too small.

> It is much more pleasant to actually work in, and feels cleaner.

Which Scheme? Chicken Scheme? Racket - which is no longer a Scheme? Kawa? They are cleaner than CL?

The last clean Scheme was R5RS - and that was underspecified as a programming language.

Whenever I used Scheme I missed keyword arguments, CLOS, LOOP, optimization declarations, type declarations... Oh, wait. All those and much more has been added to Scheme in some ways. Unfortunately the result does not look 'cleaner'.

Chicken Scheme:

    (define-method (pop (stack <stack>))
      (let* ((c (slot-value stack 'content))
             (x (car c)))
        (set! (slot-value stack 'content) (cdr c))
        x))

Let's see how it's written in Common Lisp:

    (defmethod stack-pop ((s stack)) 
      (pop (slot-value s 'content)))

[eadmund]

> CL also has unhygienic macros, non-lispy loop grossness, lots of cruft, lots of poorly named functions that are named two different ways in two different places, and generally reeks of the 70s.

That's all true enough; I believe that non-hygienic macros are a vital capability of a programming language (and Common Lisp being a Lisp-n makes them much less of a problem), and that LOOP is okay. I don't mind the cruft much: it's a mostly-backwards-compatible language, and backwards-compatibility is important; it's why Lisp code from the 80s can still run now, almost 40 years later.

I don't hate Scheme, really: it's a very neat little language. But it's completely unsuited for production work on large systems, which are what I'm interested in. Case in point: call/cc. It's nifty, really cool and absolutely has no place in any production system — it's ultimately just a very-lightly-structured GOTO.