Crafting Code Podcast

Fear is the mind-killer, leaving us convinced that we cannot trust others to make decisions. But being the bottleneck for decision making only slows everything down. Delegating to other people helps them grow and be more fulfilled while also freeing up leaders to do more. In this episode, your hosts discuss the importance of delegation and a framework we've used to help provide clarity on how peop...

Finding your next job can be a difficult task. You need to know what you're looking for and how to sell yourself in your application and interviews. In this episode, Dave and Allan share what they've learned about job searching. We discuss networking, what to do and look for in interviews, and things to consider when deciding if you want the job or not.

'We need to instill a sense of urgency.' This is something we've heard in a few variations at different companies. Is a sense of urgency even a good thing to have on your team, or is it just undue pressure and anxiety? In this episode, Dave and Allan find that they disagree strongly about the semantics of that specific word, but still find a lot of common ground on what we think it should mean for...

Sixty-four episodes is a significant milestone (in powers of two)! In commemoration, Dave and Allan reflect back on how this podcast got started and some of the changes we made along the way to keep it going. We also share a few details about how we record, edit and publish. Most of all, we hope that we are providing something of value to our listeners.

When one of the hardest things in our industry is naming things, it is easy for us to disagree on what words mean as language changes over time and space. The terms 'craftsmanship' and 'engineering' are some that we struggle with and fight over. In this episode, Dave and Allan discuss the concept of semantic drift, what these terms mean to us, and how these terms and our job titles affect how we a...

A cross-functional team is one that has all the necessary people to build and ship a product without having to wait on people outside of the team. But having those people on the team isn't the whole story; how the team works together (or not) matters. In this episode, your hosts discuss the Product Discovery Double Diamond concept, using techniques like '5 Whys' to dig into problems, and letting t...

Practices co-evolve with activities. As we (as in industry) increasingly use AI tools, how will this change our existing practices and what new ones will emerge? In this episode, Allan and Dave discuss practices that we've found valuable and what our experiences have been like incorporating AI into our work thus far. We cover some tried-and-true practices that seem to pair well with AI and specula...

Most software engineers work on teams sharing their code with others. Yet significant portion of people in our industry never elevate their level of code collaboration beyond code reviews (often in the form of pull requests). Allan and Dave have mentioned pairing and mobbing many times, but in this episode they finally talk about what those ways of collaborating actually look like. Listen in as we...

Software patterns are sort of like recipes which offer solutions for particular problems. Familiarity with patterns allows you to speak at high levels of abstraction, communicating a lot of information without having to dive into specific details. In this episode, your hosts share a bunch of patterns, explaining what each one is for and the consequences of using them. Along the way, we point out p...

In order to create really great software, we need more than just coding knowledge. This is why most teams are structured to include and benefit from people with other specialties. What do we expect from these other disciplines, and what should they expect from us? In part two of this two-part episode, Dave and Allan discuss our interactions with operators, testers, architects, and more.

In order to create really great software, we need more than just coding knowledge. This is why most teams are structured to include and benefit from people with other specialties. What do we expect from these other disciplines, and what should they expect from us? In part one of this two-part episode, Dave and Allan discuss our interactions with product managers and user experience designers.

Humans need feedback in order to do their jobs well. Unfortunately, because feedback can often feel negative, it can be difficult to both give and receive feedback. In this episode, Dave and Allan discuss the importance of feedback and share some concepts which have helped us improve. Hopefully some of the ideas will help you to either give better feedback or open yourself to receiving it.

Knowing your audience is good advice for APIs, not just public speaking or selling your ideas. Providing separate APIs for different purposes can make each one much easier to manage, especially when it comes time to roll out updates. In this episode, your hosts discuss how we like to categorize our APIs, how we deal with versioning, and why you might want to follow these patterns too.

Utilizing the skill acquisition models from our previous episode, we can begin to explore how our level of expertise affects us when collaborating with others. Dave and Allan share the 'Dreyfus Squared' concept from Dan North and then expound on it to explore the troubles that novice developers can have and why experts may not be the best at teaching them.

Learning and developing skills is vital in the software industry. But evaluating where you are at and how to take the next step can be difficult. In this episode, your hosts share two models for skill acquisition: Shuhari and the Dreyfus Model. These two models help us understand how we go from novice developers where following the rules is paramount to seasoned veterans that work by intuition and...

Coupling and cohesion are fundamental design considerations, but when sitting down to build a system we often find we need additional guidance. SOLID is a mnemonic for five important principles which help us lower our coupling and improve cohesion, improving our software architectures. In this episode, Dave and Allan discuss each of these principles and how they support and reinforce each other.

Kanban boards have appeared and settled in to the software development world over the last decade or so. And yet, many people use them daily without ever having been exposed to the Lean concepts behind them. In this episode, we discuss the importance of making work visible so that you can have a useful sign board. We also talk about the Lean concepts that make Kanban powerful and some ideas to set...

Lean teaches us that there are two distinct types of efficiency: resource (being busy) and flow (delivering value). Unfortunately, many organizations are so focused on staying busy that they don't have any capacity to improve flow. In this episode, we discuss how Lean can be applied to software development. We discuss the three related laws from queueing theory, why flow is so important, the Effic...

How much does software cost? How do you know if you can afford to build what you want to build? In this episode, Dave and Allan discuss how to figure out your fully burdened cost and then use that rate as a way to judge costs. Not just money, but money over time, which becomes critical in a product mindset where we have to maintain and enhance what we build. Your hosts also discuss making bets, bu...

Optimization is a word that sounds so good. Sometimes we get an idea which we believe will be an improvement to the code and want to just go ahead and implement it. But often these are premature optimizations; changes that may not be needed and in some cases can even make things worse. In this episode, your hosts discuss premature optimization and it's close relation, over-engineering, to try to b...

Part of being a professional coder is being aware of the commitments you make and then keeping them. But the nature of software development often makes it difficult to know how long something will take. In this episode, Dave and Allan discuss how to say yes and no to requests, deadlines, and estimates. We also talk about ways to honor or renegotiate our commitments.

Have you ever been to a conference where you felt like the most useful part was the 'hallway track' where you got to talk with other people between sessions? Open Space Technology builds on this idea, providing the scaffolding needed for attendees to create a custom event. Special guests Mike Clement, Will Munn, and Amy Dredge join us to talk about the principles, admonition, and law of Open Space...

Following on to our previous discussion about event-based systems, in this episode Allan and Dave share some of the strategies they've used utilize events successfully. We cover naming strategies, sources of truth in a system, bounded contexts, anti-fragility, and delivery guarantees. And just because you're using events doesn't mean you have to give up on HTTP APIs; sometimes having both is bette...

Although event-based systems are nothing new, they remain underutilized across our industry and therefore can still feel foreign. In this episode, your hosts talk about why you might want to adopt events into your code. We talk about orchestration versus choreography, temporal decoupling, and different types of events you may encounter.

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...