Come on, even if that's true, it's obviously a very different situation.
For one thing, the grocery store is deciding what produce to stock and what suppliers to get it from. They can choose suppliers that have at least a minimum standard of quality. They don't just let anyone on the world slap a barcode on anything at all, claim it's a grapefruit, and put it into their stores.
For another, a large fraction of produce (though not all) is bought in person, and customers can see if it's obviously bad quality before buying it, unlike Amazon where all you have to go by is the product listing for the SKU.
But the per-request cost is not the only one. You're also paying $0.02 per million CPU-microseconds. If you do the math, that's easily double or triple the equivalent hourly charge for VM instances from the various major cloud providers.
For now, you're benefiting from the zero idle charges and Cloudflare's generous free allowance, because you're at a small scale. As you get bigger, the effect of those factors -- as a fraction of your total spending -- will decrease by a lot, and you'll still be paying the inflated unit costs.
Go does hardcode system call numbers on Linux, but it doesn't on Windows. Instead it follows the normal Windows convention of calling the userspace wrappers from kernel32.dll and similar libraries.
Unlike on Linux, the low-level syscall numbers on the NT kernel are highly unstable across releases, so programs that try to call them directly will generally only work on a very specific kernel version.
I wonder if due to C slowly fading away things like syscall
ABI, kernel numbers, etc, will start getting more stable, not just on Windows but on macOS too
There still needs to be a cause for working directly with the kernel interface instead of going via the userland interfaces (libc on Linux, kernel32/user32 on Windows, macOS frameworks) to justify the required effort, and the use cases are basically only DRM, malware, malware detectors and anti-cheat.
In that respect, it reminds me a bit of the busy beaver problem.
I wonder: consider the decision problem of determining whether or not a given still life is glider-constructible. Is this problem known to be undecidable?
It's straightforward to show that an "inverse" of this problem -- given an arbitrary glider construction sequence, does it result in a still life? -- is undecidable, because gliders can construct patterns that behave like arbitrary Turing machines.
My understanding is that the only still-lifes known not to have a glider synthesis are those containing the components listed at [0], which are 'self-forcing' and have no possible predecessors other than themselves. Intuitively, one would think there must be other cases of unsynthesizable still-lifes (given that a still-life can have arbitrary internal complexity, whereas gliders can only access the surface), but that's the only strategy we have to find them so far.
> Maybe it's time to try pushing the envelope on this: what's the biggest blobbiest most spacedustful period-4 c/2 orthogonal spaceship that current technology can come up with? Might there be some kind of extensible greyship-like thing that escorts a patch of active agar instead of a stable central region, that might allow an easier proof of non-glider-constructibility?
I always enjoy the absolutely incomprehensible GoL jargon
Is it that easy though? Because the Turing machine constructions we have in the game of life are clearly not still lifes, and I don't know if you can construct a Turing machine which freezes into a still life upon halting.
You can make a Turing machine that contains self-destruct circuitry which destroys all moving parts upon halting. The resulting pattern will be a (pseudo) still life.
Since GoL is Turing Complete,is such an inconstructable pattern an example of godels incompleteness theorem? I feel like I must be confusing some things here.
I notice that the stars don't seem to be rendered correctly. If you zoom out, you can see the sun's position relative to the stars. As you scroll the date slider through the course of a year, the sun should make a complete 360-degree revolution around the ecliptic. Or, when the camera view is locked to the sun, the stars should appear to revolve relative to the sun.
Instead, the sun appears motionless against the stars, regardless of the time of year. (If the demo used actual star positions, I would be able to point to how the sun was in the wrong constellation for a given date. But the starfield is randomly generated, so you have to actually observe the sun in motion to see the bug.)
I guess it's just a display bug, then? Though it's hard to imagine what kind of bug would lead the game state and the visual representation to get out of sync in that particular way.
They're probably using an OSS chess engine in something like C++, but using HTML/CSS/JS for the interface. 90% moves could be represented by a chess board as a 2D array, checking the engine accepts it as a valid move, and then replacing what's on that square be it empty space or a now captured piece. Castling, pawn promotion, and en passant are the edge cases with en passant being the most obscure.
My guess is they only remove captured pieces on the moved-to square (maybe relying on an implicit capture by overwriting an array entry). This is probably easier than actually tracking pieces that get captured.
The game is likely in javascript but because of this bug we know it's not using React because with React the programmer doesn't update the view, React does.
Don't get me wrong, it's fun to see performance optimizations like this.
But I'd expect that a naive implementation of the same strategy would already take like 0.1% of the time needed to actually generate embeddings for your chunks. So practically, is it really worth the effort of writing a bunch of non-trivial SIMD code to reduce that overhead from 0.1% to 0.001%?
But the bottleneck is generating embeddings either way.
memchunk has a throughput of 164 GB/s. A really fast embedder can deliver maybe 16k embeddings/sec, or ~1.6GB/s (if you assume 100 char sentences)
That's two orders of magnitude difference. Chunking is not the bottleneck.
It might be an architectural issue - you stuff chunks into a MQ, and you want to have full visibility in queue size ASAP - but otherwise it doesn't matter how much you chunk, your embedder will slow you down.
It's still a neat exercise on principle, though :)
It doesn't matter if A takes much more time than B, if B is large enough. You're still saving resources and time by optimising B. Also, you seem to assume that every chunk will get embedded - they may be revisiting some pages where the chunks are already present in the database.
Amdahl's law still holds, though. If A and B differ in execution times by orders of magnitude, optimising B yields minimal returns (assuming streaming, vs fully serial processing)
And sure, you can reject chunks, but a) the rejection isn't free, and B) you're still bound by embedding speed.
As for resource savings.... not in the Wikipedia data range. If you scale up massively and go to a PB of data, going from kiru to memchunk saves you ~25 CPU days. But you also suddenly need to move from bog-standard high cpu machines to machines supporting 164GB/s memory throughput, likely full metal with 8 memory channels. I'm too lazy to do the math, but it's going to be a mild difference at O($100)
Again, I'm not arguing this isn't a cool achievement. But it's very much engineering fun, not "crucial optimization".
OK, but isn’t the key take-away from the Challenger disaster all about the consequence of organizational dysfunction and fear of speaking up?
It wasn’t really a “design flaw” or “weak link” as much as it was management disregarding the warnings of engineering staff. The cold temperature limitation was known in advance by the Morton Thiokol engineers but their management refused to relay the warnings of engineering to NASA and NASA was under pressure to fly. IMHO this was a failure of multiple, mostly organizational, systems rather than “one weak link”.
Likely yes, because NASA and other agencies were able to portray the incident as an O-ring failure. It was in fact just that management was indifferent to the risk to the astronauts on board. The only individual who accurately reported on the disaster was Feynman.
The o-ring was still the weak link, a small part that decision makers assumed was insignificant whose failure caused the complete destruction of a massive system and tragic deaths. The organizational failures are just why the weak link wasn't addressed. We can say with hindsight that things should have been better communicated and the warnings should have been heeded, but the fact is they were dealing with a complex system where the risk was sufficiently non-obvious that they could disregard the warnings.
Completely unrelated. Laffer curve is total tax returns as a function of tax rate (usually used to show that at some point T = t*Y(t), where t is the rate and Y is the taxe base, dT/dt < 0).
This is about how Y works, not as a function of t but of, well, everything else.
It's true that no matter what symbolic representation format you choose (binary or otherwise) it will never be able to encode all irrational numbers, because there are uncountably many of them.
But it's certainly false that computers can only represent rational numbers. Sure, there are certain conventional formats that can only represent rational numbers (e.g. IEEE-754 floating point) but it's easy to come up with other formats that can represent irrationals as well. For instance, the Unicode string "√5" is representable as 4 UTF-8 bytes and unambiguously denotes a particular irrational.
> the Unicode string "√5" is representable as 4 UTF-8 bytes
As the other person pointed out, this is representing an irrational number unambiguously in a finite number of bits (8 bits in a byte). I fail to see how your original statement was careful :)
> representable in a finite number of digits or bits
Isn't "unambiguous representation" impossible in practice anyway ? Any representation is relative to a formal system.
I can define sqrt(5) in a hard-coded table on a maths program using a few bytes, as well as all the rules for manipulating it in order to end up with correct results.
Well yeah but if we’re being pedantic anyway then “render these bits in UTF-8 in a standard font and ask a human what number it makes them think of” is about as far from an unambiguous numerical representation as you could get.
Of course if you know that you want the square root of five a priori then you can store it in zero bits in the representation where everything represents the square root of five. Bits in memory always represent a choice from some fixed set of possibilities and are meaningless on their own. The only thing that’s unrepresentable is a choice from infinitely many possibilities, for obvious reasons, though of course the bounds of the physical universe will get you much sooner.
For one thing, the grocery store is deciding what produce to stock and what suppliers to get it from. They can choose suppliers that have at least a minimum standard of quality. They don't just let anyone on the world slap a barcode on anything at all, claim it's a grapefruit, and put it into their stores.
For another, a large fraction of produce (though not all) is bought in person, and customers can see if it's obviously bad quality before buying it, unlike Amazon where all you have to go by is the product listing for the SKU.
reply