AI companies should be ashamed. Their agents are shitting up the open source community whose work their empires were built on top of. Abhorrent behavior.
Sure, you can say that complex numbers are 2-tuples with a special rule for multiplication (a, b) * (c, d) = (ac - bd, ad + bc). Same way you can define rationals as 2-tuples with a special rule for addition (a, b) + (c, d) = ((ad + cb) / gcd(b, d), bd / gcd(b, d)).
But I think this way you'd lose insight as to where these rules really come from. The rule for complex multiplication is the way it is, precisely because it gives you an algebra that works as if you were manipulating a quantity that squared to -1.
From a physics point of view should be as every effect is caused by previous state. And next tick is always next tick, except quantum bacause has some randomness, but let’s assume it’s a seeded randomness.
I think every tick is predictable from previous state. Inevitable. Therefore I really like how you put it: mind is just spectating.
Maybe it's time for physicists to switch to agile? Don't try to solve the theory of the Universe at once; that's the waterfall model. Try to come up with just a single new equation each sprint!
While I consider Uncle Bob a bad programmer, there is some merit to this article. This paragraph was particularly prescient:
>But before you run out of fingers and toes, you have created languages that contain dozens of keywords, hundreds of constraints, a tortuous syntax, and a reference manual that reads like a law book. Indeed, to become an expert in these languages, you must become a language lawyer (a term that was invented during the C++ era.)
And this was written before Swift gained bespoke syntax for async-await, actors, some SwiftUI crap, actor isolation, and maybe other things, honestly, I don't even bother to follow it anymore.
I agree, but i think his point applies more to haskell than, say, kotlin. There is a balance between type strictness and productivity and if you go too far in one direction you get horribly buggy code and if you go too far in the other direction you have a language that is grindingly slow to develop in.
Another thing I dont think a lot of people appreciate either is that types have sharp diminishing returns catching the kind of bugs tests are good at catching and vice versa.
