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?
Indeed be careful at how you use strings when interacting with C APIs. String views are likely not what you want in that context. There is a reason why they don't have c_str().
Long and comprehensive look at how zswap and zram work. They each bring their own tradeoffs, it's important to understand them to choose.
Interesting story on how sometimes you can be betrayed by your memory allocator.
Of course it's a question of the amount of allocations you need.
I used to do that, fell into the "taking notes on the computer". And clearly it's not the same, I'm thinking going back to paper notebooks soon.
Looks surprisingly easy to profile the Django startup. Probably makes sense to profile other parts of your application but this is likely a bit more involved.