>There's only one standard Lisp, and that's Common Lisp
That isn't true. Scheme is a Lisp. Why would think otherwise?
Is it because nil != false? Even McCarthy admitted that that was a random decision, and possibly a mistake.
Is it because it hasn't got "proper" macros? That's a common misconception, but it's not true: all but the most minimal implementations provide an imperative macro system.
Is it because it's lisp-1? Many lisps have been.
Is it because they have different histories? Because that's not true. Both came out of MIT. Many people were on both standardization communities then, and many people are active in both communities now. The first Scheme was written in MACLisp, for crying out loud.
> Is it because nil != false? Even McCarthy admitted that that was a random decision, and possibly a mistake.
I think that code written where NIL is the sole false value tends to read better than code with a distinguished false value, but I'm open to the idea that uglier code is more reliable.
> That's a common misconception, but it's not true: all but the most minimal implementations provide an imperative macro system.
But they're not standardised. The manner in which they affect the runtime environment is not standardised. It's just not a sound basis for a portable project: in practise any large software project will run not on Scheme but on Guile Scheme, or Chicken Scheme.
> Is it because it's lisp-1? Many lisps have been.
Only mistakenly. I used to think that Lisp-1 is better: after all, I'm used to other languages like C or JavaScript where functions and variables share the same namespace.
I've come to realise that 'because C & JavaScript do it' is hardly sufficient for something to be good grin
It turns out that the multiple namespaces of Lisp are extremely useful for industrial-strength software.
> Many people were on both standardization communities then
Sure, there's lots of cross-pollination between Lisp & Scheme, because they are both good languages. I don't dislike Scheme: in its place, it's a very interesting way to learn certain concepts. It's Lisp-like, which means it's certainly not all bad.
But it's not an actual descendant of a Lisp: it's its own independent language. It has flaws (continuations which make UNWIND-PROTECT impossible; nil ≠ #f; Lisp-1; worst of all: it's under-specified), but it's not bad. The world would probably be a worse place if there were no Scheme in it.
But I think that emacs would be worse if it were implemented in Scheme rather than Lisp.
>I think that code written where NIL is the sole false value tends to read better than code with a distinguished false value, but I'm open to the idea that uglier code is more reliable.
It's less reliable, and less clean. If you can't see the problem with overloading false, look at C, another language which overloads false and suffers for it.
>Only mistakenly. I used to think that Lisp-1 is better: after all, I'm used to other languages like C or JavaScript where functions and variables share the same namespace.
I have yet to see a disadvantage to being a lisp-1, and it comes with many advantages: we don't have to function and funcall everything, which makes our code a good deal cleaner.
>But it's not an actual descendant of a Lisp
That is definitely wrong. It is emphatically a descendant of Lisp. In fact, the very first paper on Scheme, AI Lab Memo 349, described it as "a full funarg lisp."
We can argue about whether Scheme is a lisp, but its descendance is well-documented: if you can't trust the language's creator on its origins, than who can you trust?
>it's under-specified
This is true. However, R7RS is working on fixing this. And as I understand it, it's even including a standardized procedural macro mechanism, so there you go.
> and many people are active in both communities now.
Hardly.
> Many people were on both standardization communities then
Guy L. Steele worked on the High Performance Fortran standard. Makes it a Lisp...
> The first Scheme was written in MACLisp, ...
One of the first Haskell implementations was written in Lisp. The first ML was written in Lisp.
Lots of different languages were implemented (but not initially developed) in Lisp at some point in time. Incl. Scheme, Logo, Prolog, Dylan, C, Ada, Fortran, Python, Pascal, Clojure, ...
You only addressed my points showing there was a link between the communities. Just because there are links between the lisp community and other communities doesn't mean Scheme isn't a lisp.
It just invalidates your arguments, nothing more. That parts of the first Scheme were once written in Maclisp 40 years ago does not make it a Lisp. An Emacs was once implemented in Maclisp, too. It doesn't make it a Lisp. It's an editor.
Scheme is a different programming language with its own set of standards like R*RS and IEEE Scheme, its own community, its own code, its own libraries, its one mailing lists, its own online forums, its own user groups, its own funding, ...
ISLisp, Elisp and Common Lisp are sharing the same core language. ISLisp is basically a simplified Common Lisp (a Lisp-2 with a CLOS-variant and Conditions in the standard). Kent Pitman wrote a compatibility package which allows running ISLisp in CL. Elisp and Common Lisp are both coming from Maclisp, so they share the same core language. Elisp has a lot of further Common Lisp compatibility ( https://www.gnu.org/software/emacs/manual/html_node/cl/ ), which is widely used in Emacs Lisp code. Standard Lisp is another Lisp, which shares the core language.
Eulisp is long gone. RIP.
> Lisp isn't a language: it's a family of languages.
True. A family of languages which share.
> And the idea that the languages don't share community isn't true.
Sorry. I am primarily a schemer, so that's what I'm referring to.
Readtables and generic setters (as specified by SRFI-17: a bit limited compared to CL, as I understand it) are very common extensions, and there are several loop macros floating around, all inspired by CL.
We also technically took dynamic scope from CL, but most schemes only have R7RS dynamic scope, which isn't so much dynamic scope as it is a hack that looks a lot like dynamic scope if you squint.
Yes. As did lexical scope exist before Scheme. However, the scheme implementation was directly inspired by CL. As are (and I forgot to add this) our object systems.
That isn't true. Scheme is a Lisp. Why would think otherwise?
Is it because nil != false? Even McCarthy admitted that that was a random decision, and possibly a mistake.
Is it because it hasn't got "proper" macros? That's a common misconception, but it's not true: all but the most minimal implementations provide an imperative macro system.
Is it because it's lisp-1? Many lisps have been.
Is it because they have different histories? Because that's not true. Both came out of MIT. Many people were on both standardization communities then, and many people are active in both communities now. The first Scheme was written in MACLisp, for crying out loud.