Friendly reminder that in C++ that case evolved quite a bit all the way to C++23. Please use the more recent constructs in new code. This definitely leads to better patterns.
Unicode in source code can come with unwanted consequences. Tooling might be required.
Yes... definitely is too complex. This standard seriously needs a pass of simplification, I'm not at all convinced profiles would be enough to help for cases like this.
Unsurprisingly it works OK when it's about finding syntax errors you made or about low stakes mechanical work you need to repeat. The leash has to be very short.
Looks like a good list of pointers to understand languages and compilers... More reading ahead!
This remains the best explanation of why we should have more use of auto in C++ code.
I wonder how much the focus on Python biased that study... Still, maybe we've been wrong at so much emphasis on math skills for computer science and computer engineering curricula.
A good in-depth article about pair programming. Shows well the pros and cons.
Of course, we'd like more to go away... But that's already something.
There are clearly more to know. But this is a good list already.
Some tips which are easily forgotten to get the most out of std::vector.
This is a nice little experiment. Not statistically relevant (there are other papers for that), but shows in the details how introducing Rust can impact the way people work. This is interesting because it means the safety gains are not only strictly coming from the (now infamous) borrow checker. We can't rely on everyone applying all the techniques necessary but for sure they're cheaper to put in place than with C.
The concept of allocators in general and arena allocators in particular is too little know. Here is a little article which rediscover the motives behind them. It's a good introduction to the topic.
Good list of interesting features in Python. Some are tied to the gradual typing system but not all of them. Definitely tricks to keep in your bag.
A new type of strings to keep an eye on in the upcoming Python release.
A few interesting tricks to apply to Java code. Some I already did, but the proposed model for algebraic data types I might add to my bag of tricks.
The language keeps evolving, this is a good reminder that some old idiom can be let go. Parameter packs still need some adjustments to become nicer though.
A bit of a self-serving post towards the end. Still I like it because it clearly mention that it's not about dropping all documentation in favor of the code (quite the contrary in fact, documentation is very much needed). It really is about treating code like documentation, putting the same care into it in terms of readability and understandability. If you wonder what code reviews are for... it's also for this readability concern.
A list of opinions on our field. It's personal and biased of course, so make that you want out of it. I agree with most I'd say. A couple are rather niche though.
Sure, you get good memory safety with Rust. It's important and welcome, but it's just the beginning of the story.