Latest / DevQuestions with Tim Corey / 072 How Do I Upgrade An Enterprise Application? Should I Even Consider It?

Transcript

072 How Do I Upgrade An Enterprise Application? Should I Even Consider It? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:03
  SPEAKER_00: Join us each episode as we tackle the questions you are asking about a career in software development, understanding the industry, and new technology.
• 0:12
  SPEAKER_00: If you're just starting out or you want to grow stronger as a developer, this is the place to get your questions answered.
• 0:19
  SPEAKER_00: Now, here's your host, expert developer and online educator, Tim Corey.
• 0:24
  SPEAKER_01: How do I upgrade an enterprise project?
• 0:27
  SPEAKER_01: This is a question that came up recently based upon my obsolescence in C Sharp talk where I said, hey, some companies are still using the.NET framework for actively developed applications.
• 0:42
  SPEAKER_01: And some businesses are even using stuff that's older than that, maybe even VB6 or VB4 or 3.
• 0:49
  SPEAKER_01: So, how do you upgrade these enterprise projects?
• 0:53
  SPEAKER_01: Well, that's the question for today's dev question.
• 0:56
  SPEAKER_01: And what we're gonna do is we're gonna talk through the reasons why products don't get upgraded, what the feelings are from different groups, and then how can we go about actually upgrading these projects?
• 1:09
  SPEAKER_01: So let's talk first about the different camps, the different ways people think about upgrading.
• 1:17
  SPEAKER_01: Now, the first camp is some developers, and they're usually the newer developers, developers either new in the team or they're new to the company, or maybe just new overall.
• 1:27
  SPEAKER_01: But these developers usually want to upgrade everything right away.
• 1:32
  SPEAKER_01: They see the old technology and go, man, I've been working with.NET 6 already, and you're asking me to go back to.NET Framework 3.5?
• 1:40
  SPEAKER_01: That's just not what I want to do.
• 1:42
  SPEAKER_01: Let's upgrade everything.
• 1:44
  SPEAKER_01: So that's one camp, and that isn't extreme, and there's people that aren't that extreme, but that's one camp.
• 1:50
  SPEAKER_01: The other camp is the developers that just want to leave it alone.
• 1:55
  SPEAKER_01: This is usually developers who've been there for a while.
• 1:58
  SPEAKER_01: And the motto, of course, is if it ain't broke, don't fix it.
• 2:02
  SPEAKER_01: So this camp is like, you know, don't touch that, don't leave it alone because it's working.
• 2:09
  SPEAKER_01: And you don't know all the pain and the effort and the hard work that went into making it what it is today.
• 2:17
  SPEAKER_01: It'll be a massive undertaking, maybe even possible to upgrade.
• 2:21
  SPEAKER_01: So leave it alone.
• 2:22
  SPEAKER_01: So that's the second group.
• 2:24
  SPEAKER_01: And the third group is usually management that wants new features.
• 2:29
  SPEAKER_01: That's usually the management uh perspective is hey, it's working, but I want more, I want better, I want it faster, I want it to have more bells and whistles, I want it to do what I want it to do.
• 2:40
  SPEAKER_01: So there's those three groups, and yes, there are people in the middle all around, but those are the three major kind of poles to look at, the three different um extremes in organization.
• 2:54
  SPEAKER_01: So why don't organizations upgrade?
• 2:58
  SPEAKER_01: So, why isn't that when the new developers come in and have that enthusiasm, why don't companies go, yes, let's do this?
• 3:06
  SPEAKER_01: Well, the first reason they don't upgrade is because of a lack of perceived value.
• 3:14
  SPEAKER_01: What's the point?
• 3:15
  SPEAKER_01: What's the point in upgrading your application?
• 3:19
  SPEAKER_01: Imagine for a minute that you had a house, okay?
• 3:24
  SPEAKER_01: You own this house and you're you're living in this house, and you have some contractors come over, you're gonna pay them thousands and thousands and thousands of dollars.
• 3:34
  SPEAKER_01: And at the end of that time, your wiring will be so much better wiring.
• 3:41
  SPEAKER_01: Your your electrical outlets will be so much better outlets.
• 3:46
  SPEAKER_01: Is it really worth that?
• 3:48
  SPEAKER_01: Like, are you actually gonna spend a year having your whole house wiring upgraded?
• 3:54
  SPEAKER_01: Probably not, especially if you don't perceive any problems with the current outlets.
• 4:01
  SPEAKER_01: So, why would you spend all that money to upgrade something you can't really see?
• 4:06
  SPEAKER_01: It's getting very, very expensive.
• 4:08
  SPEAKER_01: You're gonna have to rip out walls and patch walls and do all this disruptive stuff for what at the end of the day seems like nothing.
• 4:18
  SPEAKER_01: There's no extra value you seem to get out of it.
• 4:21
  SPEAKER_01: So that's the first thing is a lack of perceived value.
• 4:24
  SPEAKER_01: I'm not saying there isn't value.
• 4:26
  SPEAKER_01: There definitely is value.
• 4:28
  SPEAKER_01: But if you don't communicate that to the people who are making the decisions, that lack of perceived value alone can kill an upgrade project.
• 4:37
  SPEAKER_01: Now the next one is cost.
• 4:39
  SPEAKER_01: This is where people often really uh downplay how much it can cost an organization to upgrade their application.
• 4:48
  SPEAKER_01: Remember that applications don't get built overnight.
• 4:51
  SPEAKER_01: It's not like one day you walk in, you have an enterprise application.
• 4:55
  SPEAKER_01: That took years or possibly even decades to build, which is why it's on such old technology to begin with.
• 5:02
  SPEAKER_01: Because it was built years ago and it may have been upgraded a few times, but then at some point it became too big and it was too cumbersome, and it just kind of stopped where it was, and you continue to add to it.
• 5:15
  SPEAKER_01: So the cost of an upgrade, let's just say for a minute, it's gonna take 10 developers a year to upgrade the application.
• 5:24
  SPEAKER_01: Well, in the US, we could pick a salary, let's just say$100,000 a piece, which actually is a very low salary for the US.
• 5:32
  SPEAKER_01: And you might think, well, I'm not getting$100,000.
• 5:35
  SPEAKER_01: You might be, because it's about$60,000,$65,000 a year of actual salary, maybe less, that equates to$100,000 of cost to the organization.
• 5:48
  SPEAKER_01: Because you have things like your benefits, your health insurance is a big one in the US, but uh the uh retirement contributions, days off, uh management for you, HR for you, all the other things that go into your computer, um, your workstation at your office, maybe.
• 6:07
  SPEAKER_01: Um, all those kind of things add up to your overall cost of an organization.
• 6:12
  SPEAKER_01: Now let's just say that it takes 10 of you a year to upgrade the application.
• 6:18
  SPEAKER_01: That's a million dollars.
• 6:19
  SPEAKER_01: You might say, well, our company makes you know$10 million in profit, not a big deal.
• 6:24
  SPEAKER_01: That's not the end of the cost of the upgrade.
• 6:28
  SPEAKER_01: So in that time, you will have not done probably any improvements on the system.
• 6:37
  SPEAKER_01: So you get$10 or million dollars of cost, but then you also have a year of lost upgrades, a year where there wasn't new features.
• 6:48
  SPEAKER_01: Remember, I said that management typically is the one that wants the new features, wants the new capabilities.
• 6:55
  SPEAKER_01: Well, if they're not gonna get that for a year, that's more than just the cost of your salaries for that year.
• 7:02
  SPEAKER_01: It's also the cost of missed opportunities, missed ability to do things better, more efficiently.
• 7:09
  SPEAKER_01: Imagine if you could do an update to the system that would make, let's just say, your call center 5% more efficient.
• 7:18
  SPEAKER_01: Well, what's that 5% over that course of a year for the whole call center compared to the cost of an upgrade?
• 7:26
  SPEAKER_01: It might be that the efficiency you didn't gain would have needed you even more money.
• 7:32
  SPEAKER_01: So you're talking about maybe two, three, four times what the cost of just your salary alone is.
• 7:39
  SPEAKER_01: So that lack of improvement can be a real big deal.
• 7:43
  SPEAKER_01: But then the the next thing, and this is the thing that as you grow as a software developer, as you've seen these projects happen, this is the one that is often overlooked at first.
• 7:56
  SPEAKER_01: But as you have more experience, you'll see this, and that is risk.
• 8:01
  SPEAKER_01: Massive changes rarely work.
• 8:05
  SPEAKER_01: It's rare that you say, we're gonna upgrade our entire software over the next year, and at the end of the year, you've upgraded your entire software and it all works.
• 8:15
  SPEAKER_01: That's a very, very rare case.
• 8:18
  SPEAKER_01: Most of the time, what happens is a couple things.
• 8:22
  SPEAKER_01: First of all, things don't go as planned.
• 8:24
  SPEAKER_01: You didn't realize you're like, oh, we depended on this service, which doesn't have an equivalent in the new system.
• 8:31
  SPEAKER_01: And so what are we gonna do about that?
• 8:33
  SPEAKER_01: And you have to go back to the drawing board and rework some things and maybe rewrite whole sections of your code, and you know it it becomes messy.
• 8:42
  SPEAKER_01: Maybe you base your.NET framework code on WCF.
• 8:46
  SPEAKER_01: Well, there's not an equivalent of WCF in dot net six.
• 8:50
  SPEAKER_01: There's uh GRPC, but that's not a direct one-to-one.
• 8:54
  SPEAKER_01: You lose some things when you don't have WCF.
• 8:58
  SPEAKER_01: So if you needed those things, what do you do?
• 9:02
  SPEAKER_01: You have to rewrite those libraries, not just upgrade them, you have to rewrite them and change the logic.
• 9:10
  SPEAKER_01: That can be a big deal, and that will really extend your time frame.
• 9:14
  SPEAKER_01: So that time frame can slip just from missed things, the things you didn't understand or didn't know about, that you you know, you just missed it when you were trying to plan this out.
• 9:26
  SPEAKER_01: But then the other part of that is remember that management wants upgrades.
• 9:32
  SPEAKER_01: And so when management sees you doing all this work and not getting any real value, they're gonna say, hey, while you're already in there, can you sneak in this change or sneak in that change?
• 9:46
  SPEAKER_01: Or maybe it's not management, maybe it's just you.
• 9:49
  SPEAKER_01: You go, hey, you know what?
• 9:51
  SPEAKER_01: I see we can we can make this better.
• 9:53
  SPEAKER_01: We can fix a little bit and tweak a little bit here and really improve some performance here.
• 9:58
  SPEAKER_01: And so now you put this extra change in.
• 10:01
  SPEAKER_01: Those changes take time, especially since that's now untested logic.
• 10:07
  SPEAKER_01: That when you go to test it, it might break.
• 10:09
  SPEAKER_01: Maybe you don't test it, and now you get to the end and go, things just aren't working.
• 10:13
  SPEAKER_01: Um, that all drains time away.
• 10:17
  SPEAKER_01: So that risk of not finishing on time is huge.
• 10:22
  SPEAKER_01: It's huge.
• 10:23
  SPEAKER_01: Unless your project is so small that's not a big deal.
• 10:27
  SPEAKER_01: The the risk of slipping your time frame is almost inevitable.
• 10:31
  SPEAKER_01: Unless you have really padded out your time frame, it's almost inevitable.
• 10:37
  SPEAKER_01: I mean, trying to estimate a project and what you're gonna be like in a year is is so difficult.
• 10:43
  SPEAKER_01: You don't know.
• 10:44
  SPEAKER_01: I mean, maybe COVID hits and all of a sudden, you know, you shut down in office.
• 10:48
  SPEAKER_01: That's a big deal.
• 10:50
  SPEAKER_01: So there's a lot of risk that comes with those upgrades.
• 10:54
  SPEAKER_01: So these are the reasons why companies don't upgrade, and some of it's just apathy as well.
• 11:01
  SPEAKER_01: But let's talk now about why you should upgrade.
• 11:06
  SPEAKER_01: And the number one thing on my list is again risk.
• 11:11
  SPEAKER_01: Yes, there's a risk to upgrading, and yes, there's a risk to um doing this process, especially more than once, which is what I'd advocate, smaller upgrades over time rather than one big one.
• 11:23
  SPEAKER_01: But there is a risk, and that risk on the other side, if you don't upgrade, is failure.
• 11:31
  SPEAKER_01: So at some point, your systems will stop working, and you're gonna have a problem.
• 11:38
  SPEAKER_01: So let's just say you are running old software on Windows NT.
• 11:44
  SPEAKER_01: If you don't have familiar NT, it goes back a few years.
• 11:47
  SPEAKER_01: Um, but let's say you're running on Windows NT because that's the latest version that works with your software, and a computer fails.
• 11:57
  SPEAKER_01: Well, newer modern hardware might not be fully compatible with Windows NT.
• 12:03
  SPEAKER_01: So now you have to figure out how to replace these parts with parts that still work with that old stuff.
• 12:11
  SPEAKER_01: Maybe it requires a serial port in your computer.
• 12:15
  SPEAKER_01: Well, they don't come with serial ports anymore.
• 12:17
  SPEAKER_01: You can, yes, buy some cards, but sometimes the drivers don't work then with the older operating systems.
• 12:24
  SPEAKER_01: So you run into the problem of maybe I can't get the parts I need to continue these systems.
• 12:33
  SPEAKER_01: So it's definitely some risk there.
• 12:35
  SPEAKER_01: There's also a cost associated as well.
• 12:39
  SPEAKER_01: The systems you're gonna run on are less efficient.
• 12:42
  SPEAKER_01: Maybe you say, hey, we can run, I'm not even sure if you can or not, we can run NT in a Docker container, let's say.
• 12:48
  SPEAKER_01: Docker's awesome, uh, it might be able to.
• 12:51
  SPEAKER_01: But let's say you do, well, that's not as efficient as running it on a system, but the systems you have to run it on are really old, and those aren't efficient either.
• 13:01
  SPEAKER_01: So you have some efficiency lost there either way.
• 13:06
  SPEAKER_01: And replacements are rarer.
• 13:09
  SPEAKER_01: So if replacements are rarer, then the costs are gonna go up.
• 13:13
  SPEAKER_01: There are things where if you buy a brand new computer today, they can be cheaper sometimes than an old computer.
• 13:21
  SPEAKER_01: Because an old computer, there's only a few of them left, so the price goes up because if there is a demand for it and the supply is small, then you're gonna raise that price to get what you can out of that now more valuable thing.
• 13:37
  SPEAKER_01: And then the the other part of cost here is that developers are more niche.
• 13:43
  SPEAKER_01: As you leave the modern era, as your as time passes, you buy, developers are less and less likely to want to work on your software.
• 13:55
  SPEAKER_01: So you have a narrower and narrower pool of people that could work on your software and who want to.
• 14:03
  SPEAKER_01: And again, just like with those parts, as the the supply of developers dwindles down, the the demand might drive higher prices.
• 14:16
  SPEAKER_01: And so you're now paying these developers one and two and three times what you would a regular developer, uh a modern developer, because there's more modern developers than there are these niche developers.
• 14:31
  SPEAKER_01: So it's also a cost factor, but it's also the idea of lost opportunity.
• 14:37
  SPEAKER_01: So if you don't upgrade, you might lose opportunities.
• 14:41
  SPEAKER_01: When the mobile devices first came out, they were seen as a fad, that's not gonna go anywhere, and software really didn't support them.
• 14:48
  SPEAKER_01: Well, if that's where your software stopped, and now mobile is the primary way we do we browse the web, it's the primary way we interact with computers, you're kind of losing an opportunity here.
• 15:03
  SPEAKER_01: And along with that, there is the inability to grow.
• 15:07
  SPEAKER_01: The idea that you can only scale so high, you can only expand so much.
• 15:13
  SPEAKER_01: Let's just say you're a warehouse and you run everything on these old Windows NT machines, that's the most modern you can go.
• 15:22
  SPEAKER_01: What if you wanted to open up five more warehouses?
• 15:27
  SPEAKER_01: Well, you really can't because you can't get the supplies necessary to run your old software.
• 15:33
  SPEAKER_01: So there's a lock-in factor there at some point that really hampers what you can do.
• 15:40
  SPEAKER_01: And maybe you say, well, we'll do the new stuff and the new the new uh warehouses.
• 15:44
  SPEAKER_01: Well, great, but now the two can't talk to each other.
• 15:48
  SPEAKER_01: That's a problem where you have two different systems, and that that really does happen, and it's messy.
• 15:54
  SPEAKER_01: And then you're trying to piece together some kind of bridge that that communicates across the two, and it gets really ugly really quickly.
• 16:04
  SPEAKER_01: And you still have to build that new system, which means you could just use that new system, the old system, and get rid of the old system, in which case you really did do an upgrade, but you did it the hard way.
• 16:15
  SPEAKER_01: Okay.
• 16:16
  SPEAKER_01: And the the final uh reason why you should upgrade is because if you don't, you risk the potential death of your business.
• 16:25
  SPEAKER_01: And that is not an exaggeration.
• 16:27
  SPEAKER_01: I have seen that happen, where a business loses their data because of a corrupt database that didn't have any backups or or you know that the systems are so old they're breaking down, they could not get replacements.
• 16:41
  SPEAKER_01: And so they literally could not operate anymore.
• 16:47
  SPEAKER_01: And at that point, it's too late.
• 16:49
  SPEAKER_01: You can't say, hey, customers, hold that thought.
• 16:52
  SPEAKER_01: I'm gonna go for the next year or so and kind of redo this, and then we'll come back, we'll start from today.
• 16:59
  SPEAKER_01: That doesn't happen.
• 17:01
  SPEAKER_01: You have to think ahead.
• 17:03
  SPEAKER_01: You can't think about tomorrow, you've got to think about a year, two years, five years down the road to plan out some of these actions.
• 17:14
  SPEAKER_01: So if you aren't already building the upgrade to the system, then it's too late.
• 17:20
  SPEAKER_01: And if you can't run your business, your customers go elsewhere and you go out of business.
• 17:26
  SPEAKER_01: So just staying in place can be a death sentence for a business.
• 17:32
  SPEAKER_01: So, yes, upgrading is important, but how do you do this?
• 17:38
  SPEAKER_01: Because enterprise applications aren't just an application you wrote on the weekend, they are massive, they are millions of lines of code, they interact with hardware, they are integrated into systems that might be old.
• 17:54
  SPEAKER_01: Like I said, Windows NT or you know, old, old um scanners and PLCs and other things that that are really they tie together in such a way that it's not easy to unravel that.
• 18:09
  SPEAKER_01: So, how do you upgrade to the latest version?
• 18:13
  SPEAKER_01: Well, number one, you have to pick your battles.
• 18:17
  SPEAKER_01: Some things are just better left alone.
• 18:20
  SPEAKER_01: If you have a standalone piece of equipment that runs against a very old piece of software and it's not changing, and the equipment's not changing, maybe you don't touch that for now.
• 18:32
  SPEAKER_01: Maybe not ever.
• 18:34
  SPEAKER_01: If it, you know, kind of if it isn't broke, don't fix it.
• 18:37
  SPEAKER_01: Well, that might apply here, where some things you just leave alone and say, hey, we're gonna try not to touch that.
• 18:46
  SPEAKER_01: The next thing is you need to start small.
• 18:50
  SPEAKER_01: Do not, do not go to your boss and say, I have a plan to upgrade all of our software all at once.
• 18:58
  SPEAKER_01: And that's not a good idea.
• 19:00
  SPEAKER_01: If your boss approves it, come back to me in a year and post down in the comments or email me, let me know how badly it went.
• 19:10
  SPEAKER_01: Because trust me from experience, that's not gonna go well.
• 19:14
  SPEAKER_01: Okay.
• 19:14
  SPEAKER_01: Um, and if it does, man, that's awesome.
• 19:17
  SPEAKER_01: You are a unicorn.
• 19:18
  SPEAKER_01: Um, this does not happen that often.
• 19:21
  SPEAKER_01: So start small, pick something, a piece.
• 19:25
  SPEAKER_01: Try to carve off a little bit to upgrade.
• 19:30
  SPEAKER_01: All right, and then when you do that, guard your scope.
• 19:36
  SPEAKER_01: The the worst killer of projects is scope creep.
• 19:40
  SPEAKER_01: The idea that for with good intentions, you start to move to a larger and larger project because you want to do more, you want to accomplish more, you want to add those new features in.
• 19:55
  SPEAKER_01: You want to that can kill your project, even a small one.
• 20:00
  SPEAKER_01: So guard your scope.
• 20:02
  SPEAKER_01: What I I like to do is I like to say, okay, that's a great idea.
• 20:08
  SPEAKER_01: Let's put that down for version two.
• 20:10
  SPEAKER_01: Or that's that's a great idea.
• 20:12
  SPEAKER_01: I I know that I already have stuff for version two, let's put that for version three.
• 20:17
  SPEAKER_01: And you kind of just rough it out.
• 20:18
  SPEAKER_01: Hey, this is version two, version three.
• 20:20
  SPEAKER_01: Then management, you, your coworkers, you can all uh bicker over is that a version two or version three?
• 20:27
  SPEAKER_01: Can you change priorities around, make that a two and that a three?
• 20:32
  SPEAKER_01: Go go crazy.
• 20:33
  SPEAKER_01: But that's not what you're doing now.
• 20:35
  SPEAKER_01: You're doing version one.
• 20:36
  SPEAKER_01: Version one is getting to work.
• 20:38
  SPEAKER_01: So guard that scope jealously.
• 20:41
  SPEAKER_01: And then also you need to be honest about the value, especially this first one where you start small, you have to promise less than you deliver.
• 20:57
  SPEAKER_01: Okay?
• 20:58
  SPEAKER_01: Underpromise, over deliver.
• 21:00
  SPEAKER_01: If you say, hey, you know, boss, we need to upgrade everything to.NET 6.
• 21:06
  SPEAKER_01: And if we do, it is going to be 100% faster.
• 21:11
  SPEAKER_01: Guaranteed.
• 21:12
  SPEAKER_01: So let's start with this little piece.
• 21:14
  SPEAKER_01: And you upgrade that little piece and you say it's gonna take a week and it takes a month.
• 21:19
  SPEAKER_01: And the end result is that piece is a little slower.
• 21:23
  SPEAKER_01: Or maybe it's 10% faster, maybe it's 50% faster.
• 21:29
  SPEAKER_01: So it took you four times as long, and I got half the value you promised.
• 21:35
  SPEAKER_01: That doesn't seem like the boss is gonna look at that and go, yep, time to do the rest.
• 21:40
  SPEAKER_01: Okay, you have to underpromise and over deliver.
• 21:45
  SPEAKER_01: Say, I think that it will give us a boost, but you know what?
• 21:49
  SPEAKER_01: Even if it doesn't, it's gonna bring us into the modern era, it's gonna allow us to use more systems, more tools.
• 21:56
  SPEAKER_01: And so let's let's plan for this to take.
• 22:00
  SPEAKER_01: Two months, we're gonna try, you know, take our time, make sure we get it right, and set up some systems and processes in place so that as we do more of these, they go faster.
• 22:09
  SPEAKER_01: But let's start off with two months and this little piece, and we'll see how how performant it is when it comes out.
• 22:16
  SPEAKER_01: Make sure that this is like a test case, make sure it all works, make sure that we're doing the right thing and we're not just wasting time.
• 22:26
  SPEAKER_01: You come in at six weeks, and not only is it run, but it runs 20% faster than the old code.
• 22:36
  SPEAKER_01: That's you're now a hero.
• 22:38
  SPEAKER_01: You come in under time, you've come in with a better product, and hopefully you have systems in place to make it go even faster for next time.
• 22:48
  SPEAKER_01: So the even a worse outcome can make you look better if you underpromise and over-deliver.
• 22:57
  SPEAKER_01: There's a saying that my English teacher back in high school used to say, and it really is true, uh, but it's how do you eat an elephant?
• 23:06
  SPEAKER_01: Well, you do it one bite at a time.
• 23:09
  SPEAKER_01: If you look at an elephant and say, Man, I couldn't eat all of that, and I'm not sure I would want to, but you know, you look at that and say, I can't eat all that.
• 23:18
  SPEAKER_01: Don't concentrate on the whole elephant, concentrate on that one bite in front of you and then the next.
• 23:24
  SPEAKER_01: And sure, it's gonna take some time and leave it at that, okay?
• 23:30
  SPEAKER_01: But let's talk about applications the same way.
• 23:34
  SPEAKER_01: Don't look at the elephant and say, I'm gonna eat the whole thing in one sitting.
• 23:38
  SPEAKER_01: Think about one bite.
• 23:41
  SPEAKER_01: This is where microservices are a really big deal.
• 23:46
  SPEAKER_01: Microservices can be the salvation of your enterprise application.
• 23:52
  SPEAKER_01: And the reason why is because it's not just a cool new fad and you know, Kubernetes everything, and you know, rah-rah Docker.
• 24:01
  SPEAKER_01: That's not what this is about, it's about the idea that we break off chunks, we eat one chunk at a time.
• 24:10
  SPEAKER_01: So let's just say your system, uh, your big monolith, that's your enterprise monolith.
• 24:16
  SPEAKER_01: Let's just say it's written in.NET Framework 3.5, old system.
• 24:20
  SPEAKER_01: So in there somewhere, buried in the code, it emails users when their product ships.
• 24:27
  SPEAKER_01: Okay.
• 24:28
  SPEAKER_01: So the product gets put in a database, the purchase does, and when the warehouse says, Yep, we've shipped that, put the tracking number of the database, and then the system picks that up and says, Okay, I'm gonna send an email out.
• 24:42
  SPEAKER_01: It's all in one big monolith, the code's interwoven in there.
• 24:46
  SPEAKER_01: You can take the emailer portion out, monitor the database, and say, hey, maybe have an hourly schedule.
• 24:54
  SPEAKER_01: Look at the database.
• 24:55
  SPEAKER_01: Has something going out?
• 24:56
  SPEAKER_01: Yes, cool.
• 24:57
  SPEAKER_01: I'm gonna tell the user, I might email the user.
• 25:00
  SPEAKER_01: But that code, that emailing code, will be in.NET six.
• 25:03
  SPEAKER_01: Okay, you've taken one byte and taken it out of the monolith.
• 25:08
  SPEAKER_01: Just turn off the pieces in the monolith, and then you're good to go because the system now will take that piece and set separately run that.
• 25:19
  SPEAKER_01: Okay, which means also you can put on a different machine, you can have it on a faster process, you can even have it in the cloud.
• 25:26
  SPEAKER_01: So you now have one modern piece in your ancient enterprise monolith.
• 25:34
  SPEAKER_01: Now, what if you're you've got a user interface that let's say a person on the shop floor, they type something into the interface and it saves it to the database.
• 25:44
  SPEAKER_01: And that's really all they do in the shop floor.
• 25:46
  SPEAKER_01: Well, you could replace just the user interface with a modern user interface, maybe even a mobile user interface, and have that interface write to the database.
• 25:56
  SPEAKER_01: You might say, well, Tim, the database is old.
• 25:59
  SPEAKER_01: Okay, so write a wrapper where maybe an API where you call the API and say, hey, handle this.
• 26:07
  SPEAKER_01: And that API says, okay, here's how to translate that into old, and it takes that and puts it in the database.
• 26:15
  SPEAKER_01: So now you have a modern user interface for one particular piece.
• 26:21
  SPEAKER_01: Maybe your monolith reads text files and puts that data into the database as just part of the process.
• 26:28
  SPEAKER_01: Well, replace that part with a modern equivalent.
• 26:31
  SPEAKER_01: Right there, I can tell you, you're gonna have some big performance savings if you use.NET 6.
• 26:37
  SPEAKER_01: Now, if your system uses an old communication technology, maybe create a wrapper around a more modern uh version of communication, let's say gRPC, and then have that talk to the old communication system and back.
• 26:53
  SPEAKER_01: Now you can have new systems talk to GRPC, and you can have the old systems talk to the old piece, and that translator will wire the two together.
• 27:02
  SPEAKER_01: So now you can start building new systems using new communication technologies and yet still have the old systems still work.
• 27:10
  SPEAKER_01: Now, when we're talking specifically about a.NET framework to.NET 6 transition, there are some few tips, a few tips that are more specific.
• 27:20
  SPEAKER_01: So, for example, the first step I would take would be to refactor as much code as possible out of the UI into your class libraries.
• 27:30
  SPEAKER_01: So the way we used to build, at least, okay, in my experience, what I have seen in businesses, I have done it, I am guilty of this.
• 27:41
  SPEAKER_01: Is you have an old Winforms application, it's built in, let's say,.NET Framework 3.5.
• 27:48
  SPEAKER_01: You put all the code for that and the code behind.
• 27:52
  SPEAKER_01: Not a great practice.
• 27:53
  SPEAKER_01: Okay.
• 27:54
  SPEAKER_01: So the first thing you do is in.NET Framework 3.5, you create a class library and move as much code as possible into that class library, all the non-UI code.
• 28:06
  SPEAKER_01: So the next step is to separate the upgradable code from the the less upgradable code.
• 28:13
  SPEAKER_01: Maybe you have some things in there that just won't upgrade.
• 28:16
  SPEAKER_01: Uh WCF calls because WCF is not supported in.NET Core and beyond.
• 28:23
  SPEAKER_01: Um, those kind of things.
• 28:24
  SPEAKER_01: Well, separate those out from the stuff that's easily upgradable.
• 28:28
  SPEAKER_01: So you have two class libraries.
• 28:30
  SPEAKER_01: And now upgrade the upgradeable one to.NET Standard 2.0.
• 28:37
  SPEAKER_01: What that will do is you can have your monolith, but you're upgrading it just a piece, just that compatible code to the new.NET standard, well, new ish.NET standard 2.0, which means you can now write UIs, you can write class libraries, other things that talk to your.NET standard code, but your those libraries and UI code can be in.NET 6.
• 29:06
  SPEAKER_01: So you can start replacing UI pieces that just use the compatible code.
• 29:12
  SPEAKER_01: Now there's still some incompatible pieces there, and you have to maybe talk across to those libraries, but you have most of your stuff upgraded.
• 29:23
  SPEAKER_01: And then you can create wrappers for the code that just can't be upgraded.
• 29:27
  SPEAKER_01: Wrap that stuff up and try and get as small as possible, as few lines of code as possible.
• 29:33
  SPEAKER_01: It may be still thousands or millions, but you wrap that all up and say, okay, we're gonna put a wrapper around this, and then everything else is gonna be the new modern upgraded versions.
• 29:45
  SPEAKER_01: So there's ways of taking this one step at a time, one little piece at a time, extracting one win and the next win and the next win.
• 29:57
  SPEAKER_01: And the the really key part here is make sure they're wins, don't just extract things and make it worse.
• 30:03
  SPEAKER_01: Okay, so that email system.
• 30:05
  SPEAKER_01: If you go from being able to process 50 emails a minute to 500 emails a minute, that'll be huge.
• 30:14
  SPEAKER_01: If you can, with that uh text file importer, if you go from importing, let's say, five text files, because they're big into your system to 500 because.NET 6 is really performant when it comes to working with text files, that would be huge to your business.
• 30:32
  SPEAKER_01: And that will show value to your boss, that will show value to your team, that will help get people on board, and it will show why this update process is important.
• 30:43
  SPEAKER_01: It will also allow you to have those more modern UIs so you can have a mobile app for that one um that one team that uses just one little uh piece of a UI.
• 30:54
  SPEAKER_01: You can upgrade it to a mobile app for them, and and now they can be out on in the warehouse scanning boxes right away with a portable scanner instead of going back to a station.
• 31:04
  SPEAKER_01: Okay, that reduces your your hours needed in the warehouse, that reduces your manpower needs, and all of a sudden the company is making more money.
• 31:14
  SPEAKER_01: So if you really tie it back to wins and keep pointing those wins out and keep showing how this upgrade process is important, that will really help give you the momentum to keep going on the upgrade process.
• 31:29
  SPEAKER_01: Now, you're not always gonna be successful.
• 31:33
  SPEAKER_01: You may have to live in this old world, you may have to spend some time there and get up to speed before you can just start making changes.
• 31:41
  SPEAKER_01: I get that.
• 31:42
  SPEAKER_01: I hope you do as well.
• 31:44
  SPEAKER_01: Um, if you're a new developer and you're saying, man, I don't want to do anything but.NET 6.
• 31:50
  SPEAKER_01: Good luck.
• 31:51
  SPEAKER_01: Um, you've just narrowed your pool way down, but at the same time, I can respect the idea that you don't want to have your skills atrophy atrophy by doing old stuff only.
• 32:03
  SPEAKER_01: Totally get that.
• 32:04
  SPEAKER_01: I have been there and wasn't a good situation.
• 32:07
  SPEAKER_01: And so, yes, you want to make sure that you're not just using the old stuff and never upgrading your skills.
• 32:16
  SPEAKER_01: If you are in those positions, practice outside of work or help get your boss on board with you keeping your skills current because otherwise you will atrophy along with the application.
• 32:31
  SPEAKER_01: And then when it comes to the company downsizing and they release you, now what do you do?
• 32:37
  SPEAKER_01: Your skills don't really apply to more uh jobs.
• 32:42
  SPEAKER_01: Now you've limited yourself on the other end.
• 32:44
  SPEAKER_01: Instead of limiting yourself with only the modern stuff, you've limited yourself with only the old stuff.
• 32:49
  SPEAKER_01: That's not a great place to be.
• 32:52
  SPEAKER_01: Okay, so this upgrade process is important.
• 32:56
  SPEAKER_01: It's important that companies do continue to move forward with their languages and continue to move forward with the updates, but it is something difficult.
• 33:06
  SPEAKER_01: Now, what I would encourage, if you have any power at all, if you're in any sort of position to help determine policy for your organization, I would highly encourage you to upgrade continually.
• 33:21
  SPEAKER_01: I know it's a painful process, I know that it feels like you don't get much of a win when you do that, but it's important.NET has a three-year support window.
• 33:34
  SPEAKER_01: Okay, so.NET 6 is coming out in November.
• 33:38
  SPEAKER_01: Well, that.NET 6 will be supported for three years.
• 33:43
  SPEAKER_01: And then two revisions later, which will be.NET 8.
• 33:48
  SPEAKER_01: When that comes out, it will be supported for three years.
• 33:52
  SPEAKER_01: If you do the math on that, you'll realize that.NET 6 and.NET 8 will be supported at the same time.
• 33:57
  SPEAKER_01: The reason for that overlap is to give you a year to go from.NET 6 to.NET 8.
• 34:04
  SPEAKER_01: Do that.
• 34:06
  SPEAKER_01: Do upgrade at least that often every two years with.NET, because the upgrade process is much simpler when you do it that way.
• 34:15
  SPEAKER_01: And people say, Well, Tim, you know, I did a um a talk where I said, hey, the upgrade process is about 20 minutes to go from.NET 5 to.NET 6.
• 34:23
  SPEAKER_01: And people said, It'll never be only 20 minutes.
• 34:26
  SPEAKER_01: I have done it, it's less than 20 minutes for a full application.
• 34:30
  SPEAKER_01: But the point is, people say, well, there's integration testing and unit testing and verification processes and you know quality assurance and all these validation processes.
• 34:42
  SPEAKER_01: Absolutely.
• 34:43
  SPEAKER_01: Yes, that's going to take you time.
• 34:45
  SPEAKER_01: And yes, it needs to be done.
• 34:48
  SPEAKER_01: It's part of the process.
• 34:50
  SPEAKER_01: The actual upgrade process doesn't take that long, doesn't create a lot of breaking changes.
• 34:54
  SPEAKER_01: Very, very, very few breaking changes in the.NET 5 to 6 upgrade.
• 35:00
  SPEAKER_01: And.NET 6 to 7, same thing.
• 35:03
  SPEAKER_01: Or should be.
• 35:04
  SPEAKER_01: But it needs to be done that way.
• 35:07
  SPEAKER_01: Because if you don't, you say, well, it just takes too long.
• 35:10
  SPEAKER_01: Okay, so what's the alternative?
• 35:13
  SPEAKER_01: Stagnating where you're at, and then that upgrade process from let's just say dot net 5 or 6 to.NET 12, that's gonna be a little harder, probably.
• 35:27
  SPEAKER_01: There's gonna be some breaking changes, or at least some ways that are it's gonna cause some problems.
• 35:33
  SPEAKER_01: Now, hopefully not as many problems as the upgrade from say.NET Framework to.NET Core did, but even that was more about the third-party libraries than it was about the upgrade process.
• 35:45
  SPEAKER_01: So, and also the a few things that were didn't move over to.NET Core.
• 35:51
  SPEAKER_01: But you know, if you wait and kind of stagnate, you're not making your life easier.
• 35:57
  SPEAKER_01: It's not like the upgrade process from.NET 6 to.NET 12 will be the same as from six to eight, just won't.
• 36:06
  SPEAKER_01: You're gonna have to do a lot more paints.
• 36:08
  SPEAKER_01: Like it's like trying to skip steps on the stairs.
• 36:12
  SPEAKER_01: Going up one step at a time, not hard, hopefully.
• 36:15
  SPEAKER_01: It is right now for me.
• 36:17
  SPEAKER_01: But um if you go up two steps at a time, a little harder.
• 36:21
  SPEAKER_01: If you go up three steps at a time, a lot harder.
• 36:24
  SPEAKER_01: Okay, so same thing is true with upgrading software.
• 36:28
  SPEAKER_01: Stay current.
• 36:30
  SPEAKER_01: When you don't, that's when you fall behind, that's when you stagnate, that's when you increase your risk, that's when you increase your cost, that's when you s you lose opportunities.
• 36:42
  SPEAKER_01: So if you have the opportunity now, stay current.
• 36:47
  SPEAKER_01: If you're off that path, it's getting more expensive, more time consuming, and you have to do it one piece at a time.
• 36:53
  SPEAKER_01: But try and get up onto the current version as much as possible.
• 36:58
  SPEAKER_01: All right.
• 36:58
  SPEAKER_01: So thanks for listening to this week's episode of Dev Questions.
• 37:01
  SPEAKER_01: I hope that answered your question about how do you upgrade enterprise applications.
• 37:06
  SPEAKER_01: If you have a question about being a developer, check out the previous episodes.
• 37:10
  SPEAKER_01: And don't forget this is both a video series on YouTube on Thursdays, as well as a podcast on all your favorite podcast sites.
• 37:20
  SPEAKER_01: So thanks for watching, thanks for listening, and have a great day.
• 37:24
  SPEAKER_01: And as always, I am Tim Corey.
• 37:26
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 37:29
  SPEAKER_00: Tim is committed to making it easier for you to become a developer.
• 37:33
  SPEAKER_00: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 37:40
  SPEAKER_00: You can also send your questions to questions at IamTimcorey.com.
• 37:45
  SPEAKER_00: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 37:52
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to imtimcorey.com and enroll in a course.