Latest / DevQuestions with Tim Corey / 307. Code is a Liability, Not an Asset

Transcript

307. Code is a Liability, Not an Asset · DevQuestions with Tim Corey

• 0:00
  SPEAKER_00: Code is a liability, not an asset.
• 0:03
  SPEAKER_00: Many times developers focus on code as if it's the main purpose of their company or even just their job.
• 0:09
  SPEAKER_00: We talk about the types of code we write, the language we write in, and more.
• 0:14
  SPEAKER_00: And all that's fine as long as we remember that our code is a liability that we manage rather than an asset we create.
• 0:22
  SPEAKER_00: In fact, the first question a developer should ask is if we can avoid writing code to solve a problem.
• 0:29
  SPEAKER_00: Let's talk about why in today's episode of DevQuestions.
• 0:41
  SPEAKER_01: Welcome to the DevQuesti podcast with Tim Corey.
• 0:45
  SPEAKER_00: Software development is more than just writing code.
• 0:48
  SPEAKER_00: So let's talk about the rest of it.
• 0:50
  SPEAKER_00: Specifically, let's talk about why code is a liability.
• 0:54
  SPEAKER_00: And let's start by clearing up an objection you probably already have.
• 0:58
  SPEAKER_00: The application you build for your company can be an asset to the company.
• 1:03
  SPEAKER_00: It is the thing that provides value.
• 1:06
  SPEAKER_00: But the code that you write is not an asset, it's a liability.
• 1:10
  SPEAKER_00: A liability is something that you have to pay for over time.
• 1:13
  SPEAKER_00: Think of it like a mortgage on your home.
• 1:15
  SPEAKER_00: The house is the asset, but the loan is the liability.
• 1:20
  SPEAKER_00: You need the loan to buy the house, but it's a constant expense.
• 1:24
  SPEAKER_00: That's how we need to think about code.
• 1:27
  SPEAKER_00: So let's talk about the cost of code and where it really comes into play as a liability.
• 1:34
  SPEAKER_00: So let's start with the kind of the obvious.
• 1:37
  SPEAKER_00: You have to pay a salary for a person to create code.
• 1:40
  SPEAKER_00: You have to pay the salary of the person to fix the bugs in the code.
• 1:45
  SPEAKER_00: You have to pay a salary of a person to upgrade your code to the next version or to add new features and so on.
• 1:51
  SPEAKER_00: So you can think about it as the more code you write, the more expensive it is, because the more you're paying for that developer to do the work.
• 2:00
  SPEAKER_00: Now, this is where people that are using AI, which seems like everybody, oh, it's not really, but it seems like everybody.
• 2:08
  SPEAKER_00: And so people will say, well, then the cost is going way, way down, which means that the liability portion of code is so low anymore that we don't have to really think about it.
• 2:18
  SPEAKER_00: But that's incorrect.
• 2:20
  SPEAKER_00: Because I said let's talk about the things that everybody thinks about when it comes to the costs of X of code creation, but there's more to it than that.
• 2:29
  SPEAKER_00: Okay, so let's talk the more to it.
• 2:31
  SPEAKER_00: What are the other costs associated with code?
• 2:34
  SPEAKER_00: Because if code, writing code is so cheap because of AI, then why wouldn't we just create more and more products and more and more features for our products?
• 2:44
  SPEAKER_00: Well, there's also the cost of the increased attack surface.
• 2:49
  SPEAKER_00: If you have, let's be really simple here.
• 2:53
  SPEAKER_00: If you have an API that has one endpoint, then your attack surface is through that one endpoint.
• 3:00
  SPEAKER_00: Now, yes, you can attack a server and all the rest, but let's just look at the API itself, the actual code.
• 3:05
  SPEAKER_00: So you have that one place to attack, right?
• 3:08
  SPEAKER_00: That one endpoint that you can attack on.
• 3:10
  SPEAKER_00: Now, what if you have 10 endpoints?
• 3:14
  SPEAKER_00: Well, your attack surface has grown.
• 3:17
  SPEAKER_00: Because now there's 10 different places that an attacker could potentially attack.
• 3:22
  SPEAKER_00: What if you have a hundred?
• 3:24
  SPEAKER_00: Well, now you have a hundred different places that could be attacked.
• 3:28
  SPEAKER_00: And it isn't just the fact that there's more places to attack, but also the fact that if you have one endpoint, what are you really doing?
• 3:36
  SPEAKER_00: You're you're focusing all your work and energy on that one endpoint.
• 3:40
  SPEAKER_00: You're thinking about it, you're working on it, you're constantly evaluating it.
• 3:44
  SPEAKER_00: But what if you have a hundred?
• 3:45
  SPEAKER_00: Well, there's probably maybe 10, 20 or so that are your primary places you spend the most time.
• 3:53
  SPEAKER_00: But there's going to be a few that kind of sit out there that people forget about a bit, right?
• 3:57
  SPEAKER_00: That 99th and 100th most popular one, it's essentially the least popular endpoints, don't really get as much attention because they're not used as often.
• 4:07
  SPEAKER_00: Think about your favorite application.
• 4:10
  SPEAKER_00: Maybe uh think about Microsoft Word.
• 4:13
  SPEAKER_00: Um probably not your favorite application, but let's pretend you at least know what Word is, right?
• 4:19
  SPEAKER_00: And if you look at the ribbon at the top, the the first ribbon are the things that you are most likely going to be using.
• 4:27
  SPEAKER_00: Um, the bolding and underlying and changing fonts and things like that.
• 4:33
  SPEAKER_00: Those are the things that are most commonly used, therefore they're also the most common to be pay attention to and to uh check for any bugs.
• 4:42
  SPEAKER_00: But there's also like more tabs than that, and maybe you don't ever go to those uh tabs, but probably the last tab or two you might not ever go to.
• 4:52
  SPEAKER_00: Those features you probably don't use very often.
• 4:55
  SPEAKER_00: And that's intentional because Microsoft puts the most used things at near the front, right?
• 5:01
  SPEAKER_00: Which is great.
• 5:02
  SPEAKER_00: But if you're not using those things, then they're not as getting as many updates to them because they're not as popular.
• 5:11
  SPEAKER_00: Therefore, the code isn't changing as much in those areas, but there's still an attack service.
• 5:17
  SPEAKER_00: There's still an area where an attacker might be able to exploit something.
• 5:20
  SPEAKER_00: We've seen this in a number of cases recently.
• 5:23
  SPEAKER_00: The um uh the release uh, well not quite release, but the announcement of mythos, the new LLM, and how it's you know, this amazing thing at finding bugs that's debatable.
• 5:35
  SPEAKER_00: But it did find a whole bunch of bugs, which were in areas that weren't used as much, right?
• 5:43
  SPEAKER_00: Yes, the tools themselves were used heavily, but the the way they were exploited was using things that were off the beaten path and and ways of doing things that weren't as common.
• 5:56
  SPEAKER_00: So when you increase your attack surface, you increase the likelihood you'll have those dark corners that don't change as often and potentially open you up to uh to being attacked through those vectors.
• 6:10
  SPEAKER_00: Now, also, and I've kind of mentioned this a bit, but when you have more code, you also have an increased chance of bugs.
• 6:20
  SPEAKER_00: So let's just say that your bug rate is one bug every 100 lines of code.
• 6:26
  SPEAKER_00: Now, it's not linear like that, but let's pretend it is for an end.
• 6:30
  SPEAKER_00: It would make sense then that the less lines of code you write, the less bugs you have.
• 6:36
  SPEAKER_00: Because if you write a thousand lines of code, you're on average going to have 10 bugs.
• 6:41
  SPEAKER_00: Again, we're just making numbers here.
• 6:44
  SPEAKER_00: And if you write 10,000 lines of code, you would have a hundred lines or a hundred bugs in those codes.
• 6:52
  SPEAKER_00: So that would make sense if it was a linear thing.
• 6:54
  SPEAKER_00: And you might say, well, but it's not linear.
• 6:56
  SPEAKER_00: You're right, but on average, we create bugs at a certain rate.
• 7:01
  SPEAKER_00: So therefore, the more things you do, the more bugs you will have.
• 7:06
  SPEAKER_00: And bugs can cause your application to crash, they can cause your application to lose data or corrupt data or cause other problems.
• 7:15
  SPEAKER_00: So the more code you have, the more chance of bugs you're going to have.
• 7:20
  SPEAKER_00: Now, also, the more code you have, the more complexity you will have in your application.
• 7:27
  SPEAKER_00: If you have an application that has one endpoint and it has 50 lines of code, really easy for you to read over that, see what it does, understand how it works.
• 7:39
  SPEAKER_00: Even if there's a bit of like putting complex things into one line, which I don't recommend, but even if there's that, it's not gonna be that hard, right, to understand what this application does.
• 7:50
  SPEAKER_00: But if you have an application that is 3,000 lines of code, well, that's gonna be a bit harder to understand.
• 7:59
  SPEAKER_00: You have to do a bit more work.
• 8:01
  SPEAKER_00: If it's 50,000 lines of code, even harder.
• 8:05
  SPEAKER_00: And 500,000 obviously is even harder.
• 8:08
  SPEAKER_00: The more code you have, the more complexity you introduce into your application.
• 8:14
  SPEAKER_00: The more interactions you have between systems, the more you have to test all the various permutations.
• 8:22
  SPEAKER_00: This was especially true um uh you know 10, 15 years ago, but it's still true today.
• 8:29
  SPEAKER_00: Um when you look at Windows versus Mac.
• 8:32
  SPEAKER_00: And we've for a long, long time we've said that Windows is unstable.
• 8:37
  SPEAKER_00: And you know, we the blue screen of death, which is you know now a different color, I think.
• 8:42
  SPEAKER_00: Um, but I haven't seen one in a while, which is actually pretty impressive.
• 8:45
  SPEAKER_00: But but you know, we we have all these errors and bugs in Windows, and we kind of complain about the stability of Windows, and the comparison is often Mac, which is much more stable and it has much less problems, seemingly.
• 9:00
  SPEAKER_00: And you might say, well, you know, that's because Mac writes better software.
• 9:05
  SPEAKER_00: Debatable.
• 9:06
  SPEAKER_00: But what I do know is the complexity difference in the environment.
• 9:12
  SPEAKER_00: Mac controls the hardware.
• 9:15
  SPEAKER_00: They control which processors they allow, they control which motherboards they allow, which graphics cards they allow, and so on.
• 9:24
  SPEAKER_00: They control the hardware.
• 9:25
  SPEAKER_00: Whereas Windows does not control the hardware.
• 9:29
  SPEAKER_00: So you could have any of a number of different graphics cards and motherboards and RAM and CPUs and all the rest to the point where they have an infinite number of things to support.
• 9:41
  SPEAKER_00: It's practically infinite the number of combinations you could have for a desktop or laptop computer that Windows has to run on versus the handful of ones that Mac has to support.
• 9:53
  SPEAKER_00: Now it's gotten worse because Mac has allowed more and kind of expand on that, but the point holds that the more complexity there is, the more likely it is that you will have problems.
• 10:05
  SPEAKER_00: If Mac had to support the same number of different permutations of hardware that Windows did, they would have a similar problem with reliability because it's very, very, very difficult to support all of that complexity, all those possible interactions.
• 10:22
  SPEAKER_00: So in your code, it's the same way.
• 10:25
  SPEAKER_00: If you are only supporting a certain number of features, a limited number of features, well, there's not a lot of interactivity, there's not a lot of complexity going on there.
• 10:34
  SPEAKER_00: But if you're supporting a number of different ways to get the data in, and then a number of different ways to process the data, and a number of different ways to store the data, and you have all this interaction, different moving parts, it becomes much, much more complex, which makes it much, much more difficult.
• 10:49
  SPEAKER_00: We talked um a week or two ago about uh monoliths versus microservices and the idea that um, you know, microservices probably not the right call for most organizations or most applications.
• 11:02
  SPEAKER_00: And part of the reason for that is because of the fact that out of the box, they're very, very complex because of all the moving parts to just have even five microservices work with each other.
• 11:16
  SPEAKER_00: It's not the same as having one application with five different methods or five different even modules in them in the application.
• 11:24
  SPEAKER_00: So complexity is another reason why you're gonna cause more problems, and code is a liability in that when you add or you add more code.
• 11:35
  SPEAKER_00: So when you add more code, you also decrease speed.
• 11:40
  SPEAKER_00: It's just a given.
• 11:41
  SPEAKER_00: Now, you can argue that, well, but if you write the code right, that it actually gets faster.
• 11:46
  SPEAKER_00: Yes, I'm not saying you can't write faster code, it might take more lines of code.
• 11:50
  SPEAKER_00: I'm not saying that that 10 lines of code is always gonna need slower than one line of code.
• 11:55
  SPEAKER_00: I'm not saying that.
• 11:56
  SPEAKER_00: But when you have a lot more code, your code by definition has to do more things.
• 12:05
  SPEAKER_00: And that will decrease the overall speed of your application.
• 12:10
  SPEAKER_00: When your application is doing more things, it's going to be slower.
• 12:15
  SPEAKER_00: When your application used to just give information, then it was very fast.
• 12:19
  SPEAKER_00: But when it has to go into AI to talk to the AI to get the full information, it's slower.
• 12:26
  SPEAKER_00: I uh I have solar in my house and I have solar and batteries, and I use the um the Tesla power walls for my batteries.
• 12:35
  SPEAKER_00: And so I have a Tesla app.
• 12:37
  SPEAKER_00: And in that app, it says, hey, here's what you know, here's how much solar power your solar panels are producing.
• 12:44
  SPEAKER_00: Here's how much we're storing the batteries, here's how much how much we're giving to the grid, and here's how much grid usage we're also using.
• 12:51
  SPEAKER_00: So right at the bat, in the very front of my app, it shows me all this information, right?
• 12:57
  SPEAKER_00: I can see my panels are generating this much, this many kilowatts, this many kilowatts are going to my batteries or coming from my batteries to my house.
• 13:05
  SPEAKER_00: This is how much my house is using, and this is how much I'm either giving to the grid or getting from the grid, right?
• 13:10
  SPEAKER_00: It's a picture, only it's a it's kind of an animated picture that actually shows changing numbers.
• 13:15
  SPEAKER_00: But now they've added a new feature where I can get an AI summary.
• 13:20
  SPEAKER_00: And that summary basically just summarizes the picture, which I already have and it's immediate because it's right there, the information is right there and it's on my system.
• 13:30
  SPEAKER_00: But the summary has to use an AI to process and think about all the inputs and then summarize that into a couple paragraphs.
• 13:38
  SPEAKER_00: That's slower than just looking at the picture, right?
• 13:42
  SPEAKER_00: When you add more features and functionality, it slows things down.
• 13:46
  SPEAKER_00: When you put more things in the loop, it slows things down.
• 13:50
  SPEAKER_00: The code is a liability.
• 13:52
  SPEAKER_00: The more you use, the more you build, the more of a liability it is.
• 13:58
  SPEAKER_00: So every line of code you write, every app you build, it's an additional liability for you and your employer.
• 14:04
  SPEAKER_00: There's more to maintain, there's more to fix, and there's more to think about.
• 14:08
  SPEAKER_00: Now, again, those applications themselves, the result, can be also an asset to your company, but the code itself is a liability.
• 14:18
  SPEAKER_00: So let's explain this a different way.
• 14:21
  SPEAKER_00: Growing up, my grandfather always had a garden.
• 14:25
  SPEAKER_00: Um, I didn't um I grew up right down the road with my grandparents, and I spent a lot of time down there.
• 14:32
  SPEAKER_00: And my grandfather was a retired farmer and he just couldn't get it out of his blood.
• 14:37
  SPEAKER_00: Like that was just, it was in his blood.
• 14:40
  SPEAKER_00: And so we lived in the country and he had a garden.
• 14:44
  SPEAKER_00: But when you say a garden, he actually had two or three gardens, and they weren't just like, oh, a little 10 by 8 plot.
• 14:52
  SPEAKER_00: No, it was about as big as he could get, right?
• 14:54
  SPEAKER_00: Um, they were very large gardens.
• 14:57
  SPEAKER_00: And you know, I think that when you're thinking about writing code, you kind of have to think about like planting a garden, right?
• 15:06
  SPEAKER_00: So if if you're gonna start a garden, maybe start really small, maybe start with even a plant in a pot, like start really small.
• 15:16
  SPEAKER_00: And there's not a lot of work there.
• 15:18
  SPEAKER_00: It's just plant the seed and water a little bit and wait.
• 15:21
  SPEAKER_00: And then, you know, you might have to pick a couple weeds out, but really it's just wait for the thing to grow, maybe fertilize it, but you're pretty much done.
• 15:29
  SPEAKER_00: But if you, you know, it's not a lot of effort, but the output isn't a lot, right?
• 15:34
  SPEAKER_00: So the the end result is you get a couple tomatoes or you get, well, a lot of zucchini, but that's a whole different thing.
• 15:41
  SPEAKER_00: Um, you know, a couple potatoes or something like that.
• 15:44
  SPEAKER_00: Well, you might say, well, I but I want more.
• 15:46
  SPEAKER_00: I want more.
• 15:47
  SPEAKER_00: So you you plant a plot of land and you have more results, but it also takes more time weeding, it takes more time watering, it takes more effort to maintain that plot.
• 16:00
  SPEAKER_00: Or I can be like my grandfather and have three massive gardens.
• 16:04
  SPEAKER_00: And so you spend an awful lot of your time focused on making sure that you kill the weeds, because the weeds are always coming and clean the rocks out, and make sure you're fertilizing that thing, and make sure that you're keeping the animals out.
• 16:16
  SPEAKER_00: You're spending more time putting up more fencing out to try and keep the deer and the bunnies and all the rest out of your garden.
• 16:23
  SPEAKER_00: And you spend your whole time consumed with building out and maintaining these gardens.
• 16:30
  SPEAKER_00: And so the majority of your time is spent just in maintenance mode, keeping things going.
• 16:36
  SPEAKER_00: Now, at the end of the end of the harvest season, you got a whole lot of results for it.
• 16:41
  SPEAKER_00: You have a lot more tomatoes, you have a lot more zucchini, you have a lot more potatoes and carrots and all the rest.
• 16:46
  SPEAKER_00: But the bigger it gets, the more effort you spend to the point where that's all you do all day, right?
• 16:53
  SPEAKER_00: So that's what we're looking at when it comes to writing code.
• 16:57
  SPEAKER_00: Yes, we want bigger results and more results.
• 16:59
  SPEAKER_00: And, you know, it it gets really tempting when we build this tiny application that gives us results, but that's that's just a tiny results, right?
• 17:07
  SPEAKER_00: We want more results as we build a bigger application and it gives us more, and we can support more customers and do more things.
• 17:13
  SPEAKER_00: And then we say, you know what?
• 17:14
  SPEAKER_00: We could write five applications, or we could do even more things.
• 17:18
  SPEAKER_00: But what happens is that when that when we do that, we spend all of our time supporting it and all of our time chasing down those weeds, those bugs, chasing down the problems, keeping the malicious actors out of our application, and so on.
• 17:35
  SPEAKER_00: In a world where AI can seemingly write so much code, what should our takeaway be from this?
• 17:42
  SPEAKER_00: Because it feels like that we were manually tilling the garden and we were manually putting the fences up, and now we can just have a machine do it, right?
• 17:52
  SPEAKER_00: So why wouldn't we have bigger gardens?
• 17:54
  SPEAKER_00: Why wouldn't we have bigger applications and more applications?
• 17:59
  SPEAKER_00: But let's go through the what should we really have as a takeaway from this because code is a liability.
• 18:06
  SPEAKER_00: Well, number one, just because you can doesn't mean you should.
• 18:11
  SPEAKER_00: So just because you can build something, it doesn't mean that you should.
• 18:16
  SPEAKER_00: Just because my grandfather potentially could have tilled up even more land doesn't mean he should have.
• 18:22
  SPEAKER_00: You know, just because I could create another website or another tool or another thing to give people doesn't mean I should, because I have to support it.
• 18:32
  SPEAKER_00: I have to maintain it, I have to fix the bugs, I have to protect it.
• 18:37
  SPEAKER_00: And so what happens is you start to get tied to all of your resources going towards maintaining what you have and you can't build anything new because you chose to build these things, right?
• 18:50
  SPEAKER_00: So that's actually, you know, number two, which is that what you're doing is you're making a choice now, not only about what you're going to do, but also what you're not going to do.
• 19:03
  SPEAKER_00: If if you're going to support this app well, it's going to take X resources.
• 19:09
  SPEAKER_00: And if you only have X times three resources, and you say, well, I'm going to build these other two things too, well, now you're you've maxed out.
• 19:17
  SPEAKER_00: That's all you can do.
• 19:18
  SPEAKER_00: Which means when a good idea comes along, you can't do that because you have all your resources devoted to these other things.
• 19:25
  SPEAKER_00: So you're saying, I'm not going to do those other things, those other opportunities, because I want to do these things.
• 19:31
  SPEAKER_00: And if you're not careful, that what you're doing, you choose the good things instead of the great things.
• 19:39
  SPEAKER_00: So just because you can doesn't mean you should.
• 19:42
  SPEAKER_00: Make sure you think about that.
• 19:44
  SPEAKER_00: Um, make sure that you're thinking through, do I want to?
• 19:48
  SPEAKER_00: And then making sure you choose the great, not just the good.
• 19:52
  SPEAKER_00: Number three, writing the code, that's the easy part.
• 19:56
  SPEAKER_00: Okay.
• 19:57
  SPEAKER_00: The easy part is actually putting code into the system.
• 20:01
  SPEAKER_00: It's even easier now with AI, although I argue it actually makes it harder too.
• 20:06
  SPEAKER_00: Um, so writing the code is has always been the easy part.
• 20:10
  SPEAKER_00: The hard part is defining what you want, making sure that it's the right thing, making sure that it is the thing that's going to be long-term viable, making sure you think through do I want to support this long-term, and so on.
• 20:25
  SPEAKER_00: Writing code has always been the easy part.
• 20:28
  SPEAKER_00: Number four, the best amount of debt is no debt.
• 20:33
  SPEAKER_00: So when it comes to buying a house, the absolute best thing you could do would be to buy a house outright, right?
• 20:40
  SPEAKER_00: Pay for it and not have any loan.
• 20:42
  SPEAKER_00: That's great.
• 20:44
  SPEAKER_00: It's not how we do software development, right?
• 20:46
  SPEAKER_00: We, you know, the idea that we could build an app and then just never support it is just not the case.
• 20:52
  SPEAKER_00: So we can't not incur debt.
• 20:55
  SPEAKER_00: We're going to incur debt when we release an application.
• 20:58
  SPEAKER_00: That's why it's a little bit different than the home loan idea.
• 21:02
  SPEAKER_00: But the best amount of debt is no debt, which means that one, if we can get away with it, then don't build an app, use an app, right?
• 21:12
  SPEAKER_00: Because if you can pay for an app, let's say it's$100 a year per developer, you have 10 developers.
• 21:18
  SPEAKER_00: So you're a$1,000 a year for this app.
• 21:24
  SPEAKER_00: Okay, how much would it cost to build that application?
• 21:28
  SPEAKER_00: Well, more than$1,000 a year.
• 21:31
  SPEAKER_00: So the best amount of debt is no debt.
• 21:34
  SPEAKER_00: Like you just say, hey, we'll just use your service.
• 21:37
  SPEAKER_00: So there's a lot of things you could do, not everything you should do.
• 21:42
  SPEAKER_00: Now, if you're going to have to go into debt, if you're going to have to support an application, think about how you can support it in the least amount of effort.
• 21:51
  SPEAKER_00: Meaning, maybe we use off the shelf tools for as much as possible, but we do this one thing.
• 21:56
  SPEAKER_00: As opposed to, hey, now you build this one thing, there's so many.
• 22:00
  SPEAKER_00: More cool features we could add to this thing.
• 22:02
  SPEAKER_00: Yeah, but should we?
• 22:04
  SPEAKER_00: Probably not.
• 22:04
  SPEAKER_00: Let's not go into further debt just because we could.
• 22:09
  SPEAKER_00: All right.
• 22:10
  SPEAKER_00: Number five, don't look at just the positives.
• 22:14
  SPEAKER_00: All right.
• 22:15
  SPEAKER_00: So when you're thinking about the features, when you're thinking about, oh man, you know, we could we could do this.
• 22:20
  SPEAKER_00: We could we could uh have this thing and it would have these cool features, it would save us an hour a week.
• 22:25
  SPEAKER_00: That'd be awesome.
• 22:26
  SPEAKER_00: Or our customers will love this.
• 22:30
  SPEAKER_00: Count the cost.
• 22:33
  SPEAKER_00: Sure, it's going to add those features.
• 22:36
  SPEAKER_00: But at what cost?
• 22:40
  SPEAKER_00: Because it's not just about adding new features.
• 22:44
  SPEAKER_00: We've seen this pretty much everywhere.
• 22:47
  SPEAKER_00: Uh Microsoft gets gets a lot of flack for this, rightly so.
• 22:52
  SPEAKER_00: Um they've tried to put copilot everywhere.
• 22:57
  SPEAKER_00: Everywhere.
• 22:58
  SPEAKER_00: And they said, hey, look at the positives.
• 23:00
  SPEAKER_00: You can access your AI anywhere, and you can have it do these things.
• 23:04
  SPEAKER_00: Cool.
• 23:05
  SPEAKER_00: What are the costs?
• 23:06
  SPEAKER_00: Well, it makes your application slower.
• 23:08
  SPEAKER_00: It increases the attack surface.
• 23:10
  SPEAKER_00: It's causing more problems, and it's causing things that never had a problem that all of a sudden have a problem.
• 23:15
  SPEAKER_00: And it's actually not adding any value in a lot of cases, and people don't like it.
• 23:22
  SPEAKER_00: So those are the costs they encounter because they just kind of looked at the features, the positives, the the, you know, this will do these things.
• 23:31
  SPEAKER_00: And the thing is, those are there are positives there.
• 23:34
  SPEAKER_00: Now, it's not positive to everybody, and it might not be what you would want, but what they did was they just looked at the positives and didn't look at all the negatives.
• 23:45
  SPEAKER_00: When you have this tool that you really like, and then it adds weird features.
• 23:50
  SPEAKER_00: And you're like, why are you doing this?
• 23:52
  SPEAKER_00: It's because they're saying, hey, we could add more features.
• 23:55
  SPEAKER_00: And they don't count the costs of what's it gonna take to support these features?
• 24:00
  SPEAKER_00: Are we gonna have them long term?
• 24:02
  SPEAKER_00: Do our customers actually want these features?
• 24:04
  SPEAKER_00: Does it actually help or hurt the product that I'm using?
• 24:08
  SPEAKER_00: There are a number of apps that I use where they used to be really fast because they did one thing well.
• 24:13
  SPEAKER_00: And now all of a sudden they do multiple things and they're not doing them as well, they're a little slower.
• 24:20
  SPEAKER_00: That's frustrating because they looked at the positives and they didn't count the cost or find the value in the in the uh or look at the value and say, hey, it's not worth the cost.
• 24:32
  SPEAKER_00: So at the end of the day, we need code.
• 24:35
  SPEAKER_00: And as a developer, I can't say don't write code, right?
• 24:39
  SPEAKER_00: I can kind of uh but we need code.
• 24:42
  SPEAKER_00: We need custom solutions.
• 24:44
  SPEAKER_00: Not everything can be off a shelf because even off the shelf is somebody writing code for you.
• 24:49
  SPEAKER_00: But how much we need should be up for constant debate.
• 24:55
  SPEAKER_00: As a developer, we should be pushing to eliminate as much code as possible while still getting the desired outcomes.
• 25:02
  SPEAKER_00: That's really what the mark of a good senior developer is, is that they eliminate code.
• 25:08
  SPEAKER_00: Even if they add new features, they're cutting down the amount of code that's in the system, not increasing it, which is also something where we look at AI and how it's doing things, it's actually creating lots more code.
• 25:21
  SPEAKER_00: And we're saying, well, but that's that's fine.
• 25:23
  SPEAKER_00: No, no, no.
• 25:23
  SPEAKER_00: We should be working on eliminating as much as possible because it's adding a lot more liability.
• 25:29
  SPEAKER_00: We should also be highlighting the long-term costs and making sure those costs are paid.
• 25:35
  SPEAKER_00: One of the things that's very, very common for organizations to say is, well, we have this app that's been working for 20 years.
• 25:41
  SPEAKER_00: We can update it and adding features and all the rest, but it's still stuck in.NET framework, um, and we can't upgrade it.
• 25:48
  SPEAKER_00: Why not?
• 25:50
  SPEAKER_00: Because what happened was you built that and then you never wanted to pay the maintenance costs.
• 25:57
  SPEAKER_00: Part of the maintenance cost is that you spend time not producing new features, but moving to later versions.
• 26:05
  SPEAKER_00: And you're not spending that and you're saying, oh, well, we're stuck now.
• 26:09
  SPEAKER_00: Like, you know, it's it just is what it is.
• 26:12
  SPEAKER_00: No, it's not.
• 26:13
  SPEAKER_00: It's you didn't pay the cost.
• 26:14
  SPEAKER_00: You didn't want to pay the actual cost for the software.
• 26:17
  SPEAKER_00: And what happens is that companies get burned by that, where they'll build maybe not their main product, because their main product tends to be something they can continue to maintain, even though it's um an older version of.NET or whatever else, right?
• 26:33
  SPEAKER_00: But usually it's the secondary tools and products uh where what happens is they build them in that and then they never maintain it, and they don't upgrade it, they don't work on cleaning out the technical debt and so on.
• 26:46
  SPEAKER_00: And so become this buggy mess that gets slower and slower and harder to maintain until a competitor blows them out of the water by just making an application that works.
• 26:57
  SPEAKER_00: So this is where you can lose your application or even lose your business if you're not careful, if you're not making sure those costs are paid.
• 27:07
  SPEAKER_00: At the end of the day, our employer is going to do what they want to do.
• 27:11
  SPEAKER_00: So hear me when I say that yes, you need to work hard to make sure you're paying your application's debt long term and not just ignoring it.
• 27:21
  SPEAKER_00: But at the end of the day, your employer is gonna probably tell you, I don't want you to.
• 27:26
  SPEAKER_00: I don't want you to work on maintenance, I want you to work on new features.
• 27:30
  SPEAKER_00: And that's our job is to do what they say as long as we're also pushing back.
• 27:35
  SPEAKER_00: So it's our job to be an informed voice of reason in that process.
• 27:40
  SPEAKER_00: Too often people forget that.
• 27:42
  SPEAKER_00: They say, well, but my employer is telling me to do this and it's it's dumb, but I have to do it.
• 27:48
  SPEAKER_00: Yes, but you also have to be an informed voice of reason, meaning you have to be knowledgeable of what you're talking about.
• 27:56
  SPEAKER_00: You have to push back when appropriate.
• 28:00
  SPEAKER_00: You have to put things in writing so that when things go wrong in a diplomatic way, you can say, that's what I was saying six months ago.
• 28:12
  SPEAKER_00: That's what I was saying a year ago.
• 28:15
  SPEAKER_00: And now that we're here, let's work on fixing the problem.
• 28:18
  SPEAKER_00: Let's let's work on getting back on track.
• 28:21
  SPEAKER_00: And here's how I recommend doing that.
• 28:23
  SPEAKER_00: So, what you're doing is if you do it right, you're building up your credibility so that eventually, not right away, but eventually, you can have a better and a bigger voice in the conversation because they know that what you say is going to come to pass.
• 28:42
  SPEAKER_00: And you are not just saying, hey, these new features are great, or I don't want to do a new feature, I always want to fix things.
• 28:49
  SPEAKER_00: Those things don't communicate well to upper management that doesn't understand software development.
• 28:54
  SPEAKER_00: But if you can clearly explain long-term costs and making sure those costs are paid, making sure that you know that code's a liability, not just something you should just do, that's important.
• 29:06
  SPEAKER_00: Okay.
• 29:06
  SPEAKER_00: So, because that will help you long term in your job.
• 29:10
  SPEAKER_00: And being that informed voice of reason is really important.
• 29:14
  SPEAKER_00: All right.
• 29:14
  SPEAKER_00: So thanks for listening.
• 29:16
  SPEAKER_00: As always, I am Tim Corey.
• 29:18
  SPEAKER_01: Thank you for joining us for this episode of Dev Questions.
• 29:21
  SPEAKER_01: When you're ready to learn to think and code like a professional developer, head over to IamtimCorey.com and enroll in a course.