Unfortunately. That's why it is still so prevalent
AI needs much simpler HW (since the SW is bespoke) and that's why we see so many startups tackling this. I'm sure as ML becomes a bigger part of gaming (via coop matrix and LinAlg), we might see analog entering the gaming HW.
Gaming HW has a lot more cruft added on by standards and legacy SW. The number of gaming HW startups can be counted on one hand. QC and Apple have taken generations to get their HW ready. Even Intel needed 2 generations for their dGPU despite having a long line of iGPU
FPGA are very inefficient as compared to ASIC and need dedicated programming. It feels further than analog if we're talking about a gaming HW using them
Maintain the same algorithm optimised for each new generation. The algo needs to tailored to suit the game but adjusting per HW which was a daunting task (and why PC ports were sub optimal on a console comparable HW)
meaningfully novel hardware approaches
This isn't really possible anymore (at least unaided by LLM). In the era of fixed function pipelines, it was possible to do something new under the hood.
The current standards of Vulkan and DirectX have exposed a lot of inner workings to extract performance which makes it hard to make a large shift. While this makes it easy to use the HW, it also makes it hard for the devs to have a single algorithm for diff HWs, ie, each new feature will need in investment by them.
For any novel functionality, devs will not like to work on features only on a small set of HW, unless they are aided by HW vendors. This creates a chicken egg situation: new features don't get prioritized up by devs which makes it hard to market the features which makes it a small market which makes it likely not to be a priority by devs.
In this era where code is cheap, perhaps we'll see more fast moving devs and HW both
And that's the criticism of current design that it doesn't address issues like this and feels like half baked from certain pov
The nothrow (or whatever got deprecated) was a similarly poor design where the headaches weren't worth the benefits
Mostly comes down to how good the default behaviour a library wants to present. Eg: how do we convert a simple if check with a return in case of nullptr with contracts? Do we duplicate and have it in contacts and fn body or just contacts? If just contacts, the compiler will be able to apply optimizations assuming contracts hold but the user might put the contact in observe mode. So, we need duplicate content, and then there's not much benefit of contracts
One major disagreement was on contracts being opt-in, but by who? If we want library-authors to opt-in, then we need a way to run contracts for a library when it's disabled for the compilation unit. If not, then there are all sorts of issues and code repetition between contract and function body.
Both camps refused to budge
Fire with fire means doing a control burn wide enough that when the uncontrolled fire comes, there's nothing for it to devour and keep expanding.
It works unless the wind speeds are too high and then embers can cross the burnt section and start a new fire. Some emebrs are known to fly 100s of meters and that's a dangerous distance to maintain a control fire for
Use automation checks. Most platforms allow adding tests for every small thing.
We have post commit hooks for agents as well as merge protection based on stuff like what you said
Yup. Welcome to the corporate world. It's like a tree full of monkeys.
The one on bottom branches see the higher branch ppl as assholes, the ppl on higher just see a pile of shit below them.
Reality is: they are just monkeys covered in shit
Your own back and hips?