Crafting Code Podcast

Working independently on your own source code branch seems like a great idea until you have to merge it to the mainline. Just like with parallel processing, the bottleneck often comes when you try to combine results. Trunk-Based Development revolves on a simple idea: always commit your changes to the mainline daily. In this episode, Allan and Dave discuss this concept, the benefits, and how to use feature flags to decouple deployment from release.

At any given point in our careers, the skills we have developed and the experiences we have gained (or the lack thereof) can influence how we think about our work and how we make decisions. In this episode, your hosts discuss how we can identify and deal with these biases. From Dunning-Kruger to over-planning to working without a net, we cover how we internalize these biases. Then we talk about interactions with other people and the need to leave space to be wrong and give grace while others develop their skills.

Should code design be something we should have in mind when starting, or should we allow it to emerge from a test-driven design process? How much mileage can we get by getting better the up front design process before we run into a Design Quality Paradox? Can coupling and cohesion guide us to how small we ought to break up a function? Are code comments important to design or something to be avoided? In this episode Allan and Dave react to a written debate between John Ousterhout and Uncle Bob Martin. You can read the debate at https://github.com/johnousterhout/aposd-vs-clean-code/blob/main/README.md

The need to learn is taken as a necessity in our industry. And yet, most who write code spend almost all their time in performance mode and very little in learning mode. We are delighted to have special guest Steven Diamante join us to talk about this topic. We discuss the importance of learning on your own and in groups, and talk about ways to improve learning outcomes in our training meetings.

The effort required to author a good book can lead to a depth of understanding that doesn't come as readily to other mediums. And when a good book stands the test of time, it's worth sharing. In this episode, Dave and Allan share our recommendations for books we think are worth reading if you are serious about software. We grouped these recommendations into some categories from generally applicable to most developers to the more specialized deep-dives.

Applying Conway's famous Law tells us that software architecture and culture are intertwined. How people communicate affects how they architect their software. And the reverse is also true: being intentional about an architecture can change how people behave. In this episode, your hosts discuss this hidden coupling and how important it is to align the two.

The culture of your company has a big influence on how much you enjoy your job. Unfortunately, finding one that fits just right for your unique combination of people is hard. On top of that, there are inevitably subcultures within the larger organization. In this episode, Dave and Allan discuss things we've valued in company cultures, things we watch out for, and some ideas on being intentional in influencing a culture.

We often hear stories from successful companies shared across the industry, but usually what they did to succeed doesn't work for us. Are there principles that are independent of the organizations that we work at? Coda Hale thinks there are. In this episode we review the article, 'Work is Work' which you can read at https://codahale.com/work-is-work/

Why is asking questions such an important soft skill for software developers? Is a mindset of inquiry a way to learn more and engage in better, open communication? How can we utilize questions during retrospectives and blameless postmortems? Can questions be an important teaching tool? Will you learn more about asking questions by listening to this episode?

In the physical world we readily intuit how context matters in decision making. For example, a compact car is a perfectly fine vehicle, but may not be suitable for hauling a large load. Context informing software decisions may be even more important, since it isn't as obvious. In this episode, your hosts discuss the need for context and values as we look at 'best' practices, non-functional requirements, and patterns.