It's a question of where to focus your attention. Consider the explore/exploit trade-off. Boring tech may be a little, well, boring, but that means you get to spend your limited decision-making capacity on solving your actual problem. If your actual problem is betting on a niche language early, then go for it! Otherwise, use the thing that balances your existing knowledge, interest, existing 3rd-party resources and has the right outlook over the expected timeline to get your outcome.
The web has killed desktop apps. I use linux, but I don't buy software on any platform besides games.
I think it makes sense for professional productivity apps, like CAD stuff.
I don't think basic desktop apps are worth a fee, since no one will buy them with all the free alternatives, but maybe a case can be made with something that ties into managed cloud compute services (like superhuman's use of AI).
There is an alternative that I have found quite useful.
Create a Dualboot situation for normal linux work but set up a VM in your windows host that points to your bootloader and linux partition.
Now you have the best of both worlds, more memory and speed when you want it with native boot, but access to the dev environment from windows.
This was most effective in the case where a client required proprietary windows-only VPN software, but I wanted my dev environment. Configuring a vpn'd bridge adapter between Virtualbox+linux-guest and Windows host was a piece of cake.
I'd skip Objective-C and learn Swift to actually make a thing.
If you want general language knowledge, a really hairy production language and toolset isn't the place to look. You'll be fighting with lots of incidental stuff along the way.
Learning different kinds of languages will help you learn more languages.
I really like this comment. But I bet some folks gloss over a particular point of importance.
For me, there's a huge advantage in literally using tree-paper, either for code-reading, designing, taking notes, what have you.
It involves more of your senses, it's more tangible, every letter is written with more care and the medium is incredibly flexible (maybe I feel like drawing a circle on a whim, can't do that in emacs.)
It's better for scratch-pads than a text-buffer, imo.
Insights come more consistently and easily after iteratively marking up a printout. It's just fully-intuitive.
Better stacktraces would be better, sure, but there are good arguments on both sides whether it's better to separate the language from the platform or not.
I prefer a thin, readable compiler and core library over such abstractions. I don't mind the stacktraces, but I could see how some people might.
The fact that clojure is host-centric makes clojure and clojurescript compelling to java or javascript programmers at the expense of some aesthetics, and it also has performance implications.
This is somewhat irrational critique, clojure was an opportunity to start fresh and graft a concurrency-focused lisp onto a pervasive runtime, not to reimplement ABCL. It fills a need.
I was always somewhat halfway interested in learning common lisp, but when clojure came along I actually got excited enough to do something about it.
You even say you're 'very happy' to be working in it, but I think 'an experiment in STM' is too reductionist and shallow to address the numerous use-cases that are improved by persistent data structures and the other features that clojure provides.
Maybe I'm a bit of a masochist, but it's not that hard to read the compiled output, especially when you have a decent mental model of what it should be. It doesn't look like idiomatic javascript, but the structure is pretty regular.
What makes the right level of abstraction right? Seems like the units of abstraction have to be amenable to application (analogy), but rightness is fluid. If you have a turing machine, it might make more sense to write a JS compiler first because of the familiarity and perceived difficulty of translating your thoughts, but that's a statistical process of your own head. If you're a fresh mind, you would never create a JS compiler. The aggregated feedback of our social consciousness over time is what sets the 'rightness' of any approach by modulating the difficulty and expressiveness of each concept to each individual.
My interpretation: javascript is slowly catching up to the rest of the world. It's reach both makes it a lingua franca and slows it down. Maybe one day it will be suitable for real programming, if people who complain after 10 minutes would stop holding it back.
I think at least the criticism of immutability and FP resulted from taking concepts to extremes. I made a point to address lock-in of different aspects of clojure in my post.
I think if you're mutating deeply nested things, or doing heavy algorithmic bookkeeping, it's worthwhile to evaluate different approaches (maybe pure java) as an 80/20 thing, and I wonder how hard it would be to have comparable mutability facilities and data structures as a library?
Of course, programmers want to get things done without spending time on building up their own tools, and I understand that.
I think this site leans pretty niche.