GrantMoyer
Joined 2 years ago
Joined 2 years ago
[1]: https://web.archive.org/web/20260312134021/https://developer...
[2]: https://web.archive.org/web/20260328133800/https://developer...
The line doesn't exists. It's most profitable for the company to repeatedly:
1. Have an ad-supported tier and a no-ads tier
2. Wait for most people to move to the no-ads tier
3. Introduce ads into the no-ads tier
4. Wait for people to get sick of ads
5. Introduce a new, higher cost no ads tier
There is no threshold where it's more profitable for the company to never introduce ads at that price point.
Superficially, that benchmark and this one seem to be taking similar measurements. They both measure encoded size versus encoding time versus perceptual quality metrics, although they present the data on plots with different axes. I haven't tried to reproduce the results of either, but I have no reason to doubt either benchmark.
I wonder what accounts for the difference. Maybe the libavif encoder got a lot better in the last 2.5 years. The older benchmark uses libjxl v0.10.0 and libavif v1.0.3, while the newer one uses libjxl v0.12.0 and libavif v1.4.2. Or maybe it's the set of images used. The older benchmarks aggregates results for small test sets of images, while the newer benchmark tests individual images. The newer benchmark does find an image where libjxl wins on file size (the weasel), but it still loses on encoding time, whereas in the older benchmark libjxl almost always won on both. Or maybe it's the hardware (M3 Pro vs. M4 Pro).
[1]: https://cloudinary.com/blog/jpeg-xl-and-the-pareto-front
I've read that contracts fundamentally require a "meeting of the minds", where two parties come to a mutual understanding of an agreement. At the same time, overwhelming people are expected to not read and understand contracts they agree to. I don't understand how these two facts don't combine to mean the vast majority of written contracts are not legally binding, but apparently judges don't share my confusion.
[Are they hot?] -No> <Ignore>
|
Yes
v
[Are they wearing a ring?] -Yes> <Ignore>
|
No
v
…
I don't even know what that last step would be. It's not going to be sex. The woman is at work and the two don't even know each other.Maybe that's not what the author is thinking. I don't know, because I can't understand what the author is thinking. I'm alienated.
I think it's a good thing to keep in mind, that the actual implementation of Rust almost certainly isn't sound. Even an "ideal Rust" still has unsafe, which can affect the soundness of even faraway safe code. But I don't think it's nessesarily wrong to talk about Rust as if it were safe. Much of our communication has implicit assumptions, and the way we talk about Rust is no different. It would be exhausting to qualify every discussion of saftey with "assuming the compiler has no bugs", "assuming all unsafe code follows the (not fully specified!) rules", etc.
Ultimately it's like any other implementation of theory into practice. The theoretical model of Rust lets us reason about and design an implementation to achieve certain practical goals even though the model is a simplification of reality. In Rust's case, practical use has demonstrated it achieves design goals like reducing bugs and reducing development time (compared to peers like C++) to a substantial degree.
> Surely the compiler can just check if each access is valid.
Well, sometimes it can, but sometimes it doesn't know how long the array is. What if the array is passed as a pointer?
> Maybe each array could be annotated with its size at runtime, and accesses could be checked at runtime too.
That works, but it adds runtime cost that may legitimately be too much for some applications, for example, a Gameboy game (set aside that many Gameboy games were written in assembly).
> Fine, so we'll make the programmer promise to ensure array accesses are always valid. Maybe they'll make a mistake sometimes, but what's the worst that could happen? Throwing your hands in the air and saying the compiler is allowed to do anything, that's just stupid.
Well, maybe it's stupid, but this is one thing that could happen if you accidentally write past the end of an array: https://www.youtube.com/watch?v=Vjm8P8utT5g. I'm sure neither the programmers nor compiler writers intended that.
Ultimately, the compiler can't guarantee any behavior if its assumptions are violated. The example may seem contrived, but it demonstrates that, given the right circumstances, the results of the logical contradiction are unbounded. This is a direct consequence of the "Principle of explosion": https://en.wikipedia.org/wiki/Principle_of_explosion. On second thought, maybe the runtime costs of array bounds checking are an acceptable trade-off after all.
There's a caveat where some style guides permit using a comma without a conjunction in specific contexts, but most don't.
For example, you can donate to Sci-Hub with cryptocurrency. Sci-Hub has an ideological mission which is widely supported, but it runs afoul of copyright law and is illegal in nearly every country and sanctioned in many. You cannot donate to Sci-Hub with fiat currency.
Unfortunately, I agree that in practice >99% of cryptocurrency's use is for scams.