59nadir on One Major Difference Between Clojure and Common Lisp

Comment on One Major Difference Between Clojure and Common Lisp parent

I find that interesting, considering that most of the points you raised about Clojure not being a Lisp would indicate that you think Racket is a Lisp.

You've also been nothing but vague in terms of what makes Racket not a Lisp, which is ironic considering your previous argument that we should have more clearly defined requirements for what makes a Lisp, but I'm beginning to think that this was mostly hot air.

I think you've mostly proven that the 'vague' definition serves a much more practical purpose than your seemingly arbitrary distinction between these languages, and it will continue to do so, as it implies far more than you've displayed in this thread.

lispm 10y

You've also been nothing but vague in terms of what makes Racket not a Lisp

True, and I have to apologize for that. But I don't have the time, nor the priority to go into full detail. The main points are: different community, different goals, almost zero code sharing, different technical solutions, different literature, ... The differences are technical and social. Each of the points would need more explanation, for which I don't have the time.

For me 'Lisp' is something practical. I have a bunch of non-trivial code -> can I compile/load it? Can I port it easily? Are there people who would be interested to share? What are they using? Can I work with them?

Example:

Macsyma is an old Lisp program. New Lisp dialects appeared. Macsyma was ported to them: Maclisp, Franz Lisp, NIL (New Implementation of Lisp), Lisp Machine Lisp, VaxLisp, Common Lisp...

This software can't be ported to Clojure or Racket, without fully re-architecting the software, and I'm only thinking about the basic Macsyma, without GUI or other system dependent parts.

that the 'vague' definition serves a much more practical purpose

which one? to confuse people? To raise expectations of collaboration in a community, which are then not fulfilled?

dragonwriter 10y

It's true that it is more difficult to port from Common Lisp or other Lisp-2 dialects to Scheme, Racket, or Clojure (which are Lisp-1 dialects) than it would be to port to other Lisp-2 dialects. But that certainly doesn't make Lisp-1 dialects "not Lisp" while Lisp-2 dialects are "Lisp".

lispm 10y

Porting code from Lisp-2 to Lisp-1 is not that difficult.

Example:

Lisp-2:

    (defun new-map (f l)
      (dolist (e l)
        (funcall f e)))

Lisp-1:

    (defun new-map (f l)
      (dolist (e l)
         (f e)))

Another example:

Lisp-2

    (defun foo (l)
      (flet ((new-map (f l)
               (dolist (e l)
                  (f e))))
        (new-map (function sin) l)))

Lisp-1

    (defun foo (l)
      (let ((new-map (lambda (f l)
                       (dolist (e l)
                         (f e)))))
        (new-map sin l)))

To make it easier, just define FUNCALL, FUNCTION and FLET in Lisp-1...

Comments