OK, this is definitely a very cool hack. It can definitely help to debug locally.

Error handling is still not a properly solved problem in my opinion. At least the Rust community discusses the topic quite a bit. This is good inspiration for other ecosystems as well I think.

A good summary on the important rules to follow to debug something.

Early days but this looks like interesting tooling to inspect and debug programs using Rust channels.

An interesting way to approach the topic of GPU programming nowadays. It might indeed make more sense nowadays than reaching for putting pixels on screen as a first objective.

Interesting dive into an heisenbug... Definitely not easy to debug.

Indeed, carefully reading larger chunks of code and looking for the historical context around it can go a long way in finding bugs.

Interesting talk. The tools presented can indeed go a long way helping people figure out what's wrong with a piece of code or learning some of the harder parts of a language.

Very interesting bug hunt prompted by some mysterious character in some strings and leading all the way to PDF viewers.

You like weird bugs involving shell implementations, syscalls and filesystems? Somehow I do, this was an interesting one.

A very important tool to have around and know how to use. This is a neat introduction.

This is an important piece of advice. You need to try things for yourself and fail to really learn. I'm not talking about failing in production of course. But trying to break something locally to see how it behaves, reading the errors, etc. is part of learning. This is how you will troubleshoot things faster the next time.

Nice deep dive into a bug lurking inside a lock implementation.

Looks like a nice tool to navigate mistakes with Rust complex type system.

This is indeed a good way to guide your debugging. Using coverage information can sometimes reduce the search space.

Indeed, more metadata in your database can be a life saver.

Interesting story... when you end up turning to v8 having a bug in the field, you're really in trouble.

Interesting fork of rr to have time travel debugging with software counters. Hopefully will allow using rr in environments where it's limited by lack of access to hardware performance counters.

An excellent article, that troubleshooting skill is really important in many fields... In particular software engineering. It's hard to teach and learn but it makes all the difference.

Looks like a nice tool. Maybe it'll replace my trusty cgdb in some cases.