1. 33
  1. 10

    Last year I did a short (~ 1 billable day) gig writing a CSV to Hubspot importer in Common Lisp. I used SBCL on FreeBSD, then compiled a native Windows binary in an EC2 Windows instance.

    I really should blog about it. Best Windows dev experience I’ve ever had ;) Also a fun way of keeping my eye in, having been ‘post-technical’ for years in various day jobs.

    1. 6

      I would like to read that blog post!

    2. 6

      To add examples in Janet (my Lisp of choice):

      1. 4

        This list of CL companies is more up to date than the one on common-lisp.net: https://github.com/azzamsa/awesome-lisp-companies/ (it’s updated once in a while, after the latter)

        1. 4

          I keep saying Clojure is not a lisp. It’s a productivity focused language that uses a lot of parenthesis.

          People don’t seem to like lisp. We keep seeing stories about tools written in CL being rewritten so coders can be hired to work on it. This might be the main reason people leave lisp, and one reason people don’t start lisp projects.

          Clojure somehow avoids these stories. Maybe because, from my perspective, it splits with lisp tradition while focusing on the best bits.

          1. 15

            I keep trying to love Clojure, but I still feel happiest and most productive in Common Lisp. That said, I’d use Clojure in a heartbeat if I were operating in a Java shop, where shipping as a JAR would be a win.

            Funny anecdote: at a client some years ago, my team split in two to try out two new JVM languages. As part of a data migration project, one group wrote a migration tool in Scala, and the other a validation tool in Clojure. We met up at the end of the sprint to showcase our tools.

            The Clojure demo was straightforward - hands-on demo followed by a walk through the code.

            The Scala group started their walkthrough with a primer on type theory o_O

            1. 2

              Love it when people have no idea about sales process and wander off like this :)

              1. 3

                I don’t think they wandered off, necessarily - one just had to understand a fair bit about the subject before reading the code.

                It’d have been the same with Lisp macros if we’d needed them on the Clojure project.

              2. 2

                Why Clojure over ABCL?

                1. 4

                  Have you tried programming in ABCL? I have a bit. With much respect to the maintainers, it’s pretty slow and not incredibly mature.

                  1. 2

                    Because Clojure was seen as a more natural fit for the JVM than ABCL. I suggested it at the time but the team chose not to evaluate it.

                2. 2

                  What exactly makes it not a Lisp in your book? It’s very different from Scheme (more CL-like things like nil punning and the namespace/package system) and very different from CL (more Scheme-like things like a functional focus and a single namespace for functions and variables), but that’s valid - Scheme and CL are different enough from eachother to leave enough design space for another Lisp-like between the two.

                  1. 5

                    I read them as saying “Clojure is not a Lisp” with the goal to not dissuade people from trying/using Clojure, which they fear would otherwise happen, as “people don’t seem to like Lisp”

                    1. 3

                      Well, that’s rather disingenuous!

                      1. 2

                        To be clear I also don’t think real Lisp people like Clojure. It doesn’t “feel” the same. Even the attempt to put Clojure on Racket doesn’t feel the same, to me, as Clojure/Clojurescript. As such, focusing on Clojure as a Lisp misses the boat. It isn’t the same sort of language. Sure it has powerful macros, sure it has lists, and sure it overloads on the parenthesis… but that’s not all Lisp languages are. R.H., author of Clojure, has said he tried to split with Lisp tradition on several things… because not everything that’s Lisp is in Clojure.

                        A practical NEGATIVE example: I have errors in a Clojure function I’m working on. I can’t (currently in my workflow, surely there is a library…) just stop execution there and let me investigate the run stack at that point in time. I want to. I could do that in a Lisp. Clojure isn’t a Lisp.

                        1. 8

                          I could do that in a Lisp.

                          As far as I know, CL is the only lisp which has restarts as part of the language; are you saying Racket, LFE, Emacs, etc are also not lisps because they don’t have restarts?

                          I’ve heard a lot of shaky gatekeeping arguments from CL fans over the years but I think this is a new one.

                          1. 5

                            I’ve heard a lot of shaky gatekeeping arguments from CL fans over the years but I think this is a new one.

                            I mean, I like the conditions & restarts system but I wouldn’t say lack of it make Racket, Clojure, etc. not Lisps. I’d just argue that it makes CL one that I prefer using.

                            1. 3

                              I’ve heard a lot of shaky gatekeeping arguments from CL fans over the years but I think this is a new one.

                              I’m not a CL fan. Just putting that out there. I’m a major Clojure fan.

                              I know you say you need to look at languages as a whole rather than just obsessing over the cons cell so I won’t discuss that further.

                              I also know you work on other lisps that try to be as fun to write as Clojure.

                              My primary purpose in saying Clojure is not a Lisp is that I never get anywhere near the same “feeling” from other Lisps as Clojure (and Fennel, yes). Meanwhile Lisps have a bad rap to the point that saying “it’s written in a Lisp” leads many people to turn about and go “NEXT!” Rather than fighting the conception of lisps as so powerful yet having a bad rap, I prefer to say Clojure is not a Lisp since it doesn’t fail in the way other Lisps are perceived to have failed.

                              It’s easy to get people to write Clojure. It’s easy to get people to read Clojure. Yes there are some performance problems with idiomatic Clojure but you can fix all those if they become actual problems. I still want to see it succeed in more places (so I can then use it for work in more places).

                  2. 2

                    For what it’s worth CircleCI’s frontend is in TypeScript. The ClojureScript frontend was retired last year.