A management role in software development can be difficult to navigate. You need to keep a high-level perspective on projects while making sure they go smoothly. Eric Elliott, today's guest on the show, believes that you need to implement coding quality practices such as test-driven development. In this episode, we talk about why software development processes such test-driven development makes an impact and why it's important to remove bugs. We'll also talk about how to train developers and keep them happy—and why it's inherently important not to rush the process.

Eric Elliott has been in software development for the better part of his life. He co-founded EricElliottJS.com and DevAnywhere.io, which aim to teach developers essential software development skills. He is also the author of the books, "Composing Software" and "Programming JavaScript Applications" He builds and advises development teams for crypto projects, and has contributed to software experiences for Adobe Systems, Zumba Fitness, The Wall Street Journal, ESPN, BBC, and top recording artists including Usher, Frank Ocean, Metallica, and many more.

Outline of This Episode

[2:08] Eric's background in software development
[4:28] What's happened in the last year?
[6:17] Tangible benefits to reducing bugs on the front-end
[9:34] How much time should be spent on fixing bugs?
[11:43] What happens when you rush engineers?
[13:35] What happens when a manager steps in
[19:50] How to communicate with your leadership
[25:11] What tangible things should you measure?
[29:55] Top 3 things to do to improve quality of code
[34:30]Measure pull requests and open bug tickets
[40:49] Test-driven development (TDD)
[43:50] Resources Eric recommends

What are the tangible benefits to reducing bugs?

If you are able to reduce bugs on the front end, you spend less time fighting fires. According to Eric, "Fixing bugs is not work that's delivering direct value to your customers—it's rework". Customers don't look at your software and think being "bug-free" is a benefit. They just assume that it's a given that there will be no bugs.

Secondly, Eric points out that you will lose customers if you produce buggy software. Struggling client retention and turnover means you'll have to increase your marketing budget in order to attract new business.

It is the most expensive and time consuming part of producing software. But it is imperative to deliver a stellar product on the front end. Because, per Eric, "Every hour spent in code review saves 33 hours of maintenance". The hardest part is understanding that this process takes time and cannot be rushed, but it is well worth it in the end.

What happens when you try to rush your engineers?

Those in leadership positions often have to deal with pressure from higher-ups to rush a project or push a timeline. This is the worst thing that could happen, and you'll start to see significant negative results of rushing your developers.

Eric points out that bugs will pile up, testing will get skipped, and communication will suffer. Your team will feel like they don't have adequate time to mentor each other, and knowledge sharing is left behind. Productivity levels will plummet.

Even worse, your developers can reach the point of burnout—with effects that can be long-lasting. The Japanese struggle with a culture of over-working to the point that they have a coined term for people who die because of overworking—"Karoshi". While this is an extreme example, it's something you want to steer clear of. Pushing your team to rush will bring to fruition the opposite of what you intend.

What is your role as a manager/leader?

Eric uses a manufacturing analogy to drive this point home:

" There's a floor manager who is usually perched up high above a factory floor so they can see everything happening on the factory floor. They can see where things are piling up. So on an assembly line work comes in one end of a line and goes out the other end of the line, but then all these different processes thrown in the middle that take different amounts of time to complete. Optimizing that process is the job of the floor manager".

The moment a manager steps in and gets themselves involved in the work they lose perspective of the overall process. No one is doing quality control. The assembly line will start to have pile-ups with no one able to step in and smooth the process.

It's a manager's role to ensure the process is slow and smooth, but efficient. The key is proper communication—If you show your superiors that progress is being made on a regular basis, it eases their anxiety. If every part of your code includes code review and test-driven development (TDD) it is just another part of delivering software responsibly.

Improve the quality of your code with good software development practices

Eric recommends using a non-predictive burndown chart (a graphical representation of work left to do versus time). A predictive chart can set unrealistic expectations for a project, which is a developer's #1 complaint.

He also believes you need to track developer happiness and improve it when needed. Know what makes them happy or satisfied with their work. Developers deal with time pressure, unrealistic expectations, and problems they don't know how to tackle on a daily basis. They need to be empowered and given permission to spend time on mentoring, learning, and quality control.

Happy developers perform their jobs up to 20% faster.

Secondly, you must implement test-driven development. In Eric's experience, TDD is crucial to delivering a great product. Universally, the teams that test first work better. Eric researched studies on the topic and found that testing reduces bug density by 40-80%. You will always see the test fail before it passes, which allows you to debug and find improvements. It leads to continuous delivery, which keeps everyone happy.

What you should and shouldn't measure

Everyone has heard the phrase "What gets measured gets managed", but it isn't always in your best interest to measure everything. Eric shares his take on what NOT to measure as well as what you should track.

Eric points out that you shouldn't measure individual developers' number of closed tickets. Why? The developers closing the least amount of tickets are the ones with all the answers that everyone else comes to. They're spreading their knowledge which will multiply the productivity of the organization.

You DO need to measure bug commit density instead of bugs per line of code. If you have a file with 51 commits and 14 are bug fixes, that's a 20% bug commit density. You also need to look at recency of the rework. Doing these things allow you to see what is causing bugs now and allows you to fix what needs fixing.

DO measure how many open pull requests there are. Your team needs to be able to have the time to do code review. It needs to be prioritized. It allows your teams to learn from each other and get everyone on the same page.

DO measure the number of open bug tickets. Bugs reproduce, and critical bugs will interrupt developers. When they're interrupted, it takes twice as long to complete the tasks they were working on—and they end up with more bugs. This comes full circle, back to the software development practice of test-driven development. This mitigates the number of bugs that will creep up and changes the cycle.

Eric delivers a lot of solid advice for developers and managers in this episode. Listen to the whole episode for all the important details.

Resources & People Mentioned

Eric's Blog: The Hardest Part of Being a Software Manager
BOOK: Test Driven Development: By Example
BOOK: The Phoenix Project
BOOK: Turn the Ship Around!
Eric's last episode on Simple Leadership
Karoshi: Death from overwork
Culture Amp
15five

Connect with Eric Elliott

Eric on LinkedIn
Eric on Twitter
JS Cheerleader on Twitter
BOOK: Programming JavaScript Applications
BOOK: Composing Software
Eric's 1-day training