Package management is the ultimate problem that was previously left unsolved (no, docker just pushes the problem away, doesn’t solve it. That apt install won’t be the same now as it was when you wrote it). Nix is the first thing that actually solves it properly.

They are both UNIXes, that’s quite a lot of similarity and I wouldn’t write it off that fast.

In what way does it limit your freedom? When I first tried OSX I was quite surprised at how customizable it actually is, contrary to all the talk I heard about it.

I believe we should have a new word that differentiates between ultra-basic tiny unit tests, and bigger unit tests that are still not integration tests.

E.g. rust and some other newer languages have a way to write basically an inline test for a function — that would constitute my former category. These make sense during development as a reality check. “Yes, this ad hoc stack I need inside this class should have two elements if I push two elems” sort of thing. That implementation may not even be accessible from the outside in case of an OOP language so you can’t even properly test it. Also, these are the ones that should change with the code and removing them is no big deal.

The other kind should work against the public APIs of libs/classes and they should not be rewritten on internal changes at all.

That doesn’t mean you are a shit coder, you are just likely forgetful. I also find stupid shit in my committed code, though that is also due to me not caring too much (I guess I really have burned out at my previous work place).

Now I’m at a better job, hopefully I can take proper care of my work here! Hopefully you don’t suffer from burnout.

I do believe that static typing is at least a local optimum, but I am still not entirely convinced. Rich Hickey is a very convincing presenter and I can’t help but think that he is on to something — with Clojure the chosen direction is contract-typing, which is basically a set of pre- and post-conditions for your functions that are evaluated at runtime. Sure, it has a cost and in the extremes they are pretty much the same as dependent types, but I think it is an interesting direction — why should my function be overly strict in accepting a “record” of only these fields?

It’s not that most people are bad at it, they are just out of context.

Like, I am completely swamped with a completely different business area of the code, besides checking for obviously dumb things, what can I really tell about a diff to a very separate part of the code which I may have never worked on before, with business requirements I don’t understand as I was not part of the 10 meetings that happened between the dev of the given ticket and BAs?

It also depends on the specifics — in many cases when a GUI is just a wrapper over the CLI tool, it is instructive to learn the CLI, similarly how you are a better programmer if you know about at least a layer beneath the one you are programming at (e.g. you can reason about this usage of hashmap because you roughly know what it does).

It is probably the most visible in git, but if you can only do commit and push from a GUI, just please learn the CLI as well. You don’t have to use it, but understanding it is important and the GUI may abstract away too much from you.

That 44b had to be paid in real cash, not just the current theoretical value of the sum of his shares. He sold quite a lot of Tesla shares afaik to banks to give them a “small loan”.

Memory is an implementation detail. You are interested in solving problems, not pushing bytes around, unless that is the problem itself. In 99% of the cases though, you don’t need guns and knives, it’s not a US. school (sorry)

And it is not forced at all. Noone holds a gun to your head to write extends. “Favor composition over inheritance” has been said as a mantra for at least a decade

Tbh, I just want to blend in.. but of course be as pompous as you want!