[alexdowad]

There are lots of interesting ideas to be found in the Lisp/Scheme family. A Lisp can be an excellent choice of primary dev language, especially for a dev shop which puts enough investment into training and tooling.

At the same time, the state of the art in programming languages has advanced since PG wrote those essays. Even many of the languages which he was presumably referring to as "Blub" are much better now than they were.

A bigger issue is: As one gets better and better at computer programming, at some point the specific implementation language starts to matter less and less. (It never completely ceases to matter; but, less and less.) In one of his essays, PG contrasts "applying Bayesian filtering" with "applying if statements", which describes the matter quite aptly. At some point, language constructs such as "if statements" really do melt away.

For this reason, I reject claims that using a certain programming language will make one "1000 times more productive" (or similar) out of hand. The big problems in software are not at the level of the language at all.

This may sound false to newer programmers who have just discovered a fantastic programming language which allows them to work much faster than they could before. To such ones: I've been in your shoes. I've tried many languages, perhaps even the one you are enamoured with now. The benefits don't scale indefinitely. At some point, as you apply your fantastic new language to bigger problems, you will find yourself wrestling with the same issues as you used to with your old language, perhaps in a different form.

[badpun]

> A bigger issue is: As one gets better and better at computer programming, at some point the specific implementation language starts to matter less and less.

There are things that you can do in more advanced languages which are simply not possible in the simpler languages. In that sense, e.g. Java is lower-level language than Scala. Easier to learn and probably faster too, but just much less expressive. I've seen expert Scala dev doing some magic in 100-200 lines, which literally saved us thousands of lines of code that would be a nightmare to maintain and which would be a neccessary evil in a lower-level language.

[alexdowad]

Sure. I've done similar things myself, though the "advanced languages" which I'm expert in do not include Scala. This is a good example of what I'm talking about in the last paragraph of the comment which you are responding to.

[miclill]

> The big problems in software are not at the level of the language at all.

IMHO this only partially true. Think e.g. of memory safety.

[wavemode]

Memory safety is itself one of the "powers" that Lisp had that most other languages did not, back in the day.

But nowadays almost every popular modern language is memory safe. So it has become yet another thing that doesn't really differentiate Lisp anymore.

[motherfsck]

Eh, I've worked on a lot of really shitty C code bases. Yeah memory safety is a class of bug but that doesn't exist in other languages but every ecosystem has its share of footguns.

The real time sinks are caused by the same thing regardless of language; poor design.

[jonathanstrange]

Every language with a garbage collector has memory safety. It's not the issue.

[phoe-krk]

It is the issue, when the industry nonetheless keeps on insisting on using languages that have neither garbage collection nor ownership semantics. Is your kernel, OS, userland memory-safe yet?

[theboywho]

Using a programming language that you enjoy or you feel strong about is a much better choice, in that it will actually make you more productive simply because you’ll be programming more often.

[iLemming]

> Using a programming language that you enjoy or you feel strong about is a much better choice

I enjoyed every single programming language I encountered and decided, or was compelled, to learn. Starting with BASIC, then Pascal, Assembler, C, VB, C#, F#, Java, Javascript, that followed by the plethora of "script" langs — Coffeescript, Typescript, Livescript, IcedCoffeescript, GorillaScript, etc. After that came Python and Haskell. Almost every book promised unbelievable riches and magic with this new (to me, at the time) language. Sooner or later, though, the long honeymoon would come to an end. At some point, while dealing with yet another clusterfuck of a project, I began to feel that I was simply not a good programmer and that I would never become one. Then I discovered Lisp. Somehow, inexplicably, things started making sense. Shit that confused me about Haskell and Prolog, I for whatever reason have started to grok, or at least I felt like it. For the things I build today, I use Clojure(script), Fennel, Elisp and CL. Even when I'm required to produce code in a different language, I still first prototype it in a Clojure. Not because I'm obsessed or blindly in love with one specific programming language, but because for the applications I'm building today, it makes sense — for me. I wouldn't argue that it would make sense for everyone, no. But for me, it does make sense. Today. Tomorrow that may change. Any given programming language is very unlikely to make you ten times more productive or accurate, yet it may provide you with even greater satisfaction. How? By allowing you to build something you love with it. Build something. Anything. And keep building more. And if you don't love it, rebuild it in a different language until you do.