The question is: Will we live in the world of breathless re-implementation, new features every week, rebranding every quarter or will we eventually discover the value of stability, software that does its thing more or less optimally for decades?

Recent examples of things like curl or Firefox are interesting in that regard. Will we end up with a nearly perfect HTTP user agent and stick with it for decades?

It should be fairly trivial to fix any logic errors in the structured output, too.

> It just means type errors are checked at runtime instead of compile time.

This is a fundamental misconception. A type checker proves the absence of errors. It doesn't check for error conditions. That is: A program that isn't (cannot be proven to be) well-typed can very well be correct. But a program that is well-typed is guaranteed to be free from certain errors.

What you call "dynamically typed", in contrast, is comsequent just value inspection and stopping the evaluation/execution early. A program that has been executed successfully often is not necessarily correct.

The point of types is to prove the absence of errors. Dynamic typing just has these errors well-structured and early, but they're still errors.

Obviously, our regulations aren't perfect or even good enough yet. See DRM. See spyware TVs. See "who actually gets to control your device?". But still...

Maybe a part of the anxiety is the realization that much if what was delivered by well-paid people before AI is actually not something the very same people want to consume?

A piece of code that satisfies a single test will most likely not be probable to adhere to the spec.

Worse, the whole spec can only be correctly implemented in total. You cannot work iteratively by satisfying one constraint after the other. The same holds for the test cases. That means that satisfying the last test or fulfilling the last constraint will take much more work than the first. The number of tests passed is not a good metric for completion of the implementation.

This means that any Rust ABI would have to cater for link-time specialization. I think this should be doable, but it would require a solution that's better than just to move the code generation into the linker. Instead, one would need to carefully consider the usage of the "shape" of all parameters of a function.

For me the biggest concern is that while you may be able to use and run your own device, you will be locked out of most propietary services. Much like how more and more websites simply don't work with Firefox anymore.

How the heck are the panels even installed and connected for that price? That's about 25 panels, IIRC. What about the installation material and the ac/dc converter?

If two Starlink satellites collide that go roughly in the same direction, it's not exactly a huge problem.

I think the biggest issue is to coordinate this and potentially disallow some excentric orbits.

I doubt that something built on self-identification yields a meaningful concept of racism.

Then, of course, racism consists of the believe that some races are intrinsically less valuable (in whatever sense) than others. I didn't see Scott Adams voice that part. But I might have missed it or it might have been implied.

But it's important to note that US identity politics of the last couple of decades looks increasingly weird to me as an outsider in any case.

If that wasn't the case, every piece of software could already be developed arbitrarily quickly by hiring an arbitrary amount of freelancers.