If you have enough money to have enough gpus to network them, you can probably afford the maybe $500 tops to get some rdma capable used 10 gigabit enterprise gear and get that latency sub 100 microsecond for local.
I remember solving this problem before. These are both global components, so you create a single global instance and control them with a global context or function.
You basically have a global part of the component and a local part. The global part is what actually gets rendered when necessary and manages current state, the local part defines what content will be rendered inside the global part for a particular trigger and interacts with the global part when a trigger condition happens (eg hover timeout for a tooltip).
Since the original point of this chain was a comparison between the energy efficiency of biological vs machine learning, then we need to be trying to understand if the machine is more efficient than the human. You don't need to make some moral or philosophical argument about existential justification to accept that taking a more efficient approach is better, in that it generally enables more life for the same energy.
If the true, total cost of a machine to perform some task is less than a person to do the same task, then the machine should do it and the person should move to do what the machine cannot. This means more energy is available for everything else, living included.
We're efficient once we have the energy, sure. How much energy does it take to go from raw sunlight to a calorie your body is actually able to use, and finally to your dinner table?
I hate writing by hand the same way I hate walking through deep sand. It's extra effort for the same distance and I'm mentally way ahead of where I am physically.
#2 I expect to wind up as a huge win professionally as well. It lowers the investment for creating an MVP or experimental/exploratory project from weeks to hours or days. That ability to try things that might have been judged too risky for a team previously will be pretty amazing.
Public API refers to the user of the class, not the implementer. You never call __init__ directly. __new__ allows modifying object creation itself for the implementer, but the user of the class will never call it.
I find it strange to see this sentiment... how far down the stack do you go before it stops being "configuration" to you?
Let's imagine building a video chat:
Are you going to build an OS from scratch?
Network protocols?
Encryption?
The rendering engine for it?
Compression algos?
Just how much of this do you consider "not configuration"? I think this all sounds very much like "old man yells at cloud" pining for a past that never actually existed.
Hierarchies are possible with an RDBMS, but I'd suggest it's the wrong tool to model them with, unless they're static of course. Really any graph that can't be encoded in the table relationships themselves.
This sounds like a graph problem similar to the google unit conversion problem (https://alexgolec.dev/ratio-finder/). You could probably do a data driven solution, but the gist is convert to and from one normalized form. Then it's n*2 functions.
This is probably what you're implicitly doing with the class solution you're talking about.
I've been using rust for a few weeks and I'm finding it fairly pleasant overall, but I agree on the syntax issues. I've hit some snags (in particular, graphs, but this is a common snag on constrained languages, Haskell has trouble with them too) but overall nothing serious and I'm not afraid to go down to unsafe.
I think they made a mistake using C++ style generic notation. D lang has a much, much nicer syntax for generics, and the language's readability would much improved with that syntax imo. As is, I find parsing the error messages that come back from type mismatches quite challenging. Reading documentation on traits on docs.rs, I find the actual trait name very hard to pick out in the noise. Maybe I'll get better with that over time.