Latest / DevQuestions with Tim Corey / 135 Should I Start My Project Over From Scratch or Update It?

Transcript

135 Should I Start My Project Over From Scratch or Update It? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:03
  SPEAKER_01: 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_01: 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_01: Now, here's your host, expert developer and online educator, Tim Corey.
• 0:25
  SPEAKER_02: Should I start my project over from scratch or should I update it?
• 0:28
  SPEAKER_02: This is a question that's asked on a suggestion site.
• 0:30
  SPEAKER_02: I thought we had a great one to tackle in today's episode of DevQuesti.
• 0:34
  SPEAKER_02: Now, if you have a question, go to suggestions.iamtimcorey.com, leave it there, or upvote an existing one that fits your question.
• 0:42
  SPEAKER_02: Hopefully, you'll see your question answered on a future episode of Dev Questions.
• 0:47
  SPEAKER_02: Okay, so should you start a project over?
• 0:50
  SPEAKER_02: Let's say you have a project that you know it's kind of old, it's got a mess in there, and you're like, should I just abandon it and start over, or should I try to fix this thing?
• 1:03
  SPEAKER_02: Let me start with where I start.
• 1:06
  SPEAKER_02: And that is I start from the perspective of we're going to upgrade this.
• 1:11
  SPEAKER_02: And let's talk through why I think that, what the pros and cons of each are, and then hopefully I'll give you some better criteria for identifying when it's time to just replace the entire project versus upgrading the project.
• 1:27
  SPEAKER_02: Okay?
• 1:28
  SPEAKER_02: So we're gonna start off with a scenario.
• 1:30
  SPEAKER_02: And this is a scenario that I've changed a few details to protect the innocent, but this is a real scenario that I really did work on for a company.
• 1:40
  SPEAKER_02: And the scenario is you've got a project that is in.NET Framework 3.5.
• 1:46
  SPEAKER_02: It's a web forms project with lots of third-party dependencies.
• 1:51
  SPEAKER_02: Okay.
• 1:52
  SPEAKER_02: It's a pretty common scenario, actually.
• 1:55
  SPEAKER_02: And then the actual issues, besides the fact it's web forms, not you know, um, something more modern, and it's on.NET framework even 3.5, not even uh 4 or 4.5.
• 2:06
  SPEAKER_02: Um it's got spaghetti code.
• 2:08
  SPEAKER_02: It's got a mess of code all over.
• 2:10
  SPEAKER_02: There's no test, there's no logging, there's no best practices, there's no class library to house our business logic and data access.
• 2:17
  SPEAKER_02: It's kind of all just in the code behind for web forms.
• 2:21
  SPEAKER_02: So that's our scenario.
• 2:22
  SPEAKER_02: And the question is: do we upgrade this or do we do a uh build a second application where we build it up and then swap it out at one point, you know, overnight, something like that, where all of a sudden it's a brand new application with all new bells and whistles.
• 2:41
  SPEAKER_02: So let's talk through how to upgrade it.
• 2:45
  SPEAKER_02: Since we know how we we replace it, right?
• 2:48
  SPEAKER_02: We'd rebuild the application in a brand new code base and redo everything.
• 2:54
  SPEAKER_02: It'd kind of be like the a waterfall approach, probably, where we'd say we already have our requirements, let's go ahead and build it.
• 3:01
  SPEAKER_02: Or even worse, you get into the place where you're like, well, since we're already here, let's go ahead and add these features and change these things, and all of a sudden you're in a real nightmare.
• 3:11
  SPEAKER_02: But that's the the build process.
• 3:13
  SPEAKER_02: We don't have to build an application.
• 3:14
  SPEAKER_02: But how would you upgrade something like this?
• 3:17
  SPEAKER_02: Let's just talk through the basics of this, and then we'll get into the pros and cons of upgrade versus replace.
• 3:25
  SPEAKER_02: So what I would do, what I did, um would be I would extract as much code as possible into a class library.
• 3:34
  SPEAKER_02: So you have.NET Framework 3 or 3.5.
• 3:38
  SPEAKER_02: Um, you extract as much as possible into a.NET 3.5 class library that you um you know move everything as much as possible out from underneath the user interface.
• 3:51
  SPEAKER_02: Now, UI code stays in the UI, but business logic, data access, all that stuff, try and get it into a class library.
• 3:58
  SPEAKER_02: Well, then I'd want to reduce as much as possible the dependencies on third-party libraries because those third-party libraries probably won't upgrade cleanly throughout our entire move.
• 4:12
  SPEAKER_02: Because we probably want to move to.NET 7.
• 4:14
  SPEAKER_02: Well, most dependencies aren't going to just move from old.NET framework to brand new uh.NET 7.
• 4:23
  SPEAKER_02: So we want to reduce as much as possible the dependencies and get down to as few as possible.
• 4:30
  SPEAKER_02: Next, I'd try to upgrade the entire thing to.NET Framework 4.8, the latest.NET framework.
• 4:38
  SPEAKER_02: That's still.NET Framework.
• 4:40
  SPEAKER_02: It's still the older technology, not.NET Core, but we try to move it to.NET 4.8, 4.7, somewhere in there, if we can get it that far.
• 4:49
  SPEAKER_02: Okay.
• 4:50
  SPEAKER_02: That'd be the goal for that upgrade process.
• 4:52
  SPEAKER_02: And that would be a lot of trial and error.
• 4:56
  SPEAKER_02: And it would be a bigger upgrade just in the standpoint I would have to test the entire application and all the rest, but that's where I'd go next.
• 5:04
  SPEAKER_02: And then what I would do is I would move as much as possible in that class library, if not the entire class library, over to a.NET 7 API.
• 5:16
  SPEAKER_02: And then I'd call it from the user interface in web forms.
• 5:21
  SPEAKER_02: Okay, so now we have web forms calling an API instead of web forms calling our class library.
• 5:26
  SPEAKER_02: And all of a sudden now our API can be on the latest technology because an API doesn't matter what language it's in, if it doesn't even matter what language it's in.
• 5:35
  SPEAKER_02: Like you can write it in, I don't know, node, and that's fine.
• 5:39
  SPEAKER_02: It will still run with.NET framework.
• 5:41
  SPEAKER_02: So I would try and do that.
• 5:42
  SPEAKER_02: And then I would try to create replacement pages in probably, I don't know, ASP.net core Razor pages.
• 5:50
  SPEAKER_02: And then I would slowly create, you know, page or two in Razor Pages, and then replace that page or two over the other site and try and mix those two together.
• 5:59
  SPEAKER_02: And I'd mix the whole site until finally we don't have any web forms left.
• 6:05
  SPEAKER_02: We have just Razor pages.
• 6:06
  SPEAKER_02: All of a sudden, we have a brand new application, really, but at the same time, a lot of the stuff behind the scenes is still a little kludgy.
• 6:15
  SPEAKER_02: We're still working through it and improving logic and all the rest.
• 6:20
  SPEAKER_02: But we kind of move that over.
• 6:23
  SPEAKER_02: Okay.
• 6:23
  SPEAKER_02: So that would be the high-level process that I'd probably take in a scenario like that.
• 6:30
  SPEAKER_02: That's a lot of work.
• 6:31
  SPEAKER_02: And it's a lot of interwork, okay, where you have to have things working together that might not necessarily want to work together.
• 6:40
  SPEAKER_02: And you're doing some things that, like the upgrade.NET Framework 4.8.
• 6:45
  SPEAKER_02: Well, that's a that's an upgrade, but not as far as you want to go.
• 6:49
  SPEAKER_02: You still want to go to.NET 7, which is a far sight different than.NET Framework 4.8 as far as underlying architecture.
• 6:58
  SPEAKER_02: But you know, the code might be similar, but why do you stop there?
• 7:02
  SPEAKER_02: Well, because that's where you kind of have to stop to keep web forms running.
• 7:08
  SPEAKER_02: So you'll do some upgrades like that where it might not give you everything, might not give you all the way there, but you get closer.
• 7:16
  SPEAKER_02: So now we have that scenario in our heads.
• 7:20
  SPEAKER_02: Let's talk about the cost to upgrade.
• 7:22
  SPEAKER_02: Okay, the first cost of upgrading as opposed to replacing, it's gonna take a very long time.
• 7:29
  SPEAKER_02: It's not gonna be something overnight that you do.
• 7:31
  SPEAKER_02: All right.
• 7:32
  SPEAKER_02: It's also means you're gonna work with older technology for a while.
• 7:36
  SPEAKER_02: So you're gonna stick with the.NET framework for a long time.
• 7:42
  SPEAKER_02: Until that last web form page is replaced at the very end of the process, you will still have.NET framework code.
• 7:50
  SPEAKER_02: That's a long time.
• 7:52
  SPEAKER_02: All right.
• 7:53
  SPEAKER_02: So you're gonna have to be okay with your team's gonna have to be okay with the idea of we work in older technology, we use older versions of Visual Studio, we use the older versions of C sharp, and we don't have all the latest and grayest stuff because we're using.NET framework for some of our code.
• 8:11
  SPEAKER_02: So you'll have that dual life for a long time.
• 8:16
  SPEAKER_02: It's ultimately harder to debug because now you have, you know, when you get to the point where you have an API that's.NET 7, you have your web forms, which is.NET Framework 4.8.
• 8:28
  SPEAKER_02: Well, now you've got to debug that connection piece as well.
• 8:32
  SPEAKER_02: And you have to have two applications running and seeing, you know, is is the the API causing the problem, or is the front end, or is it how the front end you know figures out the API and all that kind of stuff?
• 8:43
  SPEAKER_02: It just gets harder to debug.
• 8:45
  SPEAKER_02: All right.
• 8:46
  SPEAKER_02: And it might even make your application worse for a while.
• 8:50
  SPEAKER_02: So your application might be slower, it might be less responsive, it might not have as many features as it used to.
• 8:58
  SPEAKER_02: Um, when I went through this process, the the company I was working for was heavily into web forms and they used session for everything.
• 9:09
  SPEAKER_02: So they put everything in the session object, megabytes of information in the session object that the user would pass from page to page, which was very, very convenient because every uh web app page would know about everything that came before.
• 9:28
  SPEAKER_02: Well, you can't do that in MBC or Razor pages.
• 9:32
  SPEAKER_02: There's they're not they're session-let or stateless.
• 9:35
  SPEAKER_02: So that state you're passing around, it didn't really have a good way of knowing about that.
• 9:41
  SPEAKER_02: And you could turn on state, but it would cause problems because it's not designed to do that.
• 9:47
  SPEAKER_02: And now you're trying to force it to do something that you shouldn't want it to do long term.
• 9:51
  SPEAKER_02: And so we had to create a way to basically look up state, the state that you needed for a particular page, instead.
• 10:00
  SPEAKER_02: And so now it's a lot more database calls, there's a lot more uh latency as opposed to just having the session object have everything in it.
• 10:10
  SPEAKER_02: So that caused some degradation of the application's performance and the some degradation of what information you got and how fast and how it worked and all the rest.
• 10:23
  SPEAKER_02: So there are things that will happen that will could intend could make your application work a little less good, a little a little more poorly if you um try to do this upgrade process.
• 10:37
  SPEAKER_02: But what are the benefits?
• 10:39
  SPEAKER_02: Because this sounds horrible so far.
• 10:41
  SPEAKER_02: Why would I ever do this?
• 10:42
  SPEAKER_02: Well, there are some benefits.
• 10:44
  SPEAKER_02: Um the benefits are let's just say you are starting down this process, and you've got to the point where you have the API and the web forms in.NET Framework 4.8.
• 10:57
  SPEAKER_02: But then your boss comes to you and says, Oh my goodness, we need to add a new feature to the site.
• 11:03
  SPEAKER_02: You can do that.
• 11:04
  SPEAKER_02: You can either create a new web forms page and have it talk to the API, add new API functionality, or if you're at that point, you can write that feature in Razor pages and have it be the first page that gets released because it's a brand new page or a brand new feature, a brand new section.
• 11:24
  SPEAKER_02: So updates can still happen throughout this process, which is important because typically businesses do not say, okay, we're good.
• 11:34
  SPEAKER_02: We're gonna pause all changes for the next two years while you upgrade.
• 11:40
  SPEAKER_02: It just doesn't happen.
• 11:42
  SPEAKER_02: In fact, it's hard to get businesses to pause changes for a week.
• 11:47
  SPEAKER_02: Because they're like, well, yeah, but this is a bug, I need to get this fixed.
• 11:50
  SPEAKER_02: Or I really need this new feature, or you know what, we just took out a new client and they need this functionality.
• 11:56
  SPEAKER_02: It's going to happen.
• 11:57
  SPEAKER_02: And so being able to make changes to the system while it's being upgraded is huge.
• 12:05
  SPEAKER_02: Now, also, as you make changes, you can change and implement, or I'm sorry, you can test and implement a change as you make it.
• 12:15
  SPEAKER_02: So as you decide, okay, we're ready to upgrade to.NET Framework 4.8.
• 12:22
  SPEAKER_02: Well, you put it in, you test it, and then you do it.
• 12:26
  SPEAKER_02: So something has improved right then.
• 12:30
  SPEAKER_02: Instead of waiting until the very end and getting all the changes, you get changes in increments as you go.
• 12:39
  SPEAKER_02: And with that, work can be done in small chunks.
• 12:42
  SPEAKER_02: Maybe that's a long process, like I said, but maybe you don't do it continually.
• 12:48
  SPEAKER_02: Maybe you say, okay, our goal for this year is to get to.NET Framework 4.8.
• 12:53
  SPEAKER_02: And you do that by March.
• 12:55
  SPEAKER_02: And you say, you know what, we're gonna go back to get any other updates done, other things we're gonna do where we're not gonna continue to do this upgrade process until next year.
• 13:05
  SPEAKER_02: And so you can do that if you want to.
• 13:07
  SPEAKER_02: You can do small chunks of work and say, okay, we're done for now.
• 13:10
  SPEAKER_02: You can do something as simple as, hey, every time you fix a bug, try and fix some code around it as well.
• 13:17
  SPEAKER_02: Or write a unit test for that code.
• 13:20
  SPEAKER_02: You know what?
• 13:22
  SPEAKER_02: When you start, you'll have no unit tests.
• 13:24
  SPEAKER_02: After you fix the first bug, you might have one or two unit tests.
• 13:28
  SPEAKER_02: And for a million lines of code, one or two unit tests seems like nothing.
• 13:33
  SPEAKER_02: But you've made progress and you've made an improvement, and that small little chunk of improvement will grow and grow until the point where you have dozens and hundreds of unit tests and you have more confidence in the changes you're making.
• 13:47
  SPEAKER_02: So there's some benefits to be had by even making small changes to your system to improve how things work.
• 13:54
  SPEAKER_02: So that's the benefits.
• 13:56
  SPEAKER_02: Let's talk about the other side.
• 13:59
  SPEAKER_02: What if you decide, no, you know what?
• 14:01
  SPEAKER_02: I'm not going to upgrade, I'm going to replace.
• 14:06
  SPEAKER_02: What are the the costs of doing that?
• 14:09
  SPEAKER_02: Well, it's going to take a long time.
• 14:11
  SPEAKER_02: You might say, well, Tim, that was the cost of upgrading.
• 14:16
  SPEAKER_02: And it sure was.
• 14:17
  SPEAKER_02: But the cost of replacing it is it's going to take a long time.
• 14:21
  SPEAKER_02: It may almost certainly will take longer.
• 14:24
  SPEAKER_02: So it's going to be a long time to replace it.
• 14:28
  SPEAKER_02: And then another cost is going to be that any work done on the old system is going to need to be done on the new system as well.
• 14:37
  SPEAKER_02: This creates a really scary scenario where you have a moving target for your end goal.
• 14:44
  SPEAKER_02: So let's say that you are, I don't know, a small little application, but you know, small meaning 200,000 lines of code.
• 14:54
  SPEAKER_02: And you know, you do X, Y, and Z, you create these widgets.
• 14:58
  SPEAKER_02: And then, you know, as you're in the upgrade process, a new company comes in and says, Hey, we want to increase your business by 30% if you would do this.
• 15:10
  SPEAKER_02: Okay, whatever this is.
• 15:12
  SPEAKER_02: And of course, the company executives are like, this is awesome.
• 15:16
  SPEAKER_02: We can hire more people, we can we can expand, we can all get raises, whatever.
• 15:20
  SPEAKER_02: And so they say yes, and they come to you and say, okay, but we need this new feature added.
• 15:26
  SPEAKER_02: Well, now you've got to add that feature to the old system.
• 15:30
  SPEAKER_02: And you've got to look at the new system and figure out how to change the new system to also incorporate that new feature, but it has to be created in the new way.
• 15:40
  SPEAKER_02: So you've got a moving target where the where done is for your new system.
• 15:46
  SPEAKER_02: And that's a really scary scenario because all of a sudden it feels like you're never going to catch up to done.
• 15:54
  SPEAKER_02: Because the more changes you make in the old system, which remember, always gonna be changing.
• 15:59
  SPEAKER_02: You're always gonna have things that are gonna be changing.
• 16:02
  SPEAKER_02: The more changes you make over here, the more change you have to make in the new system.
• 16:06
  SPEAKER_02: And all of a sudden, your goal gets a little further out every time.
• 16:11
  SPEAKER_02: So along with that, another cost to replacing is business logic can be lost.
• 16:18
  SPEAKER_02: Remember, I said that the system has spaghetti code where it's just complicated.
• 16:23
  SPEAKER_02: And you say, okay, let's take a step back.
• 16:26
  SPEAKER_02: I got the inputs, I've got the outputs.
• 16:28
  SPEAKER_02: Let me figure out if we can just work from that and figure it out and not have to deal with this spaghetti code.
• 16:35
  SPEAKER_02: And so you do that.
• 16:36
  SPEAKER_02: And you say, okay, I got this form, it takes in this information and it puts this data in a database after it crunches some stuff.
• 16:42
  SPEAKER_02: Um, cool.
• 16:43
  SPEAKER_02: And you get it to work.
• 16:45
  SPEAKER_02: But I can tell you for certain that unless that is brand new spaghetti code, there's probably some hidden stuff in there because you've probably had bugs over the years where they say, oh, well, that works for everything, but in cases where X, Y, and Z happens.
• 17:04
  SPEAKER_02: For example, um, if a user is from Alaska, we have to do this stuff.
• 17:10
  SPEAKER_02: If a user is from Canada, we have to do this stuff.
• 17:14
  SPEAKER_02: You know, normally all of our users are in the continental United States, um, the 48 states, but every once in a while you get a person from Alaska.
• 17:22
  SPEAKER_02: We have to take care of that, but it's got some tweaks to it.
• 17:24
  SPEAKER_02: Well, that you put that in the spaghetti logic.
• 17:28
  SPEAKER_02: That's why it becomes spaghetti logic.
• 17:30
  SPEAKER_02: Because you say, okay, you know, in there buried somewhere is if the user is in Alaska, then also do X, Y, and Z.
• 17:37
  SPEAKER_02: So when you write your code where you have the input and the output, and you figure out I can do this, the problem becomes where you do that and you miss Alaska.
• 17:48
  SPEAKER_02: You miss Canada, you miss whatever other little things that are buried in there that were exceptions.
• 17:54
  SPEAKER_02: And what you do is reintroduce the bugs that you've fixed over the years.
• 18:00
  SPEAKER_02: And all of a sudden, your code is going to move backwards a lot.
• 18:05
  SPEAKER_02: And you don't even know it because you don't have unit tests and you don't have tests for those edge cases.
• 18:12
  SPEAKER_02: And so all of a sudden now you've you've got a system that looks like it works.
• 18:16
  SPEAKER_02: It's the worst kind of system, a system that looks like it works because you start to get confidence and you say, okay, you know, I've I've put in a person from Washington, a person from Texas, a person from Iowa, a person from Pennsylvania, a person from Maine.
• 18:29
  SPEAKER_02: It all works.
• 18:31
  SPEAKER_02: And so you're good to go, and you forget about or don't realize that Alaska is a problem or Canada is a problem.
• 18:40
  SPEAKER_02: And then all of a sudden, your application, if it ever does get launched, when it gets launched, it has those bugs in it, and you'll find those right away.
• 18:49
  SPEAKER_02: But you'll find a lot of bugs really quickly because you bring this application online in all those places where spaghetti code was there because it was hiding a number of exceptions or edge cases and the fixes for them.
• 19:05
  SPEAKER_02: All of a sudden you have to fix all of them all at once, and it feels overwhelming, and it can actually cause your application to be rejected and people to roll back to the old application.
• 19:16
  SPEAKER_02: I have seen this happen.
• 19:18
  SPEAKER_02: I have seen brand new applications rolled out and rolled back in less than a week.
• 19:25
  SPEAKER_02: And all that work gets scrapped because they say, you know what, we just can't rely on it.
• 19:31
  SPEAKER_02: Our business needs to keep running.
• 19:33
  SPEAKER_02: And it does.
• 19:34
  SPEAKER_02: And we can't rely on a system that's so full of bugs, this is just a failure.
• 19:41
  SPEAKER_02: So you gotta be very careful that you don't lose the business logic, you don't lose the bug fixes, you don't lose the institutional history or institutional memory of all the things that need to be addressed for edge cases.
• 19:59
  SPEAKER_02: All right.
• 20:00
  SPEAKER_02: And then another cost is that work needs to be completely done before anything can be used.
• 20:06
  SPEAKER_02: Now, you can kind of, I don't want to say cheat because that's not right.
• 20:10
  SPEAKER_02: But you can say, oh, well, we're gonna take over this whole department and replace the entire application with a new application.
• 20:16
  SPEAKER_02: You could do that.
• 20:18
  SPEAKER_02: But um, you know, doing just that still is build the entire application and put it in place.
• 20:27
  SPEAKER_02: You're not doing the the upgrade process where you can change features, you can change the the version of.NET, you can change to use an API instead of using the the class library.
• 20:40
  SPEAKER_02: You can't do those things.
• 20:42
  SPEAKER_02: You gotta upgrade the entire thing.
• 20:44
  SPEAKER_02: And that leads to bigger bugs and more bugs and and more cost and risk.
• 20:51
  SPEAKER_02: Okay.
• 20:51
  SPEAKER_02: Another uh cost here is actual cost.
• 20:54
  SPEAKER_02: Okay, your cost in dollars, your cost in time will be higher than expected.
• 21:01
  SPEAKER_02: And you may say, Tim, I'm great at estimates.
• 21:03
  SPEAKER_02: I don't care.
• 21:05
  SPEAKER_02: You're not, you don't understand the future.
• 21:08
  SPEAKER_02: You don't know the future.
• 21:10
  SPEAKER_02: You can't predict the future with any certainty.
• 21:13
  SPEAKER_02: You don't know what bugs are in there, you don't know what hurdles you're gonna have to overcome.
• 21:17
  SPEAKER_02: You don't know what issues will come up.
• 21:20
  SPEAKER_02: The cost will be higher than expected.
• 21:24
  SPEAKER_02: Okay, so I've seen it over and over again people confidently say, well, we've got an extra 30% of buffer here.
• 21:33
  SPEAKER_02: We're we're sure that even with even the unexpected things come up, we have that buffer.
• 21:38
  SPEAKER_02: We have 50% of buffer.
• 21:40
  SPEAKER_02: It almost doesn't matter because it will be higher than expected.
• 21:45
  SPEAKER_02: You will run into problems.
• 21:46
  SPEAKER_02: And unfortunately, developers tend to be optimists.
• 21:54
  SPEAKER_02: They tend to look at a problem and say, I can fix that.
• 21:58
  SPEAKER_02: Um Example of this was when Twitter was having problems and get the switch over to Elon Musk and all those things.
• 22:08
  SPEAKER_02: And people were saying, oh, well, I could rewrite Twitter in a weekend.
• 22:13
  SPEAKER_02: And they were fighting and arguing over, yes, I could.
• 22:17
  SPEAKER_02: It wouldn't be this big of scale as Twitter, but I could definitely rewrite Twitter in a weekend.
• 22:22
  SPEAKER_02: No, no, you couldn't.
• 22:25
  SPEAKER_02: Because it is much more complicated than you think.
• 22:29
  SPEAKER_02: On the surface, it looks super simple.
• 22:31
  SPEAKER_02: Just put 280 characters on a screen, you know, mix those together, you're good to go.
• 22:37
  SPEAKER_02: I saw a flow chart just of how to notify a person of something on Twitter.
• 22:44
  SPEAKER_02: So, you know, if you're tagged on Twitter, if a person likes your post, whatever the thing is, you know, how do you notify a person?
• 22:53
  SPEAKER_02: And the flow chart was about 50 steps long on figuring out if you should notify a person or not.
• 23:02
  SPEAKER_02: Because you might have notifications turned off.
• 23:04
  SPEAKER_02: Okay, well, then don't notify, right?
• 23:06
  SPEAKER_02: Well, yes, but you might have notifications turned off only for a group.
• 23:10
  SPEAKER_02: Well, but what if it's personally tagged to you?
• 23:13
  SPEAKER_02: Well, and there's the list goes on of all the exceptions, all of the times when you should or shouldn't.
• 23:20
  SPEAKER_02: And the waiting of that and figuring that out in the flow chart of that was pretty impressive.
• 23:25
  SPEAKER_02: And that's just for notifications.
• 23:28
  SPEAKER_02: And when you look at a system from the outside, you tend to say, oh, it's just 280 characters in a list, and we just kind of merge them all together from everybody, and we're good to go.
• 23:38
  SPEAKER_02: And it's not that simple.
• 23:40
  SPEAKER_02: In fact, it's much, much more complex than that.
• 23:43
  SPEAKER_02: So when you're looking at your system and you say, oh, it just does X, Y, and Z, you're forgetting about all the edge cases, you're forgetting about all of the institutional knowledge that went into it, and you're forgetting the fact that it took developers years to come to this point.
• 24:03
  SPEAKER_02: And yet you in the hubris have this idea that you could do it in six months or three months or a year.
• 24:11
  SPEAKER_02: Whatever the case.
• 24:13
  SPEAKER_02: If it took developers 10 years to develop to this point, they weren't just slacking off.
• 24:20
  SPEAKER_02: Now, yes, they were upgrading systems, they were improving things, they were taking things out and changing it with something new.
• 24:26
  SPEAKER_02: And so it's not going to be 10 years to replace it, but it will still be a lot of time.
• 24:34
  SPEAKER_02: So the cost in dollars and time will be higher than you expected.
• 24:40
  SPEAKER_02: And then there's also the danger that it will never happen.
• 24:46
  SPEAKER_02: Like I said, it may be that you lose some institutional knowledge and some of that business logic of edge cases where you put it in place and you have all these problems, and so management gets freaked out and just pulls the plug.
• 25:00
  SPEAKER_02: And that could absolutely happen.
• 25:03
  SPEAKER_02: But another thing that can happen is that those cost overruns occur and that time overrun occurs.
• 25:11
  SPEAKER_02: And at some point the business says, we just can't afford to just keep throwing money at this thing.
• 25:17
  SPEAKER_02: I've seen this happen a number of times, where companies invest one, two, even three years into a project and it just never comes to fruition.
• 25:29
  SPEAKER_02: So that's a big danger when you're talking about just replace.
• 25:35
  SPEAKER_02: So there's a lot of dangers when it comes to just replace, but there are some benefits.
• 25:40
  SPEAKER_02: We can't skip over the benefits.
• 25:44
  SPEAKER_02: The first benefit, and we're gonna put some asterisks on this, um, you get a clean code base when you're done.
• 25:50
  SPEAKER_02: So, you know, as you build up your application, you start to have some legacy stuff in there and some things that might not be used anymore and all the rest.NET went through this.
• 26:01
  SPEAKER_02: The.NET framework was pretty bloated.
• 26:04
  SPEAKER_02: And Microsoft said, hey, we're gonna start over, and they did, and we're gonna create.NET Core.
• 26:12
  SPEAKER_02: And so they recame about and looked at how do you make this efficient?
• 26:19
  SPEAKER_02: How do you, you know, lessons learned, how do you make this a clean code base that is more efficient and more effective, and yet still uses the same C sharp code or as much as possible.
• 26:30
  SPEAKER_02: And they came up with a result where the.NET Core code, which is now just.NET, um, is so much faster than.NET framework code.
• 26:42
  SPEAKER_02: It's the same C sharp code itself, but.NET Core executes it so much faster because it's clean.
• 26:49
  SPEAKER_02: It doesn't have all the legacy of, well, if you're on XP, Windows XP and you're you know using a 32-bit op, forget all that.
• 26:57
  SPEAKER_02: It's kind of cleaned out all those exceptions.
• 27:00
  SPEAKER_02: If you're on Internet Explorer, forget that.
• 27:02
  SPEAKER_02: You know, it's kind of cleaned out all this old stuff, this legacy stuff that was kind of patched and fixed and and you know, jury-rigged to get to work, and it does, but it's not as efficient as it could be.
• 27:17
  SPEAKER_02: So you can have a clean code base when you're done.
• 27:20
  SPEAKER_02: Now, I want to stop right there.
• 27:22
  SPEAKER_02: Like I said, asterisk here.
• 27:24
  SPEAKER_02: That's a bold claim.
• 27:27
  SPEAKER_02: You can have a clean code base.
• 27:31
  SPEAKER_02: That does not mean you will.
• 27:33
  SPEAKER_02: Because when you're building an application over again, you start off with the best of intentions.
• 27:39
  SPEAKER_02: I'm gonna do everything perfect.
• 27:41
  SPEAKER_02: I'm gonna have dependency injection, I'm gonna have separation of concerns, I'm gonna follow all of solid.
• 27:47
  SPEAKER_02: I'm going to, and then the reality of the world hits, and you start to have to make things work, and you have to implement a new feature that was implemented in the old system.
• 27:57
  SPEAKER_02: And so now you've got to rip things out and put things back in.
• 28:00
  SPEAKER_02: Before you know it, you still have a bit of a mess, but it's at least in the newer version, right?
• 28:06
  SPEAKER_02: So that's what a clean code base will really look like.
• 28:08
  SPEAKER_02: It won't be perfect, but it'll be better.
• 28:12
  SPEAKER_02: Okay, so that's the first benefit.
• 28:14
  SPEAKER_02: The second benefit is you can have two different teams.
• 28:17
  SPEAKER_02: You can have a maintenance team and a rebuild team.
• 28:19
  SPEAKER_02: And you can have them both work in parallel.
• 28:21
  SPEAKER_02: And so you can say, you know what, we're gonna put two people on maintenance only.
• 28:26
  SPEAKER_02: The people that kind of know the system and know how to keep it working, we're gonna keep communication open so we know when new things happen.
• 28:34
  SPEAKER_02: But we're gonna put six people on the rebuild team.
• 28:37
  SPEAKER_02: And that way we can kind of get that done quickly and get finished and complete and implement all the changes that two people are doing, and then eventually we have that new system only.
• 28:50
  SPEAKER_02: So you can have two different teams working on this.
• 28:54
  SPEAKER_02: You also get to re-choose your architecture.
• 28:57
  SPEAKER_02: Let's say you were really tied into um, I don't know, Microsoft Access.
• 29:05
  SPEAKER_02: I've been there.
• 29:06
  SPEAKER_02: I worked on a system where it was completely tied to not one, but multiple access databases.
• 29:14
  SPEAKER_02: C sharp code, actually, I think it was VB code, but your code tied to an old database structure with multiple databases and messy stuff where the databases have been modified and changed and huge tables with lots of columns and all this stuff.
• 29:29
  SPEAKER_02: And you can say, you know what?
• 29:30
  SPEAKER_02: Let's pause that.
• 29:32
  SPEAKER_02: Let's take a step back and say what's best for our team.
• 29:35
  SPEAKER_02: What's the best architecture look like?
• 29:37
  SPEAKER_02: And maybe it's MongoDB and we have this document structure instead.
• 29:42
  SPEAKER_02: Or maybe we use Microsoft SQL and we move to that and have a different database schema and we optimize that.
• 29:50
  SPEAKER_02: And you know, you get to re-chose your architecture.
• 29:52
  SPEAKER_02: Maybe you say, you know what, we're gonna prepare for Azure or move to Azure right away so that we have this scalable architecture instead of this limited on-site-only architecture.
• 30:04
  SPEAKER_02: And you can get to re choose, and that's a big benefit of just completely restarting your application.
• 30:12
  SPEAKER_02: So this is the time when you get to choose.
• 30:19
  SPEAKER_02: Do I upgrade or do I rebuild?
• 30:23
  SPEAKER_02: And hopefully you've seen there's costs and benefits to both.
• 30:29
  SPEAKER_02: But at the end of the day, I start from upgrade.
• 30:35
  SPEAKER_02: That's what that's the starting point.
• 30:37
  SPEAKER_02: So when I come into a meeting where that's what we're gonna decide, or we're gonna start working on, is how do we move forward?
• 30:44
  SPEAKER_02: I always start from the default of upgrade.
• 30:48
  SPEAKER_02: Because you get to upgrade in place, you get to see your changes happen as they as they are done.
• 30:54
  SPEAKER_02: You get to you know keep some of that logic in place so you don't have those bugs.
• 30:58
  SPEAKER_02: There's smaller changes over time, and all this good stuff that comes with it, even though there's a lot of pain that comes with it.
• 31:05
  SPEAKER_02: But just because I default to that does not mean I only do that.
• 31:12
  SPEAKER_02: There have been times where I've come in, I've looked at the situation, I go, you know what?
• 31:17
  SPEAKER_02: You need to do a restart.
• 31:20
  SPEAKER_02: You need to rebuild.
• 31:22
  SPEAKER_02: And there's things you can do and tricks you can do to try and have both systems work at the same time.
• 31:28
  SPEAKER_02: But at the end of the day, you need to rebuild your system because it's just too far gone, or it's just too difficult to work with, and there's not enough institutional knowledge to make sure we get it right.
• 31:41
  SPEAKER_02: So there are times when a total scrap it and start over makes sense.
• 31:46
  SPEAKER_02: Like I said, Microsoft decided that the scrap it and start over method was what was best for.NET.
• 31:55
  SPEAKER_02: And that's why they built.NET Core while still upgrading.NET Framework.
• 32:03
  SPEAKER_02: And they kind of have a period of time where.NET Core was being improved and features are being added to it at the same time as.NET Framework was having features added to it and being the primary thing used in production.
• 32:17
  SPEAKER_02: So they kind of ramped it up and then they stopped.NET Framework at a point once.NET Core was complete enough to be a replacement.
• 32:28
  SPEAKER_02: So it there are times when it is the right choice.
• 32:31
  SPEAKER_02: And I think that was the right choice for Microsoft.
• 32:34
  SPEAKER_02: But just because there are times does not mean it's the primary thing you should do.
• 32:40
  SPEAKER_02: Instead, I would again default to upgrade your systems and plan for that and plan that journey so that you can keep your management happy, you can keep your business moving forward, you can not have that big leap off a cliff moment where you put it in, hope things work.
• 32:59
  SPEAKER_02: That's just not a good place to be.
• 33:01
  SPEAKER_02: So there's a lot of benefits to upgrading your system, even if it does mean you have older technology in place, you keep some of that spaghetti logic, you have to deal with some bad architecture, and you know it's gonna take you a long time to kind of cleanse the system of those old processes and ways of doing things.
• 33:23
  SPEAKER_02: So that's my advice.
• 33:25
  SPEAKER_02: Um, I would encourage you to look at your situation as unique and evaluate it honestly.
• 33:32
  SPEAKER_02: Just be careful that you don't use a bad estimate as your basis for moving forward.
• 33:41
  SPEAKER_02: Don't just say, oh, well, it's gonna take us six months to rebuild, so let's do that.
• 33:44
  SPEAKER_02: Because it will not take you six months.
• 33:46
  SPEAKER_02: Okay, so don't use a bad estimate as your foundation for the reasoning behind making the replace choice over the upgrade choice.
• 33:57
  SPEAKER_02: All right, thanks for listening, and as always, I am Tim Corey.
• 34:01
  SPEAKER_00: Thank you for joining us for this episode of DevQuestions.
• 34:04
  SPEAKER_00: Tim is committed to making it easier for you to become a developer.
• 34:07
  SPEAKER_00: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 34:14
  SPEAKER_00: You can also send your questions to questions at Iamtimcore.com.
• 34:20
  SPEAKER_00: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 34:27
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.