Why such an emphasis on what language stuff is written in? Why does it even matter? Sounds like it was a good engineering choice given the constraints of the problem, get over yourself ffs.
There was a HN submission yesterday about another project of his (also in Clojure) and many of the comments were "Why is this made in Clojure?".
Unfortunately, a large segment of developers think there is no value in venturing beyond C-style languages.
Another dimension in recent years is the static type checking cult, whose adherents must warn everyone else in the cult whenever they spot any kind of dynamically typed programming language, e.g. causing a separate thread about the lack of static type checking in any comment section about a Clojure project.
Shun the nonbeliever!
For years I thought it was a dynamic/static issue. Then I used Python (without type hints), and almost all the JS errors were impossible in Python too! Turns out it's about weak/strong typing instead.
Put simply: when given something that is an obvious error, throw an error. This sounds obvious, but given an obvious error, in many cases JavaScript remains silent and passes garbage data to the rest of the program.
I think if JS added a "use strong", it would remove 80-90% of the need for TypeScript.
"use strict";
let undef;
let str1 = "hello";
let str2 = str1 + undef;
console.log(str2); // -> "helloundefined"
"use sane";
let undef;
let str1 = "hello";
let str2 = str1 + undef; // -> Uncaught TypeError: Cannot append string and undefined
console.log(str2); // (code never reaches this point)
You might enjoy this classic comedy routine: https://www.destroyallsoftware.com/talks/wat
Because it's by far the most important decision made during the creation of any software project, and to a large extent, it sets the boundaries of what the software will ever be able to do.
Experience also teaches that language choice strongly correlates with overall project quality. When I see a CLI project written in JavaScript (Node), I know that it's probably not worth my time to take a closer look. With Rust, Clojure, Haskell, F# etc, the opposite is the case. This is a cultural effect, rather than a technological one, but that doesn't make it any less real.
E.g. from a performance perspective, the design of you program is orders of magnitude more important than the language itself. Also, not every platform is as limiting - you could for example start a clojure project, and extend it in java without any fuss.
polyglot programmers are the exception, not the rule, and even for people who have mastered >5 languages, there's still no one who's mastered the top 50, let alone all the languages out there.
Language impacts both codebase contributor pool size and codebase reviewer pool size. In large, conservative orgs, the latter can matter a lot - good luck getting an insurance megaco's security review board to approve the cool new tool you found that's written in Eiffel - none of them know it, so none of them can review it intelligently.
Language diversity is a good thing, IMO, and there are many different factors impacting what you choose, and that makes your choice more important, not less.
The culture of how to write programs in Lisp or Schemes is quite different, very much focused on using recursion, macros, code as data, etc.
It can be hard to read through a Lisp program if you're not used to it.
Yeah, fair, I re-read that part after I made my comment and you're right. Though it's a bit weird with Clojure with it being a JVM-based language, it's got this hybrid world which is both Lispy and Java-ish.
Reaching the kind of mastery where you see extremely subtle mistakes instantly - well, no, I think that really does take years to reach, even if you're an expert in a similar language.
I've picked up TypeScript for $DAYJOB in the past year, and there are definitely still deep aspects of the type system I only half-understand.
Granted, my decades of JS experience didn't really prepare me for static type systems, nor did the years of Python's strong-but-dynamic typing.
Still, I'm reminded of the quote "A language that doesn't change how you think about programming isn't worth knowing."
Most languages have some corners that are genuinely unlike most other languages, and without knowing those bits you don't count as a master, IMO.
I don’t think it’s a good quote with such a bold claim, but I agree with the core of it: you should try to learn languages that have different paradigms. There is still value in knowing two quite similar languages.
This suggests the frequent existence of a megacorp’s security review board that could intelligently review a tool written in a more mainstream language. That doesn’t exactly match my experience.
Forward unreviewed log output from a scanner they bought and ask you to respond with whether that’s a problem? Yes, they can do that.
Of course people ask "why clojure", we're curious!
> Why such an emphasis on what language stuff is written in? Why does it even matter?
Because different languages (and especially different paradigms) are different. The choice of language affects the project's future prospects, productivity, expressivity, maintainability, developer satisfaction, ease of finding developers, and a million other things.
You wouldn't be able to translate Clojure to another language line by line unless you brought in some framework or library
People are interested in the decisions that informed the engineering of a tool they respect.
People are interested in reading the code but aren’t going to learn something as goofy as clojure (sorry) to do it, and this causes them to whinge.
Some combination of those two. I’m sure the second one is purely hypothetical since no one ever whinges on the internet.
Because people are interested in the way that languages affect your ability to think and solve problems? Because different languages have different tradeoffs and the tradeoffs involved in less used languages are often underexplored? Jeez dog, ease up.
aphyr should've written it in ada, though.