It's good to also see articles which point out the problems with Rust. Overall I find it an interesting language but people tend to oversell it too much. This is a nice reminder it already carries complexity issues.
Excellent conclusion to the recent turmoil around undefined behaviors. The way they are currently used as definitely a problem, they shouldn't be ignored in your code (although that's admittedly not that easy). There's hopefully a path forward.
Nice primer on std::variant. Covers all the bases of how to use it properly.
Problems with integers now. Kind of better known usually, still to keep in mind as well.
Excellent piece about technical debt. The approach proposed is definitely the good one, it's the only thing which I know to work to keep technical debt at bay.
Nice set of problems encountered when using floating point numbers. Definitely to keep in mind.
Nice resource to get started with Prolog.
Since I'm also a bit of a nerd of nice programming language features, that's an interesting list (mostly) coming from less known languages. Some of that syntactic sugar would be welcome in more main stream languages I think.
Like it or not, this is definitely filling a very unique niche. It's a very good fit for system software where safety is important and available time limited. There is no better option for now.
Good points, this shows quite effectively the problem with blindly following rules without keeping in mind the reasoning behind them.
Good piece. I like how it frames the debate, asking the right questions on where might be the assumptions on how testing is done.
Excellent piece about naming things in code. The conclusion is perfect of course: it's hard but it pays off.
At least a good balanced post about Generative AI and programming. It's not overestimating abilities of the latest trend in large language models and moves away from the "I'll loose my job, developers will be replaced with AI" stance.
Good balanced view about pair programming. I'd definitely like to practice it more, although whole days might be a bit too much and too exhausting.
Words of caution regarding the use of language models for producing code. This can derail fairly quickly and earlier than you'd expect... without noticing it.
Don't believe claims about Rust (or any other options in fact) being a language for universal use. It has a few spaces where it shines and others where it'll be a drag. Picking the right language and stack is a multi-factor decision process where the technical advantages of the language itself say less than half of the story.
Good reasons to use [closed, open) intervals. If you didn't know where it was coming from, here it is.
I love this kind of explorations. Where does the term boilerplate code come? Let's find out.
Illustrated with Java, still this highlight fairly well the caveats of mutable collections in multithreaded code.
This is a clever and important use of =delete which I sometimes miss in other languages.