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.
Do you wake up in a cold sweat at the thought of implementing a new feature in your codebase?
Did you wear a weighted safety blanket during your last sprint planning meeting?
Was the last time you were assigned a ticket with single digit points before “Progressive Web Apps” was a thing?
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.
Picture if you will, a sunny day mid spring. You decide it’s the perfect day for a hike in the woods and as you wander about the winding dirt trail, encircled by a babbling brook on one side, foraging chipmunks with full cheeks on the other, your drifting eyes settle not more than ten paces from you. Strewn about the fallen leaves but still plainly visible; there they are—your requirements.
Ripe for the gathering.
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.