Latest / DevQuestions with Tim Corey / 150 How Do I Approach Rewriting an Old Codebase?

Transcript

150 How Do I Approach Rewriting an Old Codebase? · 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_02: How do I approach rewriting an old code base?
• 0:28
  SPEAKER_02: This is a question that really intrigued me because I've answered it kind of before, and I want to make sure that I address the other side of it, which is how do you when you have no other option?
• 0:39
  SPEAKER_02: So let's talk about how do you rewrite an old code base when you just have no other choice.
• 0:45
  SPEAKER_02: That's today's topic for this DevQuestion series.
• 0:48
  SPEAKER_02: If you have a question, go to suggestions.imtimcorey.com and ask it there.
• 0:53
  SPEAKER_02: Hopefully you'll see or hear your question answered in a future episode of DevQuesti.
• 0:58
  SPEAKER_02: Okay, so my number one answer always when someone says, How do I rewrite an application is don't.
• 1:06
  SPEAKER_02: If you can help it, don't.
• 1:08
  SPEAKER_02: Because it's much better to try and upgrade an application than it is to rewrite the entire thing.
• 1:14
  SPEAKER_02: But let's talk about why.
• 1:16
  SPEAKER_02: Because if you if you say, hey, you know what, I can get rid of all these old problems by just rewriting it.
• 1:24
  SPEAKER_02: Kinda, but you're also getting rid of all the lessons learned.
• 1:28
  SPEAKER_02: There are years and years of lessons learned, years and years of code fixes and bug fixes and logic fixes that you may not know about that are under the surface of that application.
• 1:41
  SPEAKER_02: You may look at the UI and say, okay, I put this much data in, I get this much data out.
• 1:46
  SPEAKER_02: How hard can it be?
• 1:48
  SPEAKER_02: But there's usually more to it than just that.
• 1:51
  SPEAKER_02: So when you rewrite an application, you often lose a lot of the positive history on how your code should really work.
• 2:00
  SPEAKER_02: And what happens is you start to repeat the same problems you had earlier.
• 2:05
  SPEAKER_02: So that's why I avoid a total rewrite and encourage instead an upgrade process, if at all possible.
• 2:12
  SPEAKER_02: However, sometimes you just can't help it.
• 2:15
  SPEAKER_02: For instance, in this particular case, the person said, Hey, I know the upgrades are the better way of going, but I've got a.NET framework project that uses web forms, and it's not even well written.
• 2:27
  SPEAKER_02: And it's got problems that I just can't ignore.
• 2:32
  SPEAKER_02: I have to address.
• 2:33
  SPEAKER_02: I have to redo how this thing does what it does anyway.
• 2:37
  SPEAKER_02: And so I need to upgrade it as well.
• 2:40
  SPEAKER_02: It's probably the best to just rewrite the application.
• 2:43
  SPEAKER_02: So, you know, what do you do in that case?
• 2:46
  SPEAKER_02: How do you go about rewriting your application?
• 2:50
  SPEAKER_02: The first step is start small.
• 2:54
  SPEAKER_02: Don't try to just redo everything all at once.
• 2:57
  SPEAKER_02: That's kind of the waterfall technique of we've got this plan for the whole thing, we're gonna build the whole thing and then we're gonna release the whole thing all at once.
• 3:05
  SPEAKER_02: And that is a hard thing to get right.
• 3:08
  SPEAKER_02: So start small, do a little piece.
• 3:11
  SPEAKER_02: If it's a web application, which this one was, it that's a great opportunity to redo one page or one feature in a new site.
• 3:20
  SPEAKER_02: Being able to say, okay, yes, it's a different URL, or maybe use DNS to kind of redirect and move things around.
• 3:27
  SPEAKER_02: But you know, we're gonna kind of mix and yeah, it's gonna get a little bumpy, but in the end of the day, we're gonna have the ability to slowly move features over.
• 3:37
  SPEAKER_02: YouTube did this recently when they upgraded how their back-end system worked for content creators.
• 3:45
  SPEAKER_02: So I spent a lot of time in the back end of the YouTube's content creation system.
• 3:51
  SPEAKER_02: So things like moderating comments and tracking my videos and uploading new videos and setting their, you know, from private to you know, uh public or scheduled or all the rest, all that stuff that you do behind the scenes on YouTube.
• 4:07
  SPEAKER_02: Well, that interface has radically changed in the past few years.
• 4:11
  SPEAKER_02: But it didn't happen overnight.
• 4:14
  SPEAKER_02: Instead, we were notified, hey, there's a new YouTube interface.
• 4:17
  SPEAKER_02: Do you want to try it?
• 4:18
  SPEAKER_02: And so I tried it and it would have some of what I wanted, but it lost some of the things that I needed.
• 4:26
  SPEAKER_02: And so I'd bounce back and forth, the new user interface for most of my stuff, but they're still missing these things.
• 4:32
  SPEAKER_02: And eventually they moved all the things, or not all, but a lot of the things over into the new interface and said, okay, we're done.
• 4:40
  SPEAKER_02: The old system goes away now, it's just the new system.
• 4:43
  SPEAKER_02: So you can do that if you start small and slowly migrate things over.
• 4:48
  SPEAKER_02: Now, that does mean that if at all possible, and this is point number two, try to reuse the same database.
• 4:57
  SPEAKER_02: Meaning, try not to restructure all your apps so that the data goes in different places and it's just messy.
• 5:05
  SPEAKER_02: Because then what happens is you've got to have some kind of synchronization system between the two systems for the data.
• 5:11
  SPEAKER_02: That gets a lot harder to do right.
• 5:13
  SPEAKER_02: So if you can help it, use the same database so that when your new UI makes a change to the data, it's the same data that the old UI sees, therefore the old UI has those updated pieces of data.
• 5:27
  SPEAKER_02: So if you can do that, that's great.
• 5:29
  SPEAKER_02: It may require you to write an interface layer between your new system and the database.
• 5:35
  SPEAKER_02: And that can be okay, where you say, hey, you know what, this is the new structure, but we're gonna translate it through an interface layer to the old database this way.
• 5:45
  SPEAKER_02: And when we're done, we can upgrade the database to the new way of doing things and take the translation layer out.
• 5:52
  SPEAKER_02: That can be possible too, but try and reuse that same database.
• 5:56
  SPEAKER_02: And that leads right into point number three is try not to change everything.
• 6:03
  SPEAKER_02: This is hard to do because when you look at all the problems, say I can fix this, I can fix this, I can fix this.
• 6:10
  SPEAKER_02: You know what?
• 6:10
  SPEAKER_02: We've got a.NET framework web forms project.
• 6:13
  SPEAKER_02: We're gonna make it a desktop application with also.NET Maui and mobile interfaces, we're gonna use microservices and we're gonna put it in the cloud.
• 6:22
  SPEAKER_02: We're gonna, wow, that's a lot of changes.
• 6:26
  SPEAKER_02: And so when it comes to trying to make sure all those changes work and make sure that it does the same thing the same way, and that gets hard to do.
• 6:34
  SPEAKER_02: Instead, try to change as little as possible.
• 6:38
  SPEAKER_02: In this case, you're gonna have to change the UI from web forms to something else.
• 6:42
  SPEAKER_02: Probably a Blazor product, WebAssembly or server, or the upcoming hybrid way of doing things.
• 6:49
  SPEAKER_02: But um, whatever you're gonna do, you're gonna have to have a different UI.
• 6:53
  SPEAKER_02: But try and keep as much of the logic the same way and the same type of system, the same database and the same structure and maybe even the same locations.
• 7:02
  SPEAKER_02: Because the less you change, the less you have to debug.
• 7:08
  SPEAKER_02: And it's the more you have the similar, the easier to compare the old system to the new system.
• 7:14
  SPEAKER_02: If the old system is one page where you enter one set of information and it goes to the database, and the new system is five different pages that use three different microservices that asynchronously put stuff in the database eventually, well, how do you compare apples to apples to make sure that you're doing the same thing in the new system that you did in the old systems, accomplish the same end goal?
• 7:36
  SPEAKER_02: It's hard.
• 7:37
  SPEAKER_02: But if you have one page over here and one page over here and they both do a similar thing, maybe different UI, maybe different processes a little bit, but a similar thing, it's a lot easier to make sure that when you do your checks to say, yes, the new system is working the way we expect.
• 7:56
  SPEAKER_02: So try not to change everything.
• 7:58
  SPEAKER_02: Now it does mean that if you write things modularly, that once you have the new system fully online, then you can start changing things.
• 8:07
  SPEAKER_02: You could start redoing things if you've thought ahead and said, hey, I want to architect this in a way that is modular so that we could have a.NET Maui app.
• 8:17
  SPEAKER_02: So you could break off microservices, so you could rearrange this and put this in Azure and so many other things.
• 8:23
  SPEAKER_02: But don't do it yet.
• 8:25
  SPEAKER_02: That's my my recommendation.
• 8:27
  SPEAKER_02: Number four, review the help tickets and past commits.
• 8:32
  SPEAKER_02: So look at the past.
• 8:34
  SPEAKER_02: Look at why things changed.
• 8:36
  SPEAKER_02: If you were modifying a specific page, look at the Git history and say, hey, how has this page changed and why?
• 8:44
  SPEAKER_02: Hopefully you've written good commit messages that don't just say, may it change, may it change.
• 8:51
  SPEAKER_02: Hopefully you said why you made a change, what the bug fix was, linked to an issue, and so many other things.
• 8:57
  SPEAKER_02: But being able to track through the changes and understand why something changed will help you understand is this the can I change this in some way, the new way?
• 9:09
  SPEAKER_02: Can I change it in a way that makes more sense now?
• 9:12
  SPEAKER_02: Or am I going to repeat history and this thing over here, the thing we fixed, was because we did it that way originally and that wasn't right and that caused this problem.
• 9:23
  SPEAKER_02: So learn from history.
• 9:26
  SPEAKER_02: People who don't learn from history are bound to repeat it.
• 9:29
  SPEAKER_02: So learn from your past history of help tickets, past history of commits.
• 9:33
  SPEAKER_02: Try to figure out why your system evolved over time the way it did.
• 9:37
  SPEAKER_02: Now, some things are going to be because we got new interfaces, because we got new software ability, because we, you know, we want these new ways of doing the processes and our business changed.
• 9:48
  SPEAKER_02: And those things, you know, they are what they are.
• 9:51
  SPEAKER_02: And yeah, your business changes, and that's not really a history you need to necessarily learn from.
• 9:56
  SPEAKER_02: But when it's because the system broke, because the logic wasn't right for your business, that's what you need to learn from.
• 10:03
  SPEAKER_02: And then finally, number five, you need to interview users.
• 10:09
  SPEAKER_02: Find out from the people who actually use the software what their thoughts are, how it works, why it works, what problems there are, and how you might be able to, without making tons of changes, be able to alleviate some of those problems.
• 10:26
  SPEAKER_02: Maybe the system doesn't work right now.
• 10:29
  SPEAKER_02: Maybe there's a big bug in here where it they make it work, but it's really broken right now, and you can fix that in your new design.
• 10:38
  SPEAKER_02: Again, trying to change as little as possible, but you don't want to replicate a broken system.
• 10:43
  SPEAKER_02: So the key here though is to talk to the real users.
• 10:47
  SPEAKER_02: Too many times, as a consultant, I've come in and said, okay, I need to interview the users.
• 10:53
  SPEAKER_02: And who they sit me down with are the managers.
• 10:56
  SPEAKER_02: That is not the user.
• 10:58
  SPEAKER_02: The manager is not the person who knows the most.
• 11:02
  SPEAKER_02: In fact, they often know the least.
• 11:05
  SPEAKER_02: They can tell you overall what the department does, how it operates, what the goals are, what they do as far as processing.
• 11:14
  SPEAKER_02: But when it comes to the actual day-to-day, how things work, how the system works, how the system operates or doesn't operate, the people who actually put data into the system, typically the lowest people on a totem pole, they're the people that are most likely the people that are going to know the most about the system and how it really should work and does work.
• 11:37
  SPEAKER_02: So talk to those people, get to understand the system really well.
• 11:41
  SPEAKER_02: Try and get as much institutional knowledge in your head before you even start this process.
• 11:47
  SPEAKER_02: And then make sure you keep going back to that to make sure that you are following through and making sure you create a system that really does replicate as much as possible of what the system should do while at the same time avoiding all the pitfalls that is currently doing that you don't want to do in the new system.
• 12:05
  SPEAKER_02: Okay?
• 12:06
  SPEAKER_02: So again, if you can avoid it, avoid it.
• 12:09
  SPEAKER_02: Try and just upgrade and then change over time.
• 12:12
  SPEAKER_02: But if you really have to redo, start small, reuse the same database, try not to change everything, review their old the past, and then also interview the current users to figure out how the system works now.
• 12:27
  SPEAKER_02: All right, that's my recommendation for up or replacing an old system with a new system.
• 12:33
  SPEAKER_02: Thanks for the question.
• 12:34
  SPEAKER_02: Thanks for listening, and as always, I am Tim Corey.
• 12:37
  SPEAKER_01: Thank you for joining us for this episode of Dev Questions.
• 12:40
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 12:43
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 12:51
  SPEAKER_01: You can also send your questions to questions at IamTimcorey.com.
• 12:56
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 13:03
  SPEAKER_01: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.