1. 9
  1.  

  2. 8
    1. 4

      There’s so much wrong with this article I don’t know where to start.

      “lisp-1 vs lisp-2”? One of the things that lispers forever ado about.

      I guess this depends on who you talk to–on the whole for lispers the only people who don’t consider lisp-2 to be a mistake are the hardcore CL fans. Emacs Lisp is the only other lisp-2 with a large userbase, and if you talk to elisp users, most of them are annoyed or embarrased about elisp being a lisp-2. If you look at new lisps that have been created this century, the only lisp-2 you’ll find is LFE.

      Not a Important Language Issue […] For another example, consider today’s PHP language. Linguistically, it is one of the most badly designed language, with many inconsistencies, WITH NO NAMESPACE MECHANISM, yet, it is so widely used that it is in fact one of the top 5 most used languages.

      You can use this same argument to justify classifying literally any language issue as unimportant. This argument is so full of holes I’m honestly kind of annoyed at myself at wasting time refuting it.

      Now, as i mentioned before, this (single/multi)-value-space issue, with respect to human animal’s computing activities, or with respect to the set of computer design decisions, is one of the trivial, having almost no practical impact.

      Anyone who has tried to use higher-order functions in emacs lisp will tell you this is nonsense. Having one namespace for “real data” and another namespace for “functions” means that any time you try to use a function as data you’re forced to deal with this mismatch that has no reason to exist.

      I could go on but I won’t because if I were to find all the mistakes in this article I’d be here all day.

      1. 9

        I guess this depends on who you talk to–on the whole for lispers the only people who don’t consider lisp-2 to be a mistake are the hardcore CL fans.

        This only is doing a lot of work here, given that CL is where the majority of practice happens in the (admittedly tiny) Lisp world.

        1. 4

          I know anecdote is not data but I know far more people who work at Clojure shops than I do Common Lisp shops. How would we quantify “majority of practice?”

          1. 2

            It’s more to do with whether qualify Clojure as a dialect of Java or a dialect of Lisp.

            Clojure proclaims itself a dialect of Lisp while maintaining largely Java semantics.

            1. 2

              CL programmers are so predictable with their tedious purity tests. I wish they’d move on past their grudges.

              1. 3

                Dude you literally wrote a purity rant upthread.

                1. 2

                  Arguing about technical merits is different from regurgitating the same tired old textbook No True Scotsman.

                  1. 3

                    Look, (like everyone else) I wrote a couple Scheme interpreters. I worked on porting a JVM when Sun was still around. I did a JVM-targeting “Lisp-like” language compiler and even was paid for doing it. I look on Clojure and immediately see all the same warts and know precisely why they are unavoidable. I realize some people look at these things and see Lisp lineage, but I can’t help seeing some sort of Kotlin with parens through it.

                    And it’s not just me really: half of the people who sat on RxRS were also on X3J13, and apparently noone had a split personality. So no need to be hostile about technical preferences of others. When you talk to your peers it helps to build a more complicated theory of mind than “they are with me or they are wrong/malicious”.

                    1. 2

                      Sure, you can have whatever prreferences you want. But if you go around unilaterally redefining terms like “lisp” and expecting everyone to be OK with it, well, that’s not going to work out so well.

                      1. 2

                        If you hang around long enough you hear people calling about anything as “Lisp-like”. Forth, Python, Javascript, Smalltalk, you name it. Clojure is a rather major departure from lisps both in syntax and semantics, so this is not a super unusual point.

        2. 6

          on the whole for lispers the only people who don’t consider lisp-2 to be a mistake are the hardcore CL fans.

          That folks who use a Lisp-1 prefer a Lisp-1 (to the extent that non-Common Lisp, non-Emacs Lisp Lisp-like languages such as Scheme or Closure can fairly be termed ‘Lisps’ in the first place) is hardly news, though, is it? ‘On the whole, for pet owners the only people who don’t consider leashes to be a mistake are the hardcore dog owners.’

          Emacs Lisp is the only other lisp-2 with a large userbase, and if you talk to elisp users, most of them are annoyed or embarrased about elisp being a lisp-2.

          Is that actually true? If so, what skill level are these users?

          For my own part, my biggest problem with Emacs is that it was not written in Common Lisp. And I think that Lisp-N (because Common Lisp has more than just two namespaces, and users can easily add more) is, indeed, preferable to Lisp-1.

          1. 4

            Is that actually true? If so, what skill level are these users?

            This is based on my experience of participating in the #emacs channel since 2005 or so. The only exceptions have been people coming to elisp from CL. This has held true across all skill levels I’ve seen including maintainers of popular, widely-used packages.

          2. 4

            I dunno. I think the article is a bit awkward but I think the author is absolutely right: in practice, to the language user, it doesn’t really make a difference.

            I am a full-time user of a lisp-1. When I use it, I appreciate the lack of sharps and the like for when it’s time to use higher order functions or call variables as functions. The same language has non-hygienic macros, which Dick Gabriel rather famously claimed more or less require a separate function namespace, and have almost never found my macro usage to be hampered.

            At the same time, I was for three years a professional user of Elixir, a language with both syntactic macros and separate namespaces. I found it mildly convenient that I could declare an variable without worrying about shadowing a function, and never found the syntax for function reference or for invoking variables as funs to be particularly burdensome at all.

            To the user, it really doesn’t have to matter one way or the other.