[leethomas]

I like lisps syntactically. The only thing stopping me from using it more frequently is the lack of static typing. I wasn't always a stickler for static typing, but I've spent a lot of time working with Scala and TS and the main advantage for me is ease of refactoring and avoiding NPEs.

EDIT: What I'm continuously evaluating for myself is Clojure specifically

[cutler]

Clojure is head and shoulders above other lisps. Watch Rich Hickey's Sermons From the Mount in the years following Clojure's release and you may never be the same again. At least that was my experience. David Nolen's Clojurescript videos are similarly riveting.

Clojure also has far more reach than any other lisp with implementations for JS, JVM, .Net and recently Dart/Flutter. It also has a library - libpython - for easily importing Python libraries.

[bjoli]

What about it is head and shoulders above other lisps?

The ecosystem? The lack of first class continuations? All the things that can be portably implemented in any language?

[funcDropShadow]

Clojure makes simple code easy to write and maintain. It is more practical than most other Lisps by wisely choosing on which giants should to stand. E.g.

- make immutability the normal case, yet it is sufficiently performing that one rarely has to go back to mutability

- minimal syntax, uniformity, dynamic typing, macro-system, symbols from Lisp

- it extends Lisp with namespaces, even symbols get namespace

- access to the whole ecosystem of the JVM, of Javascript and mostly to Python's ecosystem

The price for accessing those ecosystems was omitting first class continuations. Which one is more valuable depends on your use case, but for many use cases I am considering that was the right choice.

[bjoli]

I would probably say that It is opinionated in a way that makes it good to write services in and it integrates well with the JVM.

CL has packages and most implementations have PLN so you get most (all?) of what the clojure namespaces offer.

I think that if anyone was rethinking scheme the would steal the immutability things from clojure (something like HAMTs and RRB trees or the scala finger tree vectors are more exciting I would say).

I don't think clojure brought anything new, per se. It took some nice parts from common lisp and scheme and added an immutability first paradigm. Nothing new, but getting people to understand how nice immutability is probably involves making the happy path immutable from day 1.

[readthenotes1]

"I like lisps syntactically"

and yet, not a single parentheses in your text. Disappointed.

[kdmccormick]

  ((syntactically like) I lisps)

[hajile]

Check out Coalton.

[dataangel]

Coalton static typing doesn't actually work, there's an issue filed that it breaks as soon as you do any mutation.

[reikonomusha]

It is not true that "any mutation" causes issues. In fact, most idiomatic usage of mutation is problem-free and completely sound.

One can find out more about polymorphic mutation as a "counterexample" to Hindley-Milner type inference on Wikipedia [1]. It's a well-studied problem with space of solutions. Purity, weak references, the value restriction, etc. are all ways of dealing with this shortcoming of Hindley-Milner.

Interestingly, one of the first proposed solutions to this problem was suggested by Wright in the journal "LISP and Symbolic Computation" [2].

[1] https://en.wikipedia.org/wiki/Value_restriction#A_Counter_Ex...

[2] https://link.springer.com/article/10.1007/BF01018828

[medo-bear]

i guess you need to learn more about static typing

[Pay08]

Common Lisp has the declare form and it's siblings. It's not exactly static typing but it's close. Unfortunately, it does make the code a bit uglier.