The Cat Ate My Source Code

Collin Cierlak
Aug 14, 2019 · 3 min read

Software engineering is an ever changing landscape, and so we here at GumGum are constantly striving to sharpen our skills and emulate best practices in our day to day work. However, knowledge is much more valuable when shared and though we already share this knowledge among our engineering teams, we want to extend that principle to the outside world as well.

So for the past year we have been churning out episodes of our software engineering podcast, The Cat Ate My Source Code, in an effort to spread what we learn from our experiences working at GumGum tempered through the lens of a staple book of the software engineering community. Hosted by three of our engineers: Azam Abdulkadir, Ben Koch, and Collin Cierlak; we go through The Pragmatic Programmer by Andrew Hunt and Dave Thomas break it down concept by concept to explain how we can apply these best practices in an enterprise environment.

Episode one dives into the first chapter of the book and covers ideas on fighting software entropy, maintaining your knowledge portfolio, what makes a programmer pragmatic, and more!

Code Duplication & Orthogonality — eliminate one and focus on the other. In this episode we cover the evils and benefits of these topics. Moreover, we seek out common causes of duplication and what kind of impact maintaining an orthogonal system can have. The episode is technically opinionated, so be prepared to have your opinions ready and minds open.

Ready… Aim… Fire!

In this episode, we (along with special guest — Alex Wang) discuss product management and how to quickly and accurately take a project from an idea to a usable product. Drawing upon our experiences as developers interacting with product managers daily, we touch upon when to use prototypes, delve into estimation techniques, and argue a case for using tracer bullets, that is, a way to iteratively develop upon project requirements.

In our day to day experiences as software engineers, we regularly write code or interact with services that don’t live up to good standards or in some cases are error prone. In which case we have to be resilient and put measures in place to handle such scenarios. In this episode we discuss contracts, intentionally crashing programs, assertions, exceptions, and resource management — all of which are methods to survive in our unsafe world.

If you answered “yes” to any of those questions (or just sobbed quietly to yourself), we have everything you need to put an end to the madness. In this episode we tackle architecting a flexible codebase, reducing coupling, and designing your application so it can stand the test of time.

In this episode we go over the 6th chapter of The Pragmatic Programmer, discussing the hazards of programming by coincidence and how to write tests that ease the pain of refactoring with special guest Software Engineer, Steve Kiley.

Requirements are seldom ready to be gathered together and neatly placed in your ticket; more often than not they need to be refined in the fires of discussion and push back. In this episode we distill down techniques for digging for, polishing up, and (ultimately) throwing away your requirements.

We’re always looking for new talent! View jobs.

Follow us: Facebook | Twitter | | Linkedin | Instagram


Thoughts from the GumGum tech team

More From Medium

More from gumgum-tech

More on Software Development from gumgum-tech

More on Software Development from gumgum-tech

Optimizing Sequelize Queries


More on Platform from gumgum-tech

More on Platform from gumgum-tech

Migrating from Cassandra to ScyllaDB


Welcome to a place where words matter. On Medium, smart voices and original ideas take center stage - with no ads in sight. Watch
Follow all the topics you care about, and we’ll deliver the best stories for you to your homepage and inbox. Explore
Get unlimited access to the best stories on Medium — and support writers while you’re at it. Just $5/month. Upgrade