jwatte

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?

the game is fundamentally stingy with cards

Just play blue, that's not a problem then.

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."

Tell me you've never developed a driver, without telling me you've never developed a driver.

"Linux kernel devs tried Rust in the kernel -- you won't BELIEVE the reaction!"

Or run a VM in Windows? Hyper-V is pretty decent for many use cases.

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.

We had it, it was called "Aspie," but somehow that wasn't good enough.

Also, why would you need to compile it more than the one initial time? Are you actually making changes to Luau itself, rather than just using it?

Perfect! I will make sure to follow your instructions precisely.

Voting rights in founder-led public companies, and liquidation preference rights in private investments, are very different things.

Because someone who might invest some money, maybe wouldn't invest that money if they didn't get the preferred class protections?

This is similar to how different credit risks get assigned different interest rates.

Companies failing (or close enough to failing that they restructure and wipe out common) is not uncommon in start-ups. If you want a more or less sure thing, you'll have to work at a more or less sure employer, and the risk/reward will be different.

Now, whether those who exercised their Philz options and paid for the shares, were really aware in what they were doing -- I don't know! But there doesn't seem to be anything explicitly sinister about the way this was set up, or went down -- simply, the business didn't do well enough. Which is too bad, because I think their coffee is actually good.

they force their users to appraise their offering in terms of actual value offered

That's a good thing, right?

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 :-)

If you're necessarily going to go with Lua (not recommended, IMHO) you should at least try luau.

There's a second side of this story, that nobody ever really talks about, because the cost is so diffuse. There are real, legit, uses for fingerprinting. One of the more common ones is anti-fraud for payments, as well as anti-abuse for social sites. I'm sure you've been to forums or other social sites where ban evading trolls, astroturfers, card checkers, and the like cause constant pain for both legitimate users and site operators. When I ran a large site with social interactions and payments/credits, I got deep insights into all the abusers who try to bilk the system for whatever they can. Because fingerprinting is so hard, bad users have an easy time to return with a zillion sock puppet accounts. As a normal user, my estimation is that I suffer more from the actions of those bad users who poison the well, than I would suffer from an internet that made everyone non-anonymous.

Let's say a typical base service (network attached RAM or whatever) has 99.99% reliability. If you have a dependency on 100 of those, you're suddenly closer to 99% reliability. So you switch to higher-level dependencies, and only have 10 dependencies, for a 99.9% reliability. But! It turns out, those dependencies each have dependencies, so they're really already more like 99.9% at best, and you're back at 99% reliability.

"good enough" is, indeed, just good enough to make it not worthwhile to rip out all the upstreams and roll your own everything from scratch, because the cost of the occasional outages is much lower than the cost of reinventing every single wheel, nut, bolt, axle, bearing, and grease formulation.

Another one of the biggest uses of Lua outside the hyperscaler-type software like nginx or redis: Roblox. Soooo many kids run games on Roblox every day!

Roblox not only runs entirely on Lua, but they've been working on their own type inference version of Lua named Luau, and open sourced it, and it's still in very active development.

https://github.com/luau-lang/luau

Yes, the data center was designed for peak load. Unfortunately, the data center is hooked up to the grid. De-coupling that connection is what this article is literally about.

Then again, some data centers just use re-generation from giant flywheels, where the grid powers the flywheel to build up inertia, and thus load can be smoothed that way. The flywheels need to keep running at 60 Hz for at least 30 seconds to give the Diesel generators time to start, should the grid fail.

Run a flywheel at the main transformer, run batteries at your PDC and add supercaps at each point of load, and you may very well be able to show a much smoother load to the grid.

Yes, they do, and no, they don't want to wait longer for the result just because you think they shouldn't.

If I put something up for anyone to read on the internet. And someone reads it on the internet. I can't really control that, right?

Now, if someone makes an infringing use of the thing I put up on the internet. Then I have some kind of recourse, at least through the courts, if I have a lot of money to pay lawyers.

But if someone makes a fair use of the thing I put up on the internet, then I don't have any recourse, because that's the way the law works.

As far as I understand it, using data as input data to a machine learning model that substantially transforms and does not duplicate the input data is currently believed to be fair use.

So, the training use of freely available data seems pretty straightforward that authors can't control when they make it freely available.

It seems like Facebook made use of data that wasn't freely available, though -- ebook rip library type stuff. That's the bit I think they could be in trouble for. But that's just a plain-old "Napster" style copyright question, as far as I understand it.

The lawyer's argument that Llama "obliterates the market" for written works seems weak. I, and anyone I know, put down AI slop fiction before the first paragraph is done, because it's not the same thing as real fiction.

The thing with functional programming (specifically, immutable data,) is that as long as the invalid state is immutable, you can just back up to some previous caller, and they can figure out whether to deal with it or whether to reject up the its previous caller.

This is why Result (or Maybe, or runExceptT, and so on in other languages) is a perfectly safe way of handling unexpected or invalid data. As long as you enforce your invariants in pure code (code without side effects) then failure is safe.

This is also why effects should ideally be restricted and traceable by the compiler, which, unfortunately, Rust, ML, and that chain of the evolution tree didn't quite stretch to encompass.

For systems where correctness is actually important, not just a nice-to-have (in most systems, it's nice-to-have,) we have had an increasing number of options over the years.

From tools like "spin" and "tla+" to proof assistants like Coq to full languages like Idris and Agda.

Some of the stronger-typed languages already give us some of those benefits (Haskell, OCaml) and with restricted effects (like Haskell) we can even make the compiler do much of this work without it leaking into other parts of the program if we don't want it to.

Ditto

Pretty sure Warframe uses it, too.