Latest / DevQuestions with Tim Corey / 274. Why Code Quality Is Not The Most Important Metric

Transcript

274. Why Code Quality Is Not The Most Important Metric · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: Code quality would seem like the best thing to focus on.
• 0:03
  SPEAKER_01: Following best practices, applying design patterns appropriately, and generally writing well-structured code seems like a good thing.
• 0:12
  SPEAKER_01: But code quality is actually not the most important metric a company should be focusing on when building an application.
• 0:20
  SPEAKER_01: So let's talk about why code quality shouldn't be the primary focus for businesses building software in today's episode of DevQuestions.
• 0:37
  SPEAKER_00: Welcome to the DevQuesti podcast with Tim Corey.
• 0:41
  SPEAKER_01: Software development is more than just writing code.
• 0:44
  SPEAKER_01: So let's talk about the rest of it.
• 0:46
  SPEAKER_01: Specifically, let's talk about the primary focus of business applications and why it isn't code quality.
• 0:53
  SPEAKER_01: Code quality is important.
• 0:55
  SPEAKER_01: And in this episode, we're going to talk about how to make sure that it's still valued.
• 1:00
  SPEAKER_01: But let's first talk about the primary focus of business applications.
• 1:05
  SPEAKER_01: To do that, I'm going to ask you a question.
• 1:07
  SPEAKER_01: The question is this: why does an application exist?
• 1:12
  SPEAKER_01: Let's make this clear.
• 1:13
  SPEAKER_01: Let's say you work at Acme Corp and you're building a warehouse management application.
• 1:18
  SPEAKER_01: Why does that application exist?
• 1:22
  SPEAKER_01: Applications exist to perform a task.
• 1:26
  SPEAKER_01: Just like cars exist to transport us where we need to go.
• 1:30
  SPEAKER_01: So what is the primary purpose of applications?
• 1:35
  SPEAKER_01: To get the job done.
• 1:36
  SPEAKER_01: And that's where the tension comes in.
• 1:39
  SPEAKER_01: So this is the tension between what we want to do and what we need to do.
• 1:46
  SPEAKER_01: So getting a job done can mean pushing to production before you're ready.
• 1:52
  SPEAKER_01: One of the things that people often want to do is just a few more days, a few more weeks.
• 1:59
  SPEAKER_01: If you follow game development, you know, this is one of those things where game development is kind of out in the open, meaning they announce well ahead of time we're going to build this game.
• 2:11
  SPEAKER_01: And you might think of a game like uh Grand Theft Auto 6, which has been in production for I think 10 years.
• 2:18
  SPEAKER_01: Um, and it's always just around the corner.
• 2:21
  SPEAKER_01: Well, actually, that corner is a little farther away.
• 2:24
  SPEAKER_01: This happens all the time.
• 2:26
  SPEAKER_01: And part of this is you know, mismanagement.
• 2:30
  SPEAKER_01: Part of it is management wanting to change directions halfway through.
• 2:34
  SPEAKER_01: I get that, but a big part of it as well is people want to make things that are great.
• 2:41
  SPEAKER_01: They want to add a little more polish, a little more finishing touches.
• 2:47
  SPEAKER_01: I want to make the code a little better.
• 2:49
  SPEAKER_01: And so what happens is you push off a deadline and push off a deadline and push off a deadline because you want to make it perfect.
• 2:57
  SPEAKER_01: But here is the deal.
• 3:00
  SPEAKER_01: When you do that, you deny the ability to use that application for that many more days, weeks, months, it can turn into years.
• 3:10
  SPEAKER_01: So what happens?
• 3:11
  SPEAKER_01: What's the primary purpose of the application?
• 3:13
  SPEAKER_01: To get the job done.
• 3:14
  SPEAKER_01: The job's not getting done because you didn't push to production.
• 3:19
  SPEAKER_01: So pushing to production is sometimes needed, you need to do it even before you feel ready.
• 3:27
  SPEAKER_01: In fact, the first version of your application really should go to production well before you feel ready.
• 3:33
  SPEAKER_01: Now, getting the job done can also mean adding a feature instead of improving code quality.
• 3:40
  SPEAKER_01: This is hard because when you work at a company and you look at the code base and you know the code base is messy, and you know that if you just put some work in, you can make it better and you can make it a long-term better solution.
• 3:55
  SPEAKER_01: This happens a lot with even upgrading the application, where you're on.NET 5 and you know, like, man, we're out of support.
• 4:02
  SPEAKER_01: We need to upgrade a.NET 9.
• 4:04
  SPEAKER_01: I know it's it's mostly just a couple of changes, but I need to get it done.
• 4:08
  SPEAKER_01: But that's not the priority of the company.
• 4:11
  SPEAKER_01: And sometimes it feels like they just don't understand.
• 4:14
  SPEAKER_01: And to an extent, no, they don't, and you need to help them with that.
• 4:19
  SPEAKER_01: But part of it is you don't understand because the whole goal of your application is not to have a perfect application.
• 4:29
  SPEAKER_01: The goal of the application isn't to have the most efficient application.
• 4:34
  SPEAKER_01: The goal of the application is to get the job done, and they need that thing done.
• 4:39
  SPEAKER_01: So they need that new feature over what you think is more important, code quality or performance improvements or tweaking how you do something.
• 4:50
  SPEAKER_01: So getting the job done can mean adding a new feature instead of improving code quality.
• 4:55
  SPEAKER_01: Now, getting the job done can also mean implementing a workaround instead of getting the taking the time to design an elegant solution.
• 5:06
  SPEAKER_01: I don't know how many times I have created a quick workaround that ended up in production.
• 5:12
  SPEAKER_01: Because you know what?
• 5:13
  SPEAKER_01: At the end of the day, maybe taking five minutes and putting some messy code in there that works is better than spending half a day or a day tweaking it and making sure that it's it's architected right and having a discussion over how it should be architected and what can be changed, et cetera.
• 5:31
  SPEAKER_01: Sometimes you just need to get something into production.
• 5:34
  SPEAKER_01: And that workaround, yes, it's going to add technical debt.
• 5:38
  SPEAKER_01: And that debt is going to have to be paid at some point.
• 5:42
  SPEAKER_01: But sometimes it's worth it to take on a little tech debt in order to get something out into production.
• 5:50
  SPEAKER_01: Getting a job, getting the job done can mean bypassing code reviews and other safety checks.
• 5:56
  SPEAKER_01: This is not one you should do very often.
• 5:59
  SPEAKER_01: But sometimes you need to rush things into production.
• 6:02
  SPEAKER_01: Sometimes you need to rush past a normally uh calm process of reviewing the code and verifying everything works and maybe even having a multi-stage deployment where you deploy it to first the development servers and test it there, and then deploy it to a staging server, then a QA server, then a pre-production server, and then you know the canary build, and then you have the slow rollout.
• 6:29
  SPEAKER_01: Sometimes you don't have time for that.
• 6:31
  SPEAKER_01: Sometimes you need to bypass a lot of those steps and say, we're gonna get close enough.
• 6:38
  SPEAKER_01: Because sometimes you need to get something into production in order to meet meet a new sale that's coming on.
• 6:46
  SPEAKER_01: Um you need to get something into production because there's a bug that just needs to get fixed.
• 6:51
  SPEAKER_01: You sometimes need to get things into production because the boss is gonna be checking on something, or the CEO is gonna be checking on something, and you need to have something new in place.
• 7:01
  SPEAKER_01: And you know, that feels sometimes arbitrary, it feels sometimes frustrating, but sometimes that's what need to happen needs to happen in order to get things done.
• 7:12
  SPEAKER_01: And that sometimes means shrinking your code review and other safety checks, not totally eliminating them, but shrinking them or compressing them.
• 7:22
  SPEAKER_01: Getting the job done can mean rushing changes in order to meet the deadline.
• 7:27
  SPEAKER_01: I have this kind of comes back to that deadline thing, that the idea of pushing the production before you're ready.
• 7:34
  SPEAKER_01: Sometimes it feels like your boss gives you an arbitrary deadline.
• 7:38
  SPEAKER_01: They say, you know what, we're gonna have this done by October 1st.
• 7:41
  SPEAKER_01: And you're like, it's already the middle of September, and I have a month and a half worth of work to do.
• 7:48
  SPEAKER_01: The boss says, I need you to have it done October 1st.
• 7:52
  SPEAKER_01: And so sometimes you rush changes, and that might mean doing workarounds.
• 7:56
  SPEAKER_01: It might mean bypassing some of the full review process you have.
• 8:00
  SPEAKER_01: It might mean, you know, figure out how to just throw code in there and get it to work rather than making it perfect.
• 8:07
  SPEAKER_01: So that can happen.
• 8:09
  SPEAKER_01: But you know what?
• 8:10
  SPEAKER_01: You're meeting a deadline, it's not always just about you.
• 8:14
  SPEAKER_01: And this is kind of the whole idea behind this is being a software developer, we we create things, we build things, we we architect things, we think that we know best.
• 8:25
  SPEAKER_01: And in our world, sometimes we do.
• 8:28
  SPEAKER_01: But we have to remember that we are just a piece.
• 8:32
  SPEAKER_01: And in fact, we're the supporting piece of most every organization.
• 8:38
  SPEAKER_01: We are not the front line.
• 8:40
  SPEAKER_01: We are not the reason the organization exists in most cases.
• 8:44
  SPEAKER_01: So we need to figure out how to support them better.
• 8:46
  SPEAKER_01: And sometimes that means rushing to meet a deadline.
• 8:51
  SPEAKER_01: Getting a job done can mean copying and pasting code from other locations, violating dry like crazy.
• 9:00
  SPEAKER_01: And again, why does dry exist?
• 9:02
  SPEAKER_01: Because it reduces errors, it reduces potential errors.
• 9:07
  SPEAKER_01: But sometimes you just need to get it done.
• 9:10
  SPEAKER_01: And you just need to say, you know what?
• 9:12
  SPEAKER_01: I know we have this in the project over here.
• 9:14
  SPEAKER_01: Let's not worry about creating a NuGet package and extracting out and getting all that set up.
• 9:18
  SPEAKER_01: Let's just copy, paste, done.
• 9:22
  SPEAKER_01: It works.
• 9:23
  SPEAKER_01: And it working is more important than it being perfect.
• 9:29
  SPEAKER_01: Okay, getting the job done can mean not writing unit tests.
• 9:34
  SPEAKER_01: It can also mean not documenting the changes.
• 9:37
  SPEAKER_01: I just um encountered this today where I'm busy, I've got a lot of stuff to do.
• 9:42
  SPEAKER_01: In fact, I'm getting ready to head on out for a conference and then vacation.
• 9:47
  SPEAKER_01: And so I'm trying to get a lot of stuff done in a little bit of time.
• 9:51
  SPEAKER_01: And in the middle of it, our internal admin dashboard went down.
• 9:57
  SPEAKER_01: I had to get it back up because we have things coming, we have new courses coming out, we have stuff to do.
• 10:02
  SPEAKER_01: So, what did I do?
• 10:04
  SPEAKER_01: Well, I got the job done and I found out it was an expired uh secret.
• 10:10
  SPEAKER_01: And so I renewed the secret.
• 10:12
  SPEAKER_01: But you know what I didn't do?
• 10:13
  SPEAKER_01: I didn't document the process.
• 10:15
  SPEAKER_01: I could have.
• 10:16
  SPEAKER_01: I could have spent the time, but you know what?
• 10:18
  SPEAKER_01: I didn't have the time.
• 10:19
  SPEAKER_01: I decided it's okay.
• 10:21
  SPEAKER_01: When that comes back up next year, I'll just figure it out then.
• 10:26
  SPEAKER_01: And that's okay.
• 10:27
  SPEAKER_01: It's pushing off work for next year.
• 10:29
  SPEAKER_01: And yes, it will make more work for me next year than I otherwise would have, but I just didn't have time to document and figure out where I'll put that documentation and make sure that it was in my notes and would come up in my calendar and all the rest of stuff.
• 10:40
  SPEAKER_01: I didn't have time for that because I had more important priorities.
• 10:44
  SPEAKER_01: This is all about understanding priorities.
• 10:48
  SPEAKER_01: And sometimes, most of the time, priorities aren't going to align well with perfect code, which is why every application in the world is ugly and messy.
• 11:00
  SPEAKER_01: It just is what it is, because not everything aligns with being perfect.
• 11:06
  SPEAKER_01: So all of these things can be true and can be justified.
• 11:11
  SPEAKER_01: The longer you work in software development, the more you will have participated in them firsthand.
• 11:16
  SPEAKER_01: These are all situations you want to avoid, and I'm not advocating that you do any of them without cause.
• 11:25
  SPEAKER_01: But there's an argument for all of them being the right choice depending on the circumstances.
• 11:33
  SPEAKER_01: So, does that mean we give up on code quality?
• 11:36
  SPEAKER_01: Absolutely not.
• 11:38
  SPEAKER_01: We just have to remember that it isn't the top priority.
• 11:44
  SPEAKER_01: That means that we have to be better about meeting the top priority while also including code quality.
• 11:52
  SPEAKER_01: The more code you write, the better you will be at writing more maintainable code the first time and quickly.
• 11:59
  SPEAKER_01: That in turn will allow you to meet the priorities of getting the job done while still producing high quality results.
• 12:07
  SPEAKER_01: So this is something that comes out.
• 12:11
  SPEAKER_01: Uh if you are familiar with the guy named Mike Rowe, he is a really big advocate for the trade.
• 12:18
  SPEAKER_01: So electricians, plumbers, etc.
• 12:21
  SPEAKER_01: And one of the things that he pushes back on is the idea of companies and organizations saying, safety first.
• 12:29
  SPEAKER_01: And he says, no, it's not.
• 12:32
  SPEAKER_01: And you say, well, wait a minute.
• 12:33
  SPEAKER_01: No, no, we have to put safety first because our employees matter.
• 12:37
  SPEAKER_01: And his argument is safety isn't first, because otherwise you wouldn't do anything.
• 12:43
  SPEAKER_01: An electrician deals with scary amounts of power.
• 12:48
  SPEAKER_01: And the most safe thing to do would be to not deal with scary amounts of power.
• 12:53
  SPEAKER_01: But they can't.
• 12:54
  SPEAKER_01: That's part of their job.
• 12:56
  SPEAKER_01: So while safety is important, it's not first because getting a job done is first.
• 13:03
  SPEAKER_01: That doesn't mean you don't be safe.
• 13:06
  SPEAKER_01: Very much you want to be safe, but it's not the first thing.
• 13:10
  SPEAKER_01: And the same thing is true with code quality.
• 13:14
  SPEAKER_01: It's very important, but it's not first.
• 13:19
  SPEAKER_01: So the bottom line is this: don't elevate code quality above shipping.
• 13:24
  SPEAKER_01: Instead, try to ship the best possible code by improving your skills as a developer.
• 13:31
  SPEAKER_01: Some of the most successful games, movies, books, and applications have been a result of intense pressure to ship quickly.
• 13:40
  SPEAKER_01: I want you to look at books like the uh the book about Doom and the building of that game and how there was such intense pressure around you have to ship now.
• 13:52
  SPEAKER_01: And by the way, you're shipping other games at the same time.
• 13:55
  SPEAKER_01: And they created some really important lasting art because of the fact that they had that intense pressure.
• 14:05
  SPEAKER_01: And then you look at other situations where maybe a movie director was given full license and a huge budget and said, just go build something.
• 14:14
  SPEAKER_01: And they turn out junk, even though they had been very successful in the past.
• 14:19
  SPEAKER_01: And what was the difference?
• 14:21
  SPEAKER_01: In the past, they had tight budget constraints.
• 14:24
  SPEAKER_01: The original Star Wars, if you ever watched the making of Star Wars episode for A New Hope, it's fascinating stuff.
• 14:32
  SPEAKER_01: But one of the things that that led to the success it had was the fact that they had extreme limitations.
• 14:40
  SPEAKER_01: They wanted to do this amazing things, and they did, but they didn't have great computers.
• 14:46
  SPEAKER_01: They didn't have these great CGI systems, they had to build these things, they had to build practical models with a very low budget.
• 14:55
  SPEAKER_01: And even after they succeeded in the first one, they had to finance the second one by hand because of the fact that people weren't sure they wanted to have a sequel.
• 15:06
  SPEAKER_01: And yet Empire was one of the most successful ones out that came about.
• 15:10
  SPEAKER_01: So that intense pressure created some great movies.
• 15:16
  SPEAKER_01: Now you could argue that following that, the blank check of the new movies kind of caused them to struggle because the fact that there were this kind of almost a blank check on do whatever you want, make the best movie possible.
• 15:33
  SPEAKER_01: And what it comes down to, you find out, is the best movie possible is often made under the most intense pressure.
• 15:42
  SPEAKER_01: So some of the greatest failures in all these categories, uh gaming and applications and movies and books, some of the greatest failures in those same categories were made by people who prioritized perfection over getting the job done.
• 16:02
  SPEAKER_01: Get the job done.
• 16:05
  SPEAKER_01: Thanks for listening.
• 16:06
  SPEAKER_01: And as always, I am Tim Corey.
• 16:08
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 16:11
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to IamTimCorey.com and enroll in a course.