Latest / DevQuestions with Tim Corey / 105 How Do I Understand a Complex Codebase At Work?

Transcript

105 How Do I Understand a Complex Codebase At Work? · 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:25
  SPEAKER_02: How do you understand the complex code base at work?
• 0:29
  SPEAKER_02: Maybe you start a new job and you're just trying to figure out what all this code does?
• 0:34
  SPEAKER_02: How does it work?
• 0:36
  SPEAKER_02: What are these different modules?
• 0:37
  SPEAKER_02: How are they bringing being brought into the code?
• 0:40
  SPEAKER_02: How does it interact?
• 0:42
  SPEAKER_02: How does it work at all?
• 0:44
  SPEAKER_02: And this is very difficult because of the fact that you can't go to Google and say, how does my custom code at my employer work?
• 0:51
  SPEAKER_02: Because it's not on Google.
• 0:53
  SPEAKER_02: So let's talk this through in today's episode of DevQuestions.
• 0:57
  SPEAKER_02: Now, this question was asked on a suggestion site.
• 1:00
  SPEAKER_02: And if you have questions that you'd like to see answered on a future episode of DevQuestions, go to suggestions.imtimcorey.com and ask your question there.
• 1:09
  SPEAKER_02: So let's talk about integrating into a new code base, understanding it, learning it, figure out what it does and how to start working on it.
• 1:18
  SPEAKER_02: Now, I think there's three initial steps that you need to go through.
• 1:23
  SPEAKER_02: Now the first one is read the documentation.
• 1:27
  SPEAKER_02: If there's documentation, read it through.
• 1:30
  SPEAKER_02: Try to understand what it's talking about, figure out what parts are useful, because maybe not all documentation is useful, but try and figure out what's useful to you and understand it as best you can.
• 1:43
  SPEAKER_02: Number two, talk to the existing users.
• 1:46
  SPEAKER_02: What I recommend doing is every time you're not sure, go ask a senior developer, but take with you a notepad.
• 1:56
  SPEAKER_02: Write down what they say.
• 1:58
  SPEAKER_02: Try to make sure they understand that you're not going to just use them as your Google, that you are trying to learn once from them on each topic.
• 2:08
  SPEAKER_02: Because usually people don't have a problem with you learning from them.
• 2:13
  SPEAKER_02: They want to make sure you're up to speed, they want to help you.
• 2:17
  SPEAKER_02: Where the frustration comes in is when you keep coming back with the same question.
• 2:24
  SPEAKER_02: So if you take notes, if you write it down, if you document what you have learned, so you can go back to the document instead of to them, that will definitely increase your ability to use them as a resource because they'll see that you are wanting to learn and grow.
• 2:44
  SPEAKER_02: And the number three place to look is unit tests.
• 2:48
  SPEAKER_02: Look for unit tests in the project and see if they exist.
• 2:52
  SPEAKER_02: And if they do, what do they test?
• 2:55
  SPEAKER_02: Because those tests will tell you how specific methods are supposed to work.
• 3:01
  SPEAKER_02: So you'll see what the inputs and outputs should be based upon expectations, and then what they shouldn't be based upon what the rules are testing to make sure doesn't happen.
• 3:13
  SPEAKER_02: Now, it's at this point that you're probably thinking, Tim, I have zero for three.
• 3:18
  SPEAKER_02: There is nobody in the previous position, there is no documentation, and I have, of course, no unit tests.
• 3:25
  SPEAKER_02: So what do I do?
• 3:27
  SPEAKER_02: Because none of these exist, and this is not an uncommon situation.
• 3:32
  SPEAKER_02: Maybe it's a little bit uncommon to walk into a code base with no previous developers, but it does happen.
• 3:38
  SPEAKER_02: But a lot of times there is no documentation, there are no unit tests.
• 3:43
  SPEAKER_02: So at that point, you're reliant entirely on the people that came before, and maybe they're grumpy and don't want to talk to you.
• 3:50
  SPEAKER_02: So now you're still over three when it comes to learning this new code.
• 3:55
  SPEAKER_02: So what do you do?
• 3:57
  SPEAKER_02: Well, I have four self-discovery tips that I hope will help you.
• 4:01
  SPEAKER_02: So the first one is make sure that you have a development environment first.
• 4:07
  SPEAKER_02: Don't do this in production.
• 4:09
  SPEAKER_02: Okay.
• 4:10
  SPEAKER_02: But make sure you have a development environment.
• 4:11
  SPEAKER_02: If you don't, talk to your boss and say, listen, I'm new.
• 4:15
  SPEAKER_02: I'm trying to learn, I'm gonna mess things up.
• 4:20
  SPEAKER_02: You don't want that in production, right?
• 4:22
  SPEAKER_02: So help me help you.
• 4:24
  SPEAKER_02: So let's set up something where I can test things without breaking real things.
• 4:30
  SPEAKER_02: So get some type of development environment set up, hopefully on your machine or something local, where you can break it and not affect others.
• 4:38
  SPEAKER_02: And then practice.
• 4:39
  SPEAKER_02: Try things out, see what happens when you make changes.
• 4:42
  SPEAKER_02: Just try it and see if things work or they don't work and why they work or don't work.
• 4:49
  SPEAKER_02: So that's number one, get a practice environment and then practice.
• 4:53
  SPEAKER_02: Number two, step through the code.
• 4:56
  SPEAKER_02: If you're not familiar with how to do this, use breakpoints.
• 5:00
  SPEAKER_02: So wherever you want to try to figure out what the flow is for something, start at the very put a breakpoint at the very beginning where you think it starts, and then execute that step and see if the code breaks.
• 5:13
  SPEAKER_02: And if it doesn't, you know that you have a bad assumption about where even the code started.
• 5:17
  SPEAKER_02: But then once you get the right spot, you put the breakpoint, step through the code.
• 5:23
  SPEAKER_02: Go step by step by step.
• 5:25
  SPEAKER_02: Yes, it can be a long process, but understanding what each step does, inspect the variables, inspect how things change, and take notes and track down what's going on with this code.
• 5:38
  SPEAKER_02: How is this flow through the application?
• 5:41
  SPEAKER_02: What are the things it looks through?
• 5:43
  SPEAKER_02: How does it evaluate and understand how this code works?
• 5:49
  SPEAKER_02: So stepping through the code will really help you because that's the at the end of the day, that's what your code is doing at a much faster pace.
• 5:57
  SPEAKER_02: So if you understand that flow, then you'll understand what your code is doing.
• 6:02
  SPEAKER_02: So that's number two.
• 6:04
  SPEAKER_02: Number one is practice in a development environment.
• 6:07
  SPEAKER_02: Number two is step through the code using breakpoints and other tools to help you understand that flow of the code.
• 6:15
  SPEAKER_02: Number three, write unit tests.
• 6:18
  SPEAKER_02: If you don't have any unit tests, start writing them.
• 6:21
  SPEAKER_02: Not just because you need to have unit tests.
• 6:25
  SPEAKER_02: Not because you think that you know test-driven development is the only way to go and you must have them.
• 6:32
  SPEAKER_02: Don't be obstinate about this.
• 6:33
  SPEAKER_02: But instead, use unit tests as your learning process.
• 6:38
  SPEAKER_02: Create little tests and have them test a specific method for inputs and outputs.
• 6:46
  SPEAKER_02: Make sure that the method does what you expect it to do by creating a unit test that tries it out.
• 6:53
  SPEAKER_02: And then if it doesn't do what's expected, figure out why and if it's the unit test that's wrong or if it's the code that's wrong.
• 7:01
  SPEAKER_02: But start writing these unit tests to start practicing your understanding of the code.
• 7:07
  SPEAKER_02: This will do two things.
• 7:09
  SPEAKER_02: One, it will help get you used to the code.
• 7:11
  SPEAKER_02: But two, it will also create a system that'll make it easier to make changes to the code because when you change code that's under unit tests, the unit tests that we're working may break.
• 7:23
  SPEAKER_02: And if they do, you realize that the changes you made have fundamentally changed how the methods work, which is probably not what was intended.
• 7:33
  SPEAKER_02: So by having these unit tests in place, you're more likely to be able to change things with less fear.
• 7:39
  SPEAKER_02: So it really helps you in a couple of different ways to create unit tests.
• 7:44
  SPEAKER_02: So that's number three.
• 7:46
  SPEAKER_02: And number four is document everything you learn.
• 7:51
  SPEAKER_02: Even if you had documentation to begin with, even if you had coworkers that were willing to help you out, even if you had existing unit tests, still document what you learn.
• 8:03
  SPEAKER_02: Either way, it will be helpful for you, and it will be helpful for the next person.
• 8:08
  SPEAKER_02: Maybe they had documentation, but it's kind of out of date, which happens.
• 8:13
  SPEAKER_02: Improve it.
• 8:14
  SPEAKER_02: Make changes.
• 8:16
  SPEAKER_02: Make sure that you put the latest information in your documentation and share it with everybody.
• 8:22
  SPEAKER_02: Then if someone reads over and says, I don't think that's how it's supposed to be, then you can grow together.
• 8:29
  SPEAKER_02: Either they can say, Oh no, you're right, and they can understand better, or they can help you with an assumption that you had that was incorrect.
• 8:39
  SPEAKER_02: So even if you don't have anybody there to help you, there are steps you can take to learn and grow in a code base to better understand it.
• 8:48
  SPEAKER_02: Now I know that some of this is gonna seem like it's unattainable because of how long it might take.
• 8:55
  SPEAKER_02: You might say, Tim, I just don't have the time to do that when I'm trying to get up to speed and fix problems.
• 9:02
  SPEAKER_02: But you can do some of this while you're doing that.
• 9:05
  SPEAKER_02: When you go to fix a problem, write a unit test for it.
• 9:09
  SPEAKER_02: When you are trying to track something down, document what you learn trying to track it down.
• 9:14
  SPEAKER_02: So there's things you can do along the way that will help your overall goal of understanding the system better and helping others, including the person that comes behind you.
• 9:25
  SPEAKER_02: Because at some point, you'll be the person that knows a lot about your code base, and they'll be the new person that doesn't understand and needs help.
• 9:34
  SPEAKER_02: If you can give them this information, you can make it easier for them, and you can reduce the amount of work it takes to get them up to speed, which means you can reduce the amount of time it takes before you get help in your day-to-day job.
• 9:49
  SPEAKER_02: So it's really a win-win-win all around for everyone involved.
• 9:54
  SPEAKER_02: So those are the steps that I recommend for coming into a new code base, trying to learn it and understand it, and grow into it.
• 10:02
  SPEAKER_02: I hope that was helpful.
• 10:04
  SPEAKER_02: If you have a question, again, go to suggestions.com and post your suggestion there or upvote an existing suggestion, and hopefully you'll see your question answered here on DevQuestions in the future.
• 10:17
  SPEAKER_02: Thanks for listening.
• 10:18
  SPEAKER_02: As always, I am Tim Corey.
• 10:20
  SPEAKER_01: Thank you for joining us for this episode of Dev Questions.
• 10:23
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 10:27
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 10:34
  SPEAKER_01: You can also send your questions to questions at IamtimCore.com.
• 10:39
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 10:46
  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.