That the syntax of Scheme (from 1975) is more modern than the syntax of CL (from 1984) is a myth. It's more primitive. Later people added lots of features to Scheme, which were already in CL. Take keyword arguments... In essence Scheme is actually less elegant due to its too small design and the many bolted on features.
Chicken:
((lambda (x y #!optional z #!rest r #!key i (j 1))
(list x y z i: i j: j))
3 4 5 i: 6 i: 7)
=> (3 4 5 i: 6 j: 1)
CL:
((lambda (x y &optional z &rest r &key i (j 1))
(list x y z :i i :j j))
3 4 5 :i 6 :i 7)
=> (3 4 5 :I 6 :J 1)
Is the CL code more crufty compared to the almost equivalent Scheme code? Sure not. or is #!optional now more modern than &optional?
Guess where the Chicken feature originally came from ...
The difference: the CL code works in every CL implementation.
> and the ability to compile down to C.
There are many implementations which do that. SBCL has the ability to compile to optimized native code with a type-inferencing compiler...
Chicken is a great implementation with a nice ecosystem, but that it is more elegant than CL - while it copies lots of features from CL (like COOPS copies from CLOS) - is an illusion.
http://wiki.call-cc.org/eggref/4/coops
> COOPS provides classes, generic functions and methods, similar in style and use to the classic Lisp object systems like Flavors, Loops or CLOS. For general information about object-oriented programming in the context of Lisp, consult one of the various books and guides available to the subject.
Example:
Chicken:
(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 in Common Lisp:
(defmethod pop ((s stack))
(let* ((c (slot-value s 'content))
(x (car c)))
(setf (slot-value s 'content) (cdr c))
x))
Which is more modern? To me it looks the same. The difference: the CLOS code runs in every CL implementation.