pornel

4 still shipped with buttons my mum could recognise.

Apple's design never recovered from the flattening of iOS 7.

You get stricter enforcement of public APIs and dependencies. You can't import anything you haven't declared as a dep, and cycles are impossible. Rustdoc by default shows only your intended public API.

OTOH if you have one crate with lots of modules, it's tempting to import anything anywhere and use pub(crate). Rustdoc needs to be configured to show private items if you want to see internal APIs.

Cloudflare is all in on Rust, it's used everywhere by default, and C++ leftovers are being actively torn down.

v4 was a worse overthinker. 4.1 mostly fixed that. It still prefers to plan everything before making a single file change.

If I'm impatient I switch to Luna for a single turn just to get it started and let DS continue.

Excuse me, Hole of America.

The container is useless. Files based on a newer codec won't display anyway.

ISO-BMFF container is bloated and needlessly complicated. AVIF decoders didn't even want to reuse existing MP4 libraries for it due to all the baggage it brings, and implemented their own minimal parsers.

AVIF would have been better off with a simple wrapper similar to RIFF/PNG or extending AV1's own OBU header (which for inexplicable reason gets its data duplicated inside the HEIF container and then implementations are required to verify that both copies agree!)

I hope AVIF will skip AV2. We don't need yet another almost-identical format to migrate to.

And alternative rendering methods like Commanche's voxel weren't doable on the GPU for a long time.

Off-loads sample mixing to the sound card. Computers of that era were slow enough that doing 44100 additions per second was expensive (IIRC quake had 8Khz samples anyway).

HomeKit is so painfully slow and flaky.

I've switched to Home Assistant and the same devices on the same network work instantly, as they should.

Apple is so terrible at this. They have nobody to blame: it's their system, their protocol (I have pre-Matter devices), their home hub, their certified devices.

Home Assistant with a pile of community-maintained python hacks runs circles around Apple.

DeepSeek has very good bang for the buck if you're paying API prices.

1:1 rewrites from C are perfectly doable. You can use C FFI and rewrite function by function, bug for bug, while checking snapshot tests. I've converted a few libraries this way, before AI. I caught C bugs this way, and then was able to further refactor and improve the Rust version. In the end, I'm super happy with the results and I'm never touching autotools or cmake again!

The pool of C software worth rewriting is shrinking. There are the few too-big-to-rewrite projects that will never move, but everything else is either getting rewritten, or has more modern replacements already written directly in Rust.

I can't vouch for LLM-assisted rewrites. The results can be randomly dodgy regardless of what you're writing or rewriting. I suspect we'll get plenty more LLM rewrites anyway, and people will just compensate by sending LLMs hunting for bugs by brute force.

It's been over 10 years since Rust 1.0 was released, and C programmers still see it as a new fad. Yet, the same article mentions, but fails to connect the dots, that even the large slow-moving corporations bankrolling the foundation have already adopted Rust and are leaving C as fast as they can.

It's a typical C mindset that rewriting programs creates new bugs, because it takes years to "battle test" and shake bugs out of a C program. In my experience rewrites in Rust uncover latent bugs of C programs when they finally get checked lifetimes, useful type system, enforced error checking, etc.

Lack of conscience is a unique advantage.

but who's using it? Where are the hordes of SPARC users craving cutting-edge software?

Is it actually any different hardware?

They're advertising is as a Siri thing, but obviously it doesn't run any AI locally. What new hardware does it need to make an HTTP request?

UK typically uses air-to-water heat pumps with convection radiators. The passive radiators are useless for cooling, and condensation on pipes in walls can be a problem.

It's slower and can make more complex mistakes now.

When I tell it "remind me at X to Y", it sets an alarm with a label set to the reminder, instead of an actual reminder. I see it has Gemini's tool calling capability, but it still has Siri's smarts.

Even if you run code server-side, it may be hard to keep algorithms secret if there's anything that can act as an oracle for a reverse-engineering agent.

...or competitors will just burn their own tokens on reinventing the same thing from scratch. It's going to get really hard to come up with some secret sauce that can't be replicated by a swarm of agents that never sleeps.

BTW, GPL is also totally screwed by vibe-copying.

WebP is actually two completely different compression formats developed by different teams at different times for different purposes (VP8 video codec + lossless add-on by Google).

The WebP encoder just has a switch when quality=100, then use the PNG-like format in .webp, otherwise use the JPEG-like format in .webp. WebP at quality < 100 will destroy text, sometimes worse than JPEG, because VP8 can't store color at full resolution. WebP at q=100 will blow up photo sizes by orders of magnitude, similarly to PNG.

AVIF and JPEG XL actually have ability to mix-and-match blurry and sharp compression modes within a single image.

It's typically 15%-30% smaller than JPEG at comparable perceptual quality. Any reduction bigger than that is just loss of quality without further compression improvement, and you could have similarly reduced file sizes by recompressing/optimizing JPEG.

In JPEG file size grows exponentially with quality, which also means that "I can't tell the difference" decrease in JPEG quality makes a huge difference in file sizes.

It's still annoying that if you set quality anywhere below 100, you get half-resolution color (VP8 only has 4:2:0 chroma subsampling).

It's a mistake to assume that Linux with overcommit is the only platform that C runs on.

It hurts both ways. I'm trying to switch to Linux, but the lack of separation between Ctrl-C for Copy and Ctrl-C for break drives me mad. Similarly Ctrl-A for start of line vs Select All, end of line and search pasteboard (there's no search pasteboard!!!)

WASM is about 50%-70% of the speed of native code. That's like having a CPU that's a couple of years older.

It's plenty for a 1996 game.

Rust has first-class support for WASM, so building a browser version isn't hard.

It's not worth it. The value of C is in compatibility, availability of compilers, and familiarity.

As soon as you change anything in a breaking way, start requiring your own compiler/transpiler, or introduce new idioms, you end up losing the things that keep C alive.

Users of C either like it exactly the way it is, or have to use a specific C version due to a vendor dependency or compliance.

An upgraded C not approved by the standards body gives you yet another niche language that is not C, but is still burdened with its old flaws.

I suspect fearless concurrency is another motivating factor. Better perf can be achieved by squeezing more parallelism, but without borrow checking it's difficult to do fine-grained parallelism correctly.

I don't trust agents writing specs without human approval.

I've been bitten by agent-written ADRs. Agents carelessly add extrapolated details and speculated nice-to-haves that I never asked for, and this becomes a source of bloat that keeps coming back like a boomerang.

Quality over quantity :)

The bar isn't getting it perfect. The bar is merely parity with the legacy C++ code that wasn't perfect either, which nobody wants to maintain either.

LLMs are fuzzy when generating, but such conversions aren't done one-shot. Review and test feedback loops are there to catch the random errors. The frontier models are getting good enough at this.

When LLM is instructed to generate idiomatic safe Rust (rather than literal 1:1 unsafe translation), it benefits from a lot of feedback from the compiler.

Whatever QA there was to ensure C++ was good enough can be applied to the Rust version too.

Blocking slop code, like `unwrap_or_default()` in Rust that agents use to weasel out of error handling.

/omfg automatically adds new rules, so I have plenty of project-specific enforcement (e.g. disallowing making certain fields public, which agents love to do to take a shortcut that ruins the architecture).