Crafting Code Podcast

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

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 up an effective board.

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 Efficiency Matrix, and some practices that can help keep flow high.

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, build vs. buy, expensive meetings, eliminating waste, and capital expenditures.

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 better understand how to recognize and avoid them.

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. Understanding these concepts can help you get more out of your next Open Space conference, or help you to build a dynamic event of your own.

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 better. Event-based systems don't have to be complicated to work in, if you do the work to make it easy.

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.