Debugging is frustrating. It feels like a distraction from “real” work, bugs come up at the worst time, you have to read piles of inscrutable error messages that don’t make sense, it’s unclear where to start, and the process can feel very chaotic and overwhelming.
The FEELINGS make everything harder, too: we all know we should be taking a rigorous, methodical, and logical approach to debugging, but it’s hard to do that when you’re frustrated and you just want to get it to work.
And nobody teaches you how to debug! If you’re lucky, you get to pair program with someone who’s good at debugging and explaining their thought processes, and they can show you how do it. But not all of us have that person, so we end up just struggling through it ourselves and learning strategies the hard way.
Sometimes it feels like “google, try random stuff, and despair” is the only option, but it’s not. Since I started learning to program 20 years ago, I’ve learned a more fun (and more effective!) way to debug, where you:
* learn from your bugs, so that you can often skip straight to “oh, I’ve seen this before!” * have a million different ways to make progress, so that you always have something to do next * continuously run experiments to gather information (in debugging, even failed experiments are progress!) * understand exactly why the bug happened, which makes it very easy to fix it * and ultimately, learn from your bugs to become an expert on the things that went wrong
After reading this zine, you’ll have dozens of specific debugging strategies that you can use in any programming language to investigate your hardest bugs.
Glorious. I wish I had had this when I started. Tons of little things I want to investigate, plus big ideas/philosophies that are good to keep in mind (don't just rush to fix the bug, try to understand how it happened).
Pretty much everything I wish I'd known when I first started writing serious software .. or software seriously.
The zine format is perfect for this kind of guide:
* For those new to software development, it is concise, clear and complete. And of course very approachable. In a short read, newcomers can probably absorb 60%+ of the "need to know" that might otherwise take years to learn. * For experienced developers, it is an easily digested and fun little refresher. There are probably techniques here that we haven't thought about consciously for years. The act of remembering can be powerful reinforcement. * In the midst of a crisis. I can easily imaging pulling out the guide to use as a thinking tool when all else has failed.
The book doesn't get bogged down in teaching specific tools, as it is focused more on sharing practical techniques and methods for finding and correctly identifying bugs. Which is the most important skill - once found, most bugs are relatively easy to fix (this is even true of the case cited by Grace Hopper in 1947 that popularised the term "bug" for computer issues when operators traced an error in the Harvard Mark II to a moth trapped in a relay - a gnarly problem, but with a simple fix!)
I am pretty sure that even in a future when AI is writing all our software, these are the kind skills we will still need for when they call in the expensive wetware consultants to "debug" the AI-generated disasters!
Oh, and the book makes fixing bugs sound like a fun and rewarding way to spend your time. Which it can be, even if sometimes only in retrospect with rose-tinted glasses;-)
I personally ordered Julia's whole collection for my own edification, but also justified as an educational expense for the kiddos... . The Pocket Guide to Debugging is :perfection emoji:. All the things I've learned over 20 years and then some, and fantastically structured to boot. I keep it by my desk at the various work places. I enjoyed watching Julia work through the ideas on Mastodon too.
But the best part was watching my younger child read through it in a single go and then wander around the house afterward spouting out how to (and how not to) debug code.
I loved this pocket book, there are so many things I enjoyed from it. I would list them.
1. The size is so convenient you can literally carry it on your purse (which is where carried it). 2. I am a junior developer with tons learn, sometimes reading material on the internet of bigger books can be overwhelming, but the way the book is broken down and illustrated, helps you digest the information in an easier way. 3.The animations, I already listed them above but Omg I truly loved them.
I bough Julia’s whole series after reading this book.
This guide is simply fantastic. Julia summarizes essential steps to debugging, and **properly understanding** any issue that can arise while developing and deploying software. The method in which it’s presented allows for easy understanding, and the manifesto presented is extremely helpful and guiding. I absolutely recommend for any and every developer of all levels. We should all have “The Pocket Guide to Debugging” in close reach.
This zine is such a great collection of strategies and techniques for getting yourself unstuck, a toolkit that would otherwise take years to assemble. The value-per-page ratio is ridiculously high. And while most of the book is focused on technical approaches, I really appreciate the handful of pages that are focused on mindset and self-care. Yes, I will absolutely do a victory lap when I finally solve that bug! 😄
jvns/julia evans zines are what i always recommend when people ask me how to get started learning. The debugging techniques here are a perfect example. things like this are not really ever mentioned in traditional training, materials like books and courses. jvns zines are the perfect medium for this esoteric knowledge.
Es una muy buena guía para aprender a resolver bugs, pero, a diferencia de las otras publicaciones de Julia, no siento que sea tan esclarecedora y profunda.
Creo que a los perfiles que más les puede ayudar es aquellos que van empezando, pero tiene cosas valiosas para todos los programadores.
Aún así, creo que es una lectura imperdible para todos los que nos dedicamos a programar.
The debugging tools chapter could have been a little bit more extensive, at explaining what each tool does, but it was a great learning overall, I have taken many notes to put in practice next time I am working on a bug.
I thought this was a great book that is easy to read and contains simple to understand graphics. The day I placed my order, I received the book in PDF version while I awaited the print version. Julia has great tips on debugging strategies to help find bugs that surface during the stages of software development. I found this book useful and would recommend it to anyone willing to invest in themselves to become better software engineers - especially for those of us who are new to the field.