mrh

I wonder if Kuhn really understood Plantinga's argument by the end

On of the better science fiction story experiences awaits those who read the lyrics while listening through the album.

Where is that from? It is extremely pessimistic and obviously false.

someone should tell Iceland

wait until you try emacs

nice name

Structuralists seem to forget that words are signfiers and signs of meaning, not the source of meaning

Wouldn't that only apply to ontic structuralists? They say the structures themselves are the real things. But epistemic structuralists merely say that the kind of knowledge we can have about reality is structural knowledge (but the world itself might be full of non-structural objects).

The problem isn’t so much the side effect as it is the ability to introduce side effects arbitrarily with no warning to someone using your functions

Yes, I try to allude to this in the "caution" and "tldr2" sections, but I think I could have been more clear. You are right that for many people it's not so much about avoiding side effects as it is about coming up with ways to use them carefully. Stateful monads and clojure's atoms/refs were in fact what I had in mind. And debating the pros/cons of these techniques is indeed a good conversation on its own! What I mostly wanted to get across is that fp is not about programming without side effects. All the good debate is about the extent to which we should try to avoid side effects, and what techniques we should use when doing so.

I think it’s also really important to call out the concept of total functions

Yeah I think this is totally (heh) worth talking about, and a much better topic than pure functions. I only didn't mention it because I don't see it brought up too often.

why

Common Lisp "solves" most language-level problems by providing metaprogramming capabilities via lisp-style macros. (Almost) any language feature you would want can be implemented with lisp macros, and many such features already have been. So you don't have to worry whether or not lisp has "for i in..." loops, or pattern matching, or generics, or virtually anything else, because if it doesn't, you can write it! Plus if it's really a good feature somebody has probably already made a library for it (if it's not already part of the standard).

One of the most extensive examples of this is Coalton, which is an ML-style statically typed EDSL for Common Lisp.

There are metaprogramming features in a few other languages: template haskell, C pre-processors, even macros in Rust or Julia. But these all fall very short of lisp-style macros because those languages are not (truly) homoiconic, which makes the macros awkward to write and integrate into the language. This kind of metaprogramming is rarely employed, and when it is only for heavy duty tasks, and even then is generally discouraged as a last resort/special circumstance. But lisp macros are very easy to write because it's the same as writing any other piece of lisp code. This results in macros being used often for smaller lightweight abstractions in the same way you write a small function.

The other big pro of lisp is image based development. But that's not so much solving a problem in other languages as it is simply a feature that they don't (and pretty much can't) have.

And all of this is done in a language with less syntactic and semantic primitives than almost any other language, including the other "simple" ones like Python, Ruby, Elixir, etc.

I understand the general job market, but what about lisp prevents you from pursuing personal ventures with it?