Drafting last Friday, my first hand was zero lands, my second hand was one land, my third hand (bottoming two) had three lands. However, I then kept drawing four-drop spells and no more lands for 8 turns.
So is it "on me?" Or is it just that the game just is high variance?
Hard real time is a thing in some systems.
Also, the current approaches might have 85% accuracy -- if the LLM can deliver 90% accuracy while being "less exact" that's still a win!
Humans do it with access to the register-level data sheets, which are only available under NDA, and usually with access to a logic analyzer for debugging.
Usually, the problem with developing a driver isn't "writing the code," it's "finding documentation for what the code should do."
Ctrl-Z suspends the program in most UNIX shells. ("fg" to resume)
Ctrl-S may or may not end up stopping the program, depending on how much it's printing, and how much output buffering there is before it blocks on writing more.
All my shell RCs turn off xon/xoff -- that's a relic from the PDP-11 days we can all do without.
Windows has the Scroll Lock button that's supposed to do this if you need it, but typically, just selecting a character in a terminal emulator will stop the scroll while still buffering the output.
I don't think this analysis matches the underlying implementation.
The width of the models is typically wide enough to "explore" many possible actions, score them, and let the sampler pick the next action based on the weights. (Whether a given trained parameter set will be any good at it, is a different question.)
The number of attention heads for the context is similarly quite high.
And, as a matter of mechanics, the core neuron formulation (dot product input and a non-linearity) excels at working with ranges.
Tool using LLMs can easily be given a tool to sample whatever distribution you want. The trick is to proompt them when to invoke the tool, and correctly use its output.
Huh? It sounds to me like this is arguing one should be OK with /r/conservative doing it (and joining up, even) but then not OK that other subs do it, too.
That doesn't really pass the sniff test, so maybe I'm missing something.
Python is still a 10x or more performance sacrifice for anything that's actually CPU throughput limited.
Or, alternatively, your VM hosting cost will be 10x larger on Python, than something top of the line, if your workload is CPU throughput limited.
Whether you're actually CPU limited, and whether VM hosting costs is your largest cost, is a totally different question :-)
Trunk driven development has worked well everywhere I've used it.
That being said, pull requests / code reviews / merge commits are totally compatible with that. Gerrit, for example, does every commit as a mini-pull-request on top of a branchless HEAD, and when the review finishes, you merge to main/trunk and off to CD it goes.
Having maintained a C++ API and ABI based on implementation inheritance with virtual functions, I have deep respect for both kinds of compatibility. Someone even used placement new to put objects with vtable pointers in shared memory, expecting destructors to work in a different process!
Check out the "fragile base class problem" some time for more things than can go wrong.
Something that want made explicit: If you support closed source, shipping binaries, then the ABI can't change, or you break all compiled binaries users have installed.
If rebuilding the world from source is an option, changing the ABI is an option.
(Introducing a new ABI for new subsystems is still OK - hence renaming libc when it changes)
(Say what you want about Microsoft, but COM solved that problem pretty well in the '90s...)
So is it "on me?" Or is it just that the game just is high variance?