Latest / DevQuestions with Tim Corey / 333. Why Boring Technology Wins

Transcript

333. Why Boring Technology Wins · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: Why are companies so far behind the times?
• 0:02
  SPEAKER_01: New developers often want to learn the cutting edge technologies, but when they get their first job, they're shocked to see just how far behind the times their new company is.
• 0:12
  SPEAKER_01: They might be using.NET framework or they might be using a long outdated system.
• 0:17
  SPEAKER_01: So why is this?
• 0:18
  SPEAKER_01: Why do companies gravitate towards boring and outdated technology?
• 0:23
  SPEAKER_01: Why does it seem like the best practices never apply in the corporate environment?
• 0:28
  SPEAKER_01: That's what we're going to discuss in today's episode of Dev Questions.
• 0:40
  SPEAKER_00: Welcome to the Dev Questions podcast with Tim Corey.
• 0:44
  SPEAKER_01: Software development is more than just writing code.
• 0:47
  SPEAKER_01: So let's talk about the rest of it.
• 0:49
  SPEAKER_01: Specifically, let's talk about why boring tech wins in business environments.
• 0:54
  SPEAKER_01: Now there's more than one answer to this question, but I want to focus on the boring tech part.
• 0:58
  SPEAKER_01: To do that, I first want to answer the other half, which is why companies don't upgrade the technology they use.
• 1:04
  SPEAKER_01: And I think there's probably three major reasons.
• 1:07
  SPEAKER_01: One, it's expensive.
• 1:09
  SPEAKER_01: You're spending a lot of money to basically stay in place.
• 1:14
  SPEAKER_01: So when you pitch an upgrade to your boss, you say, hey, we're on.NET 8, we should move it.NET 10, your boss says, well, that's an awful lot of money.
• 1:24
  SPEAKER_01: How long is it going to take?
• 1:25
  SPEAKER_01: Well, it's going to take two months worth of work and testing.
• 1:29
  SPEAKER_01: Well, okay, if you start doing the math on that, that's just thousands and thousands of dollars.
• 1:34
  SPEAKER_01: Is it worth it?
• 1:35
  SPEAKER_01: And unless you have a good reason, the boss often will say, Well, no, I don't want to spend the money if there's not a great reason to do so.
• 1:44
  SPEAKER_01: And just saying the version number gets bigger isn't enough of a reason.
• 1:48
  SPEAKER_01: So part of this is on developers to have a really good reason.
• 1:51
  SPEAKER_01: For example, I would say things like immediate performance improvements.
• 1:55
  SPEAKER_01: You'll get that with an upgraded.NET.
• 1:57
  SPEAKER_01: You also get the ability to be again shielded under the security blanket of updated security changes, which security is more and more of an issue, et cetera.
• 2:08
  SPEAKER_01: So, but number one is it's an expense because it is expensive.
• 2:12
  SPEAKER_01: And the end user doesn't see any new features.
• 2:15
  SPEAKER_01: They just see the same thing.
• 2:18
  SPEAKER_01: So why is it that their work didn't get done, their new features didn't get added, new bugs didn't get fixed for two months while you upgrade?
• 2:26
  SPEAKER_01: Is that worth it?
• 2:27
  SPEAKER_01: It doesn't feel that way.
• 2:29
  SPEAKER_01: So that's one reason.
• 2:31
  SPEAKER_01: Now, again, I don't agree with that, but again, it comes down to how you talk about it.
• 2:36
  SPEAKER_01: Number two is a lack of understanding.
• 2:39
  SPEAKER_01: This kind of goes with number one, which is they don't understand why you would upgrade.
• 2:43
  SPEAKER_01: It's working now.
• 2:45
  SPEAKER_01: Why would we change it?
• 2:47
  SPEAKER_01: So think about anything else you use in your life.
• 2:50
  SPEAKER_01: Let's talk your house.
• 2:52
  SPEAKER_01: I've been dealing with some house issues recently, but I have an air conditioning unit.
• 2:57
  SPEAKER_01: Why would I ever change that out if it's still working?
• 3:01
  SPEAKER_01: Right?
• 3:02
  SPEAKER_01: I would keep it going as it is.
• 3:04
  SPEAKER_01: There's no reason in my mind to say, well, yes, but it's it's been two years.
• 3:08
  SPEAKER_01: It's time to get a new unit.
• 3:11
  SPEAKER_01: Well, no, it's it's working now.
• 3:13
  SPEAKER_01: This is the same mindset that management brings into upgrades.
• 3:19
  SPEAKER_01: It's working now.
• 3:20
  SPEAKER_01: Why would we spend the money?
• 3:22
  SPEAKER_01: Again, expense, number one, but why would we do that when it's working?
• 3:26
  SPEAKER_01: There's no reason to change just because of change sick.
• 3:29
  SPEAKER_01: In fact, change is scary.
• 3:31
  SPEAKER_01: Change causes problems.
• 3:33
  SPEAKER_01: So it's a lack of understanding about what this change means and why it's actually more dangerous not to change.
• 3:40
  SPEAKER_01: But that's number two.
• 3:41
  SPEAKER_01: Number three is that users are often focused on features, not fixes.
• 3:47
  SPEAKER_01: So, yes, they want bugs fixed, but they're really focused in on that new feature they want.
• 3:53
  SPEAKER_01: Hey, I want the software to do this.
• 3:55
  SPEAKER_01: And if you talk to a user and say, dream of me, what do you want to see in the software?
• 4:00
  SPEAKER_01: They don't say things like, I would like to see new versions of.NET implemented.
• 4:06
  SPEAKER_01: I would like to see those uh node packages upgraded.
• 4:10
  SPEAKER_01: I would like to see the NuGet packages brought to the latest version.
• 4:14
  SPEAKER_01: They don't say those things because they have no clue what those things even are.
• 4:18
  SPEAKER_01: What they say is, I would love it if the software would do X or Y.
• 4:23
  SPEAKER_01: And that's what they see is progress.
• 4:25
  SPEAKER_01: So if you don't start implementing new features, then they see the application as stagnant.
• 4:31
  SPEAKER_01: They don't know what's going on behind the scenes.
• 4:33
  SPEAKER_01: They don't know how many lines of code you took out or how many things are more efficient now.
• 4:38
  SPEAKER_01: They may see performance improvements, and that's something you want to talk about a lot.
• 4:43
  SPEAKER_01: But beyond that, they don't really see much change.
• 4:47
  SPEAKER_01: So they're often focused on features, not on version numbers.
• 4:52
  SPEAKER_01: So that's that's the one side of things about why companies don't upgrade their technology, which leads to them having old technology.
• 5:01
  SPEAKER_01: But there's another side of this, and that is that companies don't tend to have the flashiest of products.
• 5:08
  SPEAKER_01: Um, they tend, yeah, especially in enterprise.
• 5:11
  SPEAKER_01: Um, the the software just gets the job done.
• 5:14
  SPEAKER_01: It's not entertaining, it's not flashy, it just does the work.
• 5:20
  SPEAKER_01: Um so and let's look beyond the the big players to the actual software that runs most companies.
• 5:25
  SPEAKER_01: So I'm not talking about like, you know, Microsoft or Teams, which is, you know, we all have opinions on Teams, but let's talk about like the actual software that runs companies.
• 5:35
  SPEAKER_01: Um it's boring.
• 5:36
  SPEAKER_01: Battleship gray screens with standard fonts are really common.
• 5:41
  SPEAKER_01: Um I used to be a consultant.
• 5:42
  SPEAKER_01: I spent years going from company to company to company, working on their software, building some of these things, and then improving a lot of them.
• 5:50
  SPEAKER_01: And it's pretty common that nothing looks good.
• 5:54
  SPEAKER_01: It just works.
• 5:55
  SPEAKER_01: Um they even have text-based data entry screens sometimes.
• 5:59
  SPEAKER_01: Uh, there's a store in Dallas called Nebraska Furniture Mart.
• 6:02
  SPEAKER_01: And it's a chain.
• 6:03
  SPEAKER_01: Obviously, it's not from Dallas.
• 6:05
  SPEAKER_01: Um, but Nebraska Furniture Mart is massive.
• 6:09
  SPEAKER_01: I mean, it's a massive store.
• 6:10
  SPEAKER_01: It's an event just to go there.
• 6:12
  SPEAKER_01: It's it's actually not really great prices and a great selection.
• 6:16
  SPEAKER_01: But their sales staff, they'll use tablets to help you check out right where you're at.
• 6:20
  SPEAKER_01: So you say, I want this couch, they'll say, cool, they'll look it up.
• 6:24
  SPEAKER_01: Here's the price, they'll put it on your order, and when you're ready, you give them a credit card and they can go ahead and take care of that right there, and then send your order onto the warehouse.
• 6:32
  SPEAKER_01: And they use a tablet for that, which is very modern.
• 6:35
  SPEAKER_01: But those tablets are running a web-based version of a text-based data entry screen.
• 6:42
  SPEAKER_01: So it's the same data entry screen that I used to work on and modify back in the 90s when I was working on machine applications.
• 6:52
  SPEAKER_01: Why?
• 6:53
  SPEAKER_01: Why don't they have a flashy web app with images and Amazon-like shopping carts and more?
• 6:59
  SPEAKER_01: Well, in my years of experience working with dozens of companies, it comes down to one of three things.
• 7:05
  SPEAKER_01: Number one, it works.
• 7:07
  SPEAKER_01: So don't change it.
• 7:08
  SPEAKER_01: Like if you have something that works, again, it comes back to that air conditioning example.
• 7:14
  SPEAKER_01: It works.
• 7:15
  SPEAKER_01: So if this is the way we've done things for 30 years and it has worked all that time, why would we change it?
• 7:22
  SPEAKER_01: Now, there are reasons, but that's one of the arguments is it works, so don't change it.
• 7:30
  SPEAKER_01: Number two, it's heavily integrated systems that are outdated that really can't change.
• 7:35
  SPEAKER_01: And this is a really common one where maybe that text-based system, all it is is just a web wrapper around the actual text entry screen.
• 7:44
  SPEAKER_01: And it's even doing some really clunky stuff behind the scenes to make it work.
• 7:47
  SPEAKER_01: I built those things.
• 7:49
  SPEAKER_01: Um, but the reason why is because the systems and and processes that it connects to, those actual machines or other things, they don't have new upgraded software.
• 8:00
  SPEAKER_01: I've worked a lot with manufacturing plants.
• 8:03
  SPEAKER_01: And when you buy or install a machine in a uh in a plant, you typically don't get a new version in five years.
• 8:13
  SPEAKER_01: You typically don't say, hey, that that big, very expensive uh thing, let's rip it out and put a new one in because it's a new model.
• 8:22
  SPEAKER_01: That doesn't happen.
• 8:23
  SPEAKER_01: So the software that runs those things, it is what it is.
• 8:28
  SPEAKER_01: And you often have updates for a very long time, but at some point those updates go away and the machine is still in use.
• 8:35
  SPEAKER_01: So what do you do then?
• 8:36
  SPEAKER_01: Well, you keep running a machine and just have to have software that integrates with that.
• 8:42
  SPEAKER_01: And that can be true for conveyor systems, or it can be true for any number of other things that might go into supporting an enterprise business.
• 8:52
  SPEAKER_01: So if they're heavily integrated into systems that are outdated, you're not gonna get a whole lot of change.
• 8:58
  SPEAKER_01: And then third, and this is one that I see way too often, is there were upgrades that were proposed, but those upgrades are proposed, or even they try to implement those things and they were very expensive and they were less efficient.
• 9:16
  SPEAKER_01: This is one that's very common.
• 9:18
  SPEAKER_01: Um people see an old system and they say, ah, I could do so much better than that.
• 9:22
  SPEAKER_01: They see the Nebraska furniture more, and they say, you know what, text-based data entry, it's not where it's at.
• 9:27
  SPEAKER_01: We've got a modern web, we've got a modern way of doing things.
• 9:31
  SPEAKER_01: We can build a site that is so much better, so much faster, um, and so much more efficient.
• 9:36
  SPEAKER_01: And then you actually start doing it and you're like, ooh, I didn't realize all these edge cases existed.
• 9:42
  SPEAKER_01: And you have workarounds and systems and other things that you have to try and figure out how to make work.
• 9:46
  SPEAKER_01: And before you know it, you have this clunky system that is really complicated and really fragile and it's really expensive, and it doesn't do it as efficiently as the boring system that just worked.
• 9:59
  SPEAKER_01: And that's where companies, after a while, they get jaded to this and say, you know what, we're not spending millions on consultants to come in and you know, give us a flashy new product that won't work.
• 10:12
  SPEAKER_01: And so they kind of stay where they're at.
• 10:15
  SPEAKER_01: So it works, so don't change it.
• 10:17
  SPEAKER_01: It's heavily integrated in systems that are outdated, and every proposed upgrade was actually less efficient.
• 10:24
  SPEAKER_01: So where does this leave us?
• 10:27
  SPEAKER_01: I think there are things to learn from all these things.
• 10:29
  SPEAKER_01: I think that the my challenge to you is to make boring software.
• 10:35
  SPEAKER_01: And that may feel boring.
• 10:39
  SPEAKER_01: It may feel like I don't want to do that.
• 10:41
  SPEAKER_01: But I think it's really important as software developers when you're thinking about how to make a mark on on what I do.
• 10:49
  SPEAKER_01: How do I make sure that I am invaluable as a developer?
• 10:53
  SPEAKER_01: How I make sure that if I build a product, that people actually use it.
• 10:58
  SPEAKER_01: And I think one of the big things you can do is make boring software.
• 11:03
  SPEAKER_01: And what do I mean by boring?
• 11:06
  SPEAKER_01: Make software that is incredibly efficient.
• 11:10
  SPEAKER_01: So when you're building software, too often people start with a user interface.
• 11:15
  SPEAKER_01: And they start with, you know, how to make this thing look pretty and how to make it, you know, look modern, and they're focused in on colors and fonts and styles and that kind of thing.
• 11:24
  SPEAKER_01: That's not where your application should shine.
• 11:28
  SPEAKER_01: Now, to be clear, I do think your application should look good.
• 11:33
  SPEAKER_01: I do think your application should be more than just battleship gray.
• 11:37
  SPEAKER_01: But I think it's more important that you focus on making it incredibly efficient.
• 11:45
  SPEAKER_01: Talk to the people who are actually going to use your application and figure out every possible place that you can take time out of the process.
• 11:56
  SPEAKER_01: So it could be as simple as don't touch your mouse.
• 12:00
  SPEAKER_01: So if you're building a desktop application or a web application or a mobile application, especially desktop and mobile because, or desktop and web, because mobile doesn't have a mouse necessarily.
• 12:11
  SPEAKER_01: But try to figure out how do I stop the user for having to move to another device, like a mouse, to move a cursor down and click next.
• 12:20
  SPEAKER_01: Maybe it's a it's you know, keystrokes and trying to figure out hotkeys and things like that.
• 12:24
  SPEAKER_01: Try to figure out how do I help this user move quickly through the system.
• 12:29
  SPEAKER_01: The point isn't to spend time in your application, the point is to help them get the job done.
• 12:35
  SPEAKER_01: If you can change that paradigm in your mind to go from the point is to use my application to the point is to use my application as little as possible to do the job, you're gonna write a whole lot better software.
• 12:49
  SPEAKER_01: Number two, focus on making your customers successful before you make it pretty.
• 12:57
  SPEAKER_01: The goal of your application is not to be the next Mona Lisa of designs.
• 13:04
  SPEAKER_01: Your goal is not to win awards for how pretty it looks.
• 13:09
  SPEAKER_01: Your goal is to make your customer successful.
• 13:15
  SPEAKER_01: Now, your customer might be internal, your customer might be your boss, whoever the case may be.
• 13:20
  SPEAKER_01: Your goal is to make them successful in what you build.
• 13:23
  SPEAKER_01: Spend almost all of your time there.
• 13:27
  SPEAKER_01: Yes, make it look good, but that's a secondary goal compared to your primary goal of making your customer successful.
• 13:37
  SPEAKER_01: Number three, make your apps rock solid.
• 13:42
  SPEAKER_01: Okay.
• 13:43
  SPEAKER_01: This is something that microservices really hurt this case here.
• 13:50
  SPEAKER_01: Um, the whole idea behind microservices was hey, we can make things more resilient.
• 13:55
  SPEAKER_01: And that can be a very good thing, especially if you're at the Amazon level.
• 13:59
  SPEAKER_01: But most people aren't at the Amazon level.
• 14:02
  SPEAKER_01: They're at the 100 people use this at a time level.
• 14:06
  SPEAKER_01: And the problem is the more dependencies, now I don't just mean like NuGet packages, but I mean things like if you have a front-end app that's that's a web UI and it depends on API, but that API depends on a database.
• 14:21
  SPEAKER_01: Okay, so there's three links in the chain there.
• 14:24
  SPEAKER_01: Your front-end, you have your API, and you have your database.
• 14:27
  SPEAKER_01: If one of those goes down, then your app is down.
• 14:31
  SPEAKER_01: It might say, well, okay, so I'm gonna put a message bus in the middle so that I have more resiliency, like the front end can still work if the middle is down or something like that.
• 14:41
  SPEAKER_01: Yes, but now you have even more dependencies and interconnectedness where if something were to happen to one of those servers, you've got a problem.
• 14:51
  SPEAKER_01: And so what happens is we built more and more complex applications that, yeah, it works in the web, it works on mobile, it works all over the place.
• 15:01
  SPEAKER_01: But is it rock solid?
• 15:03
  SPEAKER_01: Or is it a bit messy, it's a bit muddled?
• 15:06
  SPEAKER_01: Sometimes the best thing you can do is write a desktop application, a thing that installs locally, has local storage for data, and it just works.
• 15:17
  SPEAKER_01: It doesn't crash.
• 15:19
  SPEAKER_01: You think about it, every time your application crashes, every time it's slow, every time one of the dependencies is down and causes a slowdown in the system, you are hurting your user.
• 15:32
  SPEAKER_01: Your user is waiting on the application.
• 15:36
  SPEAKER_01: That makes your application less reliable.
• 15:40
  SPEAKER_01: And this is where you want to be a boring system that just works.
• 15:45
  SPEAKER_01: You want to be a thing that no one has to think about.
• 15:48
  SPEAKER_01: No one has to wonder, is it gonna be okay today?
• 15:51
  SPEAKER_01: You want to make sure that your app is rock solid.
• 15:54
  SPEAKER_01: Every possible case you want to work out so it's as efficient as possible and it's as performant as possible.
• 16:01
  SPEAKER_01: And part of that is making sure that you don't depend on too many things, more than you have to, especially, so that you can make sure that your application always works.
• 16:12
  SPEAKER_01: And finally, define your success on performance, not features.
• 16:17
  SPEAKER_01: Kind of goes back to the previous ones, but define your success on performance, not features.
• 16:24
  SPEAKER_01: You've if you've listened to me at all, you've you've probably heard me not rant, but kind of rant around Microsoft's tooling.
• 16:31
  SPEAKER_01: Um let's take an example that probably everyone knows about Microsoft Word.
• 16:36
  SPEAKER_01: So what's the point of Microsoft Word?
• 16:39
  SPEAKER_01: Well, it's to be an editor for documents.
• 16:43
  SPEAKER_01: Cool.
• 16:44
  SPEAKER_01: Okay.
• 16:45
  SPEAKER_01: How many features does Microsoft Word have?
• 16:49
  SPEAKER_01: Could you put that into the 10, 20, 30, 50, 100?
• 16:54
  SPEAKER_01: Could you even get close?
• 16:56
  SPEAKER_01: Or would you not even realize just how many features are inside of Word?
• 17:01
  SPEAKER_01: And then do you know how to use 50% of them, 30% of them?
• 17:07
  SPEAKER_01: What happens is as software matures and grows, there's one more feature, one more feature, one more feature that keeps getting requested until your app is this bloated mess that no one knows how to use.
• 17:20
  SPEAKER_01: It's slower because every little feature takes a little bit more uh effort out of it.
• 17:26
  SPEAKER_01: If you've used Visual Studio, you've seen this in action because we've had Visual Studio for decades now.
• 17:34
  SPEAKER_01: And we keep getting more and more cool features.
• 17:38
  SPEAKER_01: But because of that, it keeps getting slower and slower.
• 17:42
  SPEAKER_01: And the team has done a great job at trying to improve that, trying to bring back performance, et cetera.
• 17:48
  SPEAKER_01: But that's a constant struggle because of all the stuff that's in Visual Studio.
• 17:53
  SPEAKER_01: Now, VS Code came out, and all of a sudden, this is a snappy code editor that is just so fast, but it doesn't have all the features.
• 18:02
  SPEAKER_01: And so they start putting the features into VS Code, and all of a sudden it starts to slow down a bit, right?
• 18:08
  SPEAKER_01: This is what happens.
• 18:09
  SPEAKER_01: It's the cycle of software.
• 18:12
  SPEAKER_01: Be very careful about that.
• 18:14
  SPEAKER_01: Be careful you define your success on performance, not features.
• 18:18
  SPEAKER_01: Because it does not matter if you have 100 great features, if none of those features are very performant.
• 18:26
  SPEAKER_01: Because people just aren't going to want to use it or can't use it.
• 18:30
  SPEAKER_01: It's just too slow, or it crashes, or it's not reliable.
• 18:34
  SPEAKER_01: But instead, if you do the one thing that you're designed to do really, really, really well, then you're just that reliable thing they always rely on.
• 18:44
  SPEAKER_01: They always come back to because it's all about the fact that you get out of the way.
• 18:49
  SPEAKER_01: Your application is not the star they are.
• 18:52
  SPEAKER_01: You are saying, I want to get you in and out and on your way as soon as possible.
• 18:58
  SPEAKER_01: Define your success on performance, not features.
• 19:02
  SPEAKER_01: Again, that does not mean you can't have more features.
• 19:06
  SPEAKER_01: It just means that your success is defined by the performance of your application, not on how many features you have.
• 19:14
  SPEAKER_01: Okay, so boring applications are really valuable tools.
• 19:20
  SPEAKER_01: And unfortunately, today, we're getting farther and farther away from those boring tools.
• 19:25
  SPEAKER_01: We're getting to the point where we're focusing more on things like, hey, does it deploy everywhere?
• 19:31
  SPEAKER_01: Does it have all the features?
• 19:33
  SPEAKER_01: Is it quick to build?
• 19:36
  SPEAKER_01: And yet that's not the right set of metrics.
• 19:40
  SPEAKER_01: This is why when you open up Microsoft Word now, it's a web-based app, which quite frankly isn't as good as a desktop app.
• 19:48
  SPEAKER_01: It's not as performant, it's got quirks to it.
• 19:52
  SPEAKER_01: Outlook drives me nuts because of the fact it's a web app and it doesn't have some of the features that Outlook used to have that I relied on.
• 20:02
  SPEAKER_01: Because, well, it's web-based now, so you can deploy it to more places.
• 20:05
  SPEAKER_01: Yes, so you have a lesser product deployed to more places.
• 20:10
  SPEAKER_01: I want you to focus on making better products, even if they are more tightly targeted.
• 20:17
  SPEAKER_01: Okay.
• 20:17
  SPEAKER_01: This is what's going to create great software.
• 20:20
  SPEAKER_01: This is the thing that people keep coming back to.
• 20:23
  SPEAKER_01: Instead of saying, I'm going to hold my nose and use this tool, they say, this is the tool you have to use.
• 20:29
  SPEAKER_01: All right.
• 20:30
  SPEAKER_01: That's what I want you to build for your software, even if it does feel a little boring.
• 20:35
  SPEAKER_01: All right.
• 20:36
  SPEAKER_01: Thanks for listening.
• 20:37
  SPEAKER_01: And as always, I am Tim Corey.
• 20:39
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 20:42
  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.