9 ms·

"SICP uses Scheme, which is not Lisp." --- is that a "no true Scotsman" argument or do you just mean "Scheme is not Common Lisp"?

ScottBurson 9y ago
I'm guessing the latter.
Jach 9y ago
I mean Scheme is not Common Lisp, and Common Lisp is Lisp. Both are "a Lisp" (as is Clojure), or perhaps "a dialect of Lisp", but it's questionable if that really means anything beyond s-exps and macros.
- amackera 9y ago
  So when somebody says "I am going to write some Lisp now", in your mind they are always going to write Common Lisp?
- openasocket 9y ago
  Why does Common Lisp get the distinction of being the "true Lisp" and not Scheme? Scheme precedes Common Lisp by almost a decade
  - Jach 9y ago
    Naggum has a pretty good answer for that, linked in the other comment branch: http://www.xach.com/naggum/articles/3224964049435643@naggum.net.txt http://www.xach.com/naggum/articles/3224964049435643@naggum.... You could also argue based on things like Common Lisp can run LISP code from 1960 with a very small driver, or the general history of code porting and sharing, as done here: https://news.ycombinator.com/item?id=9387131#9404543 https://news.ycombinator.com/item?id=9387131#9404543
    - openasocket 9y ago
      I read that answer, I didn't find it helpful on two points. 1. There's this really nice analogy about German and English languages, but it doesn't have any specifics. In particular, the crux of his entire argument is in this statement > The two languages and their attendant communities have drifted so far apart that there is nothing of value in their intersection. Which he simply states as fact without any sort of follow up or justification. And I disagree. Consider this Common Lisp snippet from Wikipedia computing the answer to the birthday paradox: (defconstant +year-size+ 365) (defun birthday-paradox (probability number-of-people) (let ((new-probability (* (/ (- +year-size+ number-of-people) +year-size+) probability))) (if (< new-probability 0.5) (1+ number-of-people) (birthday-paradox new-probability (1+ number-of- people))))) Literally replace "defconstant" with "define" and "defun birthday-paradox (probability number-of-people)" with "define (birthday-paradox probability number-of-people)" and that's valid Scheme. I'll readily admit they are two different languages, but pretending they are as different as C and Python or something is absurd. 2. Even if you convince me these two languages are so different, there's nothing here to convince me Common Lisp deserves the title of the "real Lisp" or "true Lisp". Scheme can also run LISP code from 1960 with a very small driver.
      - Jach 9y ago
        Is it that absurd? Where is Scheme's CLOS, condition system, built-in debugging framework, and batteries-included standard library? Type declarations? Dynamic scoping? Multi-methods? Maybe Racket (or Chicken or Chez or Guile or...) has all of these things, Racket is pretty awesome, but those things aren't standardized, whereas I can get those things in Lisp regardless of if I use SBCL/Clozure/clisp/etc. Maybe it's closer to the difference between C (with a bunch of different compiler extensions) and C++ than C and Python, but it's a pretty big difference. Ultimately I think the claim of Common Lisp being the "true Lisp" is simply that deciding such a thing was the whole point of Common Lisp. Without a standard, you're left with someone writing http://wiki.call-cc.org/eggref/4/multi-methods#examples http://wiki.call-cc.org/eggref/4/multi-methods#examples (or http://wiki.call-cc.org/eggref/4/fast-generic http://wiki.call-cc.org/eggref/4/fast-generic) and someone else writing https://docs.racket-lang.org/multimethod/index.html https://docs.racket-lang.org/multimethod/index.html and neither being able to share code with each other. Most code isn't as trivial as the birthday paradox. Would you want to try writing a (R6RS) Scheme driver for that 1960 code and see how straightforward it is? Where do you slot https://en.wikipedia.org/wiki/Dylan_(programming_language) https://en.wikipedia.org/wiki/Dylan_(programming_language) ? Should it be in the running for "the true Lisp"? If not why not?
  - lispm 9y ago
    This Lisp I code is from 1959/60. http://bitsavers.informatik.uni-stuttgart.de/pdf/mit/rle_lisp/LISP_I_Programmers_Manual_Mar60.pdf http://bitsavers.informatik.uni-stuttgart.de/pdf/mit/rle_lis... Page 101: DEFINE (((COLLAPSE,(LAMBDA,(L),(COND,((ATOM,L),(CONS,L,NIL)), ((NULL,(CDR,L)),(COND,((ATOM,(CAR,L)),L),(T,(COLLAPSE, (CAR,L))))),(T,(APPEND,(COLLAPSE,(CAR,L)),(COLLAPSE,(CDR,L)))))))) This is the Common Lisp version. Formatted, comma removed, DEFUN instead of DEFINE. Other than that the code is unchanged. It still works in Common Lisp. (DEFUN COLLAPSE (L) (COND ((ATOM L) (CONS L NIL)) ((NULL (CDR L)) (COND ((ATOM (CAR L)) L) (T (COLLAPSE (CAR L))))) (T (APPEND (COLLAPSE (CAR L)) (COLLAPSE (CDR L)))))) CL-USER 191 > (collapse '(1 2 (3 4) ((5 6) 7))) (1 2 3 4 5 6 7) Common Lisp is backwards compatible to Lisp I and Lisp 1.5 in many ways. Code like that can be relatively easy ported to Scheme (naming and syntax is slightly different). There are examples which are more difficult. But generally simple (!) Scheme is not that far away from that old core.

ScottBurson 9y ago

I'm guessing the latter.

Jach 9y ago

I mean Scheme is not Common Lisp, and Common Lisp is Lisp. Both are "a Lisp" (as is Clojure), or perhaps "a dialect of Lisp", but it's questionable if that really means anything beyond s-exps and macros.

amackera 9y ago
So when somebody says "I am going to write some Lisp now", in your mind they are always going to write Common Lisp?
openasocket 9y ago
Why does Common Lisp get the distinction of being the "true Lisp" and not Scheme? Scheme precedes Common Lisp by almost a decade
- Jach 9y ago
  Naggum has a pretty good answer for that, linked in the other comment branch: http://www.xach.com/naggum/articles/3224964049435643@naggum.net.txt http://www.xach.com/naggum/articles/3224964049435643@naggum.... You could also argue based on things like Common Lisp can run LISP code from 1960 with a very small driver, or the general history of code porting and sharing, as done here: https://news.ycombinator.com/item?id=9387131#9404543 https://news.ycombinator.com/item?id=9387131#9404543
  - openasocket 9y ago
    I read that answer, I didn't find it helpful on two points. 1. There's this really nice analogy about German and English languages, but it doesn't have any specifics. In particular, the crux of his entire argument is in this statement > The two languages and their attendant communities have drifted so far apart that there is nothing of value in their intersection. Which he simply states as fact without any sort of follow up or justification. And I disagree. Consider this Common Lisp snippet from Wikipedia computing the answer to the birthday paradox: (defconstant +year-size+ 365) (defun birthday-paradox (probability number-of-people) (let ((new-probability (* (/ (- +year-size+ number-of-people) +year-size+) probability))) (if (< new-probability 0.5) (1+ number-of-people) (birthday-paradox new-probability (1+ number-of- people))))) Literally replace "defconstant" with "define" and "defun birthday-paradox (probability number-of-people)" with "define (birthday-paradox probability number-of-people)" and that's valid Scheme. I'll readily admit they are two different languages, but pretending they are as different as C and Python or something is absurd. 2. Even if you convince me these two languages are so different, there's nothing here to convince me Common Lisp deserves the title of the "real Lisp" or "true Lisp". Scheme can also run LISP code from 1960 with a very small driver.
    - Jach 9y ago
      Is it that absurd? Where is Scheme's CLOS, condition system, built-in debugging framework, and batteries-included standard library? Type declarations? Dynamic scoping? Multi-methods? Maybe Racket (or Chicken or Chez or Guile or...) has all of these things, Racket is pretty awesome, but those things aren't standardized, whereas I can get those things in Lisp regardless of if I use SBCL/Clozure/clisp/etc. Maybe it's closer to the difference between C (with a bunch of different compiler extensions) and C++ than C and Python, but it's a pretty big difference. Ultimately I think the claim of Common Lisp being the "true Lisp" is simply that deciding such a thing was the whole point of Common Lisp. Without a standard, you're left with someone writing http://wiki.call-cc.org/eggref/4/multi-methods#examples http://wiki.call-cc.org/eggref/4/multi-methods#examples (or http://wiki.call-cc.org/eggref/4/fast-generic http://wiki.call-cc.org/eggref/4/fast-generic) and someone else writing https://docs.racket-lang.org/multimethod/index.html https://docs.racket-lang.org/multimethod/index.html and neither being able to share code with each other. Most code isn't as trivial as the birthday paradox. Would you want to try writing a (R6RS) Scheme driver for that 1960 code and see how straightforward it is? Where do you slot https://en.wikipedia.org/wiki/Dylan_(programming_language) https://en.wikipedia.org/wiki/Dylan_(programming_language) ? Should it be in the running for "the true Lisp"? If not why not?
- lispm 9y ago
  This Lisp I code is from 1959/60. http://bitsavers.informatik.uni-stuttgart.de/pdf/mit/rle_lisp/LISP_I_Programmers_Manual_Mar60.pdf http://bitsavers.informatik.uni-stuttgart.de/pdf/mit/rle_lis... Page 101: DEFINE (((COLLAPSE,(LAMBDA,(L),(COND,((ATOM,L),(CONS,L,NIL)), ((NULL,(CDR,L)),(COND,((ATOM,(CAR,L)),L),(T,(COLLAPSE, (CAR,L))))),(T,(APPEND,(COLLAPSE,(CAR,L)),(COLLAPSE,(CDR,L)))))))) This is the Common Lisp version. Formatted, comma removed, DEFUN instead of DEFINE. Other than that the code is unchanged. It still works in Common Lisp. (DEFUN COLLAPSE (L) (COND ((ATOM L) (CONS L NIL)) ((NULL (CDR L)) (COND ((ATOM (CAR L)) L) (T (COLLAPSE (CAR L))))) (T (APPEND (COLLAPSE (CAR L)) (COLLAPSE (CDR L)))))) CL-USER 191 > (collapse '(1 2 (3 4) ((5 6) 7))) (1 2 3 4 5 6 7) Common Lisp is backwards compatible to Lisp I and Lisp 1.5 in many ways. Code like that can be relatively easy ported to Scheme (naming and syntax is slightly different). There are examples which are more difficult. But generally simple (!) Scheme is not that far away from that old core.