Interesting exploration of how static and dynamic dispatchs work behind the scene in Rust. The chosen tradeoffs are different than in C++ and that's something to keep in mind.
Too often people mistake the algorithmic complexity theory for the real performances you would get. This can't be further from the truth. The memory layout trumps all. As usual you need to measure.
Looks like a nice improvement over std::unique_ptr for managing pimpl indeed. Really interesting stuff coming in C++26.
Indeed, this design choice comes with lots of issues. It might have made more sense in the 70s though.
Interesting Rust options to limit the amount of heap allocations if you're constrained by memory or for performance reasons.
Unsurprisingly cache locality is a very important factor. What's interesting here is that it still applies to a language like Javascript where you'd expect to not have enough control on the memory layout to reap any benefits.
Interesting experiment on how to totally break the performance of memory accesses. This gives good insights on the whole chain works.
This is just the beginning in a way, but it'll be a game changer for Java. The value classes will allow for better memory density.
Looks like a good book. This review definitely tempts me.
Interesting take on why CVEs are reported differently for C/C++ and Rust libraries. The responsibility for API misuse is treated differently because the abilities to express contracts is treated differently.
Wondering how those are implemented and the challenges behind them? This is a good exploration of the idea.
Wondering about the memory layout emitted by the compiler when a virtual table exists for a type? This is a good summary.
It's about time such a thing gets standardised in C++!
When you look at the binary representation of those characters, things become clear. This opens the door to interesting bitwise operations.
Straight from the uutils rewrite. This is interesting both for the class of bugs which made it (very system integration oriented, unsurprisingly) and the ones which didn't appear at all (anything to do with memory).
Indeed, the memory layout of your structs can matter. Be it Rust or not, but in the case of Rust the use of Option might give the wrong feel about the resulting layout.
Finer grained borrowing is still something people need in Rust. Here is a potential solution to get them today.
So many string types! They all have a purpose of course. It's a good reminder that something mundane like a string type is not that simple.
Failing DRAM chips are real. Here is the case of debugging a single bit flip.
The price hike on RAM due to the LLM as a service bubble is really killing interesting fields. Can't we have nice things? Will the arm race end soon?