I love scapegoating individual developers as much as the next guy, but if you take a look at the Win32 API, you'll find loads of fun "features" such as:

- Every single function that takes a string has two implementations: one that ends with the letter A (and takes its strings as ASCII) and one that ends with the letter W (and takes its strings as UCS-16). And then it has a preprocessor-define (with no suffix) that gets expanded to either one implementation or the other, based on your compiler settings.

- windows.h defines preprocessor-tokens for min() and max(), which means any C++ program that ever calls std::min() or std::max() will error out with a very strange compile-time error, if it included windows.h first; the work-around is to define NOMINMAX first to prevent windows.h from polluting the namespace.

- Modern windows is perfectly capable of arbitrary-length file-paths, but ships by default with a 260-character filepath limit anyway, "to preserve backwards compatibility with older software that expects that limitation to be enforced". To get correct behavior you have to hand-modify your registry; otherwise you find out about this limitation when you go to unzip a .zip file and the unzip mysteriously fails even though the .zip file is valid.

These are all defects that other OS's simply don't suffer from, either because the other OS's were designed correctly from the beginning, or because the people in charge of the other OS's long ago took the hit (in short-term breakage) and fixed the problems rather than letting them linger forever to preserve backwards compatibility.

All Windows developers (good and bad) have to deal with these issues, probably forever, and every line of code they add to work around these problems has to be supported and debugged and tested as well, hence the damage compounds.

Before Trump, it was a cultural norm that a President of the United States was expected to follow ethical and moral guidelines as well as laws; not only because anything less would be dishonorable and a disservice to his country, but also because otherwise he would pay a steep political price for his unethical behavior. Trump's most significant political innovation has taken the form of figuring out how to convince a plurality of the American public that the only real standard for Presidential behavior is "whatever you can get away with".

For a small fee you can get your bullshit before everyone else.

Imagine it's ten years from now, and for $199 anyone can buy an in-home UPS from Home Depot with enough capacity to keep their lights on and their ice cream frozen for 48 hours. Once most houses have one of those, most power outages become more of a minor nuisance than a significant problem.

Part of it may be a dysfunctional corporate culture, but a lot of it is a consequence of Microsoft's business decision to maintain backwards compatibility at all costs. When you're committed to retaining every design mistake, forever, the complexity of the codebase just keeps rising, which means that less and less of it can fit into anyone's mind at one time, which means more mistakes are made going forward, and the technical debt just keeps compounding.

I should have added:

"In general, renaming things does not fix a problem."

Though heaven knows, lots of stupid people try it.

Why not just discard the whole idea of DST instead of putting it into permanent effect?

The whole concept is an attempt to redefine time as a way of addressing perceived social problems. Schedule activities around the clock, not the clock around activities.

Not surprised that someone exploited a vulnerability, but surprised that deployed military personnel are allowed to use civilian communication systems.

Will it have a Genuine People Personality? Perhaps a cheerful and sunny disposition?

Good question. Their POWER series of CPUs were not insignificant in capability, their chip designers were clearly technically sophisticated, and GPUs are just specialised vector processors with a few extra bells and whistles - stuff IBM is extremely familiar with.

It would not have been difficult to release a GPU or other LLM-specific processor to go along with the POWER11. They'd been working on the POWER11 for 4 years, they knew in 2020 that LLMs had a strong potential to be significant for Big Data processing - an area you use big iron for, they're not rank amateurs, they have plenty of reserve, they could have assembled an emergency team to build a vector processor that was custom-designed for just LLM work, and released an LLM processor card that could run circles around nVidia.

They didn't. Because, as has happened before, their management is simply too stupid and too slow.

Perhaps the real problem is that there is simply no reliable way to tell a real human's post from a generative AI's post anymore, since by the AIs are trained on the posts of real humans and are asymptotically becoming indistinguishable from them. You certainly can't simply go by post-quality, since the some of the smarter bots are better posters than some of the, err, less-well-informed humans.

Because of that, it's hard to feel good about putting any real effort into a social media conversation, because in the back of your mind you're always wondering: am I engaged in any kind of constructive activity here, or am I just unknowingly humping a rubber doll that Zuckerberg (or somebody) has provided for my amusement?

What if...

Someone (say someone who was familiar with doxygen and GCC) developed number of comment types, where some stipulated preconditions that must be true for the function to run correctly, postconditions that must be true once the function has run, kernel facilities that the function definitely needs, and kernel facilities that the function definitely doesn't need. These would all be optional for any given function.

A static checker could then validate if the code meets the behaviour expected by the programmer. This is precisely what is done in SPARK, a fork of Ada for high-reliability code. Combined with existing static checker capabilities, this would greatly increase the number of bugs that could be caught with all kinds of tools, AI included.

It could ALSO build a full fine-grained mapping for any fine-grained mandatory access controls system. You'd also want includes that you could import for precompiled libraries. This would allow someone to verify if the code was making unanticipated/undesirable calls but would also make SELinux possible to develop for at the application level.

It would not be trivial. If it was trivial, it would have been done simply because it already IS done in other languages and that makes it "obvious" to anyone who has been programming for a while. However, it should not be massively complicated, simply because you can use AI as the static checker. Once it has a definite set of bounda that must be satisfied, it should be much more capable of knowing what paths would violate those bounds. Which means that the checker stage essentially is trivial today, leaving only the markup stage.

A Dyson sphere would have significant environmental effects too, and it's equally likely to be built.

I'm having a bit of trouble working up any sympathy, as the saying goes.

Is to set coursework and exams that are specifically crafted to exploit where AI is weak or prone to hallucinate.

You do not ban cheating, because those who cheat will inevitably find ways to circumvent the ban.

Rather, you exploit the properties of the mechanisms of cheating to ensure that those who actually understand the ideas are marked relatively highly (regardless of whether they reach the textbook conclusion) and whose who do not understand the ideas cannot do well even if they give what is in the textbook.

The interest should not be in precise answers, but in precise use of tools of reasoning and analysis, because this is what actually matters when it comes to understanding. Yes, it means you can't standardise so easily, and you have to devise things in ways that don't penalise intuitive thinkers over methodical thinkers, but you cannot teach a subject properly if you are only concerned about the surface.