Crafting Code Podcast

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

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/