gtrak

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.

I think this site leans pretty niche.

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.

Just a hunch, LLVM uses Static-Single-Assignment, which is just that, saving every single variable change.

I'm not sure what you mean.

Lines of code is an objective measure. How meaningful that might actually be, well, that's subjective.

I know neither.

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.

There are objective measures. There aren't necessarily 'absolute' ones.

Lisp is relatively more concise than C or Java for the same tasks.

Java is relatively safer than C for the same tasks.

Every new dev machine should have an SSD.

It's under $1/GB

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.

Very strange to have a programmer culture that is afraid of thinking about performance.

It's treated like a hobgoblin.

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.

the practical difference between lists and seqs is laziness (details like chunking, too).

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.