Why ‘Correctness’ and ‘Code Quality’ Are Misleading: Embrace Verifiability and Agility

In this episode of Code and Optimism, I argue for replacing the subjective terms ‘correctness’ and ‘code quality’ with ‘verifiability’ and ‘agility’ in software development. I explain how these alternatives provide objective measures and practical benefits, driving impactful and adaptable projects. I outline the importance of solving meaningful problems, setting good requirements, and managing code effectively for agility while verifying impact through automation. Discover how pursuing correctness and code quality has been leading your team astray, and rediscover what truly matters for maximizing your impact on the world.

00:00 Forget Correctness and Code Quality

01:53 Start with Solving a Real World Problem

05:05 Good Requirements

07:21 Correctness vs Verifiability

12:12 Quality vs Agility

14:37 Lint Rant

17:26 Agility and Code Debt

22:15 Verifiability AND Agility

25:51 Outro

Related:

• Forget “Code Quality” and “Correctness” — Verifiability and Agility are the True First Principles of Software Engineering Blog Post
• Organic Modular Design Blog Post C&O Episode #39
• Embracing Software Agility Blog Post
• Modular Testing - C&O Episode #38

Hosted on Acast. See acast.com/privacy for more information.

Most software teams are drowning in complexity—but with your help, we can change that story.

In my latest episode of Code and Optimism, I share a little-known secret: modular design, when done right, isn’t just for architects or the early stages of a project. It’s something every developer should be doing every day. I call it Organic Modular Design—a real-world approach where modules grow naturally as the code evolves.

Here’s the kicker: if we’re not constantly maximizing modularity—from the project’s inception through the very last code edit—our project’s complexity will spiral out of control. But it doesn’t have to be this way. With a few key principles, we can stop the chaos and keep our codebase healthy and scalable.

The payoff? Logarithmic complexity scaling instead of the quadratic-scaling mess that kills most projects. Curious? This episode might just change the way you code forever.

As always, I don't claim to have all the answers. Anyone who says they do is either a fool or is selling something. For my part, I'm always trying to learn how to solve problems faster with software, and I'd love to learn with you. Send some feedback my way. Let's talk!

00:00 Introduction to Modular Design

00:55 Organic Modular Design (OMD)

02:12 The Modular Life Cycle

02:49 DRY Principle and Function Modules

04:43 File and Folder Modules

07:46 Encapsulation and Interface

17:07 Packaging Modules

23:58 Conclusion and Key Takeaways

• Monorepo tooling: @art-suite/monorepo

• E12: Complexity Fighting Super Powers https://youtu.be/cj81OhXpQCU
• E13: The 5 Essential Elements of Modular Software Design https://youtu.be/V_mOC8I86ic

• The 5 Essential Elements of Modular Software Design https://medium.com/@shanebdavis/the-5-essential-elements-of-modular-software-design-6b333918e543

Hosted on Acast. See acast.com/privacy for more information.

Why You Should Stop Doing Unit and Integration Testing - Embrace Modular Testing Instead!

In this episode, I challenge conventional testing methods and present a new approach—modular testing. I argue against traditional unit, integration, and system end-to-end testing, highlighting their inefficiencies and complexities. Instead, I introduce modular testing, where the focus is on testing only the external API of a module. This method aligns with good modular design principles and significantly reduces test maintenance effort. By testing just the API, the process becomes simpler, more agile, and scalable. I provide insights into the five essential elements of modular design and discuss how modular testing can enhance overall software quality while keeping testing efforts manageable.

• 00:00 Introduction to Automated Testing
• 01:03 Standard Testing - A Review
• 01:43 Unit Testing
• 03:06 Integration Testing
• 04:57 System Testing
• 06:59 Modular Testing
• 08:25 Modular Design Recap
• 12:11 Benefits of Modular Testing
• 16:30 Modular Testing IS Unit Testing, but better...
• 18:40 Modular Testing IS Integration Testing, but better...
• 22:46 System Testing? It's Modules All the Way Down...
• 24:23 Conclusion and Final Thoughts
• 25:48 Outro

Related C&O Episodes:

• E12 - Get Complexity-Fighting Super Powers with Modules https://youtu.be/cj81OhXpQCU
• E13 - The 5 Essential Elements of Modular Software Design https://youtu.be/V_mOC8I86ic

Hosted on Acast. See acast.com/privacy for more information.

Before we can get into the nuts and bolts about how to do automated testing well, we have to understand what it means to do testing well. And for that, we need a guiding principle.

Automated testing, like so many aspects of solving problems with software, is a path of mastery. You can forever get better and better at it, and the magnitude of potential benefits are unbounded. However, it will be difficult to impossible to continually make progress without some guiding light showing us what way to go. A well constructed guiding principle can do exactly that for us. It provides a semi-objective way to assess progress and help make choices along the way.

In this episode I synthesize the benefits we explored in the last episode with some observations about the essential nature of automated testing. From that I propose a guiding principle that should help us all agree on what is and is not good automated testing.

Timestamps

0:44 - definition

1:17 - as proof

2:23 - metacode

3:00 - recap of benefits

3:56 - The Guiding Principle

5:28 - summary

6:40 - next time

7:08 - outro

Related C&O Episodes:

• E036 - Surprising Benefits of Automated Testing - https://youtu.be/pBNzAB45_Hc

Hosted on Acast. See acast.com/privacy for more information.

I have a confession to make. I love automated testing. When done well, automated tests can help write better code, provide the best possible documentation, and most of all, automated testing can help write code faster:

Seriously.

And, when done well, writing and maintaining automated tests suites can actually be a lot of fun. After all, it’s a chance to get paid to play with your code…

Timestamps

• 0:19 - #1 Write better code
• 1:43 - #2 Best form of Doc
• 3:32 - #3 Accelerate your Code
• 4:41 - Imikimi story - an cautionary tail
• 6:00 - Recap
• 6:13 - Why I Love writing tests…
• 7:02 - Outro

Related C&O Episodes:

• E12 - Get Complexity-Fighting Super Powers with Modules https://youtu.be/cj81OhXpQCU
• E13 - The 5 Essential Elements of Modular Software Design https://youtu.be/V_mOC8I86ic

Hosted on Acast. See acast.com/privacy for more information.