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.

Very early days for research on this topic and the sample is rather small still. That said the results are interesting, there seems to have a few biases inherent to the use of such an assistant, there's also clearly a link between the AI agency and the quality of what gets produced. We'll see if those result holds to larger studies.

What the title said, there's nothing fancy about optimizations. It's mostly well known knowledge, doesn't change much over time or on different stacks... still it's very satisfying.

Definitely this! It's important to model properly your domain and leverage smart value types everywhere it makes sense. This can prevent quite a few different types of bugs.

Good reminder that "premature" doesn't mean "early". Poor Knuth is so often badly quoted in the context of optimization that it's really sad. The number of times I see "early pessimisation" on the pretense of avoiding "premature optimization". Such a waste...

OK, the writing is sometimes a bit biased in my opinion (didn't you know Python is superior to any other language?). That being said, this is an interesting resource to get ideas on how the GoF proposed set of design patterns apply in the Python world. I like this kind of "how do things relate" resources.

Very interesting musing about the UX divide between GUI and CLI/text and how this could be approached to have both interacting better.

Very thorough article with plenty of tips and ideas on how to run nice pair programming sessions.

Very good overview about RAII, ownership, borrowing references. All that comparing C++ and Rust in their ways to handle those concepts. Definitely a must-read even though it's a bit long.

Always interesting when a language influence the use of another one. I like this kind of epiphanies.