How to avoid drowning in errors when getting serious about monitoring. Finding class of errors and treating them one by one will definitely help.

This is indeed a nice way to approach technical interviews. Unfortunately it requires quite some effort to setup and maintain. You also have to find the right bugs to put in the interview and this is a rarity.

You need to understand how core dumps work? This article is for you.

Nice little utility for Python programming. Helps to introspect on the spot.

Nice suite of tools. The eBPF based ones look promising.

Definitely this. In a world where LLM would actually be accurate and would never spit outright crappy code, programmers would still be needed. It'd mean spending less time writing but more time investigating and debugging the produced code.

Fascinating bug... the fine details of mundane protocols like SMTP can sometimes be surprising.

This can sometimes be confusing. Here are a couple of tips about debugging rpath and linker errors.

Looks like an interesting tool to analyze hard to reproduce bugs, especially when concurrency is involved. This could be useful to find the source of flaky tests as well.

Interesting debug tool for web frontend code. It'd be nice as a browser extension.

Nice tricks to debug the very early boot process, starting at PID 1. gdbserver saves the day here.

Definitely a weird one... still a mystery and unfortunately will probably stay this way. Having the code source could have helped nail it down, could have been interesting.

Interesting subtle differences between gzip and Python expectations which leads to a tough integration bug to find.

A few interesting tricks in there, the web platform definitely helps in term of tooling.

List of strategies to keep in mind when debugging.

Good process for fixing bug. Definitely similar to how I approach it as well.

Very interesting case full of lessons. Of course, increasing the complexity of the system overall can lead to such hard to find issues. It's also a tale into how seemingly innocuous settings can interact in unexpected ways. I also like the lessons learn pointing to the fact that you can and should debug even the systems you use through abstractions, diving into the code is almost always a good thing (even if in this particular case it wasn't strictly necessary in the end). And last but not least it shows the tension between mastery and automation... the more you automate the least you master the system, and at the same time this automation is necessary for building resilience in the system.

Looks like a very powerful tool for debugging and analyzing processes involving a Python interpreter.

I find debuggers to be underused at quite a few places. A shame when you see what they can do nowadays, and they keep improving!

Alright, that's an impressive set of tools they created to build their games. Lots of efforts went into this, very inspiring.