Latest / DevQuestions with Tim Corey / 178 What Are The Steps To Quickly Debugging An Application?

Transcript

178 What Are The Steps To Quickly Debugging An Application? · 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_00: What are the steps to quickly debugging an application?
• 0:29
  SPEAKER_00: This is a question asked on the suggestion site, and it's one I thought would be a great question to answer in today's episode of DevQuestions.
• 0:37
  SPEAKER_00: Now, every bug is a learning opportunity.
• 0:42
  SPEAKER_00: So let's start here.
• 0:44
  SPEAKER_00: Don't waste it.
• 0:45
  SPEAKER_00: Don't waste the opportunity to learn something from this bug.
• 0:51
  SPEAKER_00: So trying to escape early, trying to just get somebody else to fix it for you.
• 0:57
  SPEAKER_00: These are ways to keep your growth stunted as a developer.
• 1:01
  SPEAKER_00: The way to grow as a developer is to learn how to debug by working through the tough stuff.
• 1:09
  SPEAKER_00: If you always try to escape the tough stuff, you'll never be strong enough to stay on your own.
• 1:15
  SPEAKER_00: So you want to make sure that you work this list in order.
• 1:20
  SPEAKER_00: Okay?
• 1:21
  SPEAKER_00: So don't just waste the debugging and stunt your growth.
• 1:25
  SPEAKER_00: Instead, I'm gonna go over the six steps you should take to quickly debug an application.
• 1:31
  SPEAKER_00: If you do them in order, you'll have a lot of success and you'll note that getting help doesn't come in till the end.
• 1:39
  SPEAKER_00: Okay, there's lots of things that you can do regardless of your skill level.
• 1:45
  SPEAKER_00: There's lots of things you can do to learn how to debug earlier and more quickly.
• 1:52
  SPEAKER_00: Okay?
• 1:53
  SPEAKER_00: So you're gonna struggle through this.
• 1:55
  SPEAKER_00: This is going to be a struggle.
• 1:58
  SPEAKER_00: It almost always is a debugging.
• 2:00
  SPEAKER_00: Debugging is just, it's one of the things that developers have to do.
• 2:04
  SPEAKER_00: It's the thing that I struggle with because you're always gonna have these weird bugs that you don't understand, you don't know why they're working the way they are.
• 2:12
  SPEAKER_00: And it seems like you know, you never get simple bugs.
• 2:15
  SPEAKER_00: It's gonna happen, and what's gonna happen is you're gonna figure out how to solve those, and then that will become a simple bug after a few times.
• 2:24
  SPEAKER_00: And so you never have that again because you've learned how to avoid it in the first place.
• 2:29
  SPEAKER_00: You've become a better developer.
• 2:30
  SPEAKER_00: Okay?
• 2:31
  SPEAKER_00: So work these steps and don't skip steps.
• 2:36
  SPEAKER_00: Okay.
• 2:37
  SPEAKER_00: The only time you ever skip a step is if you solve the problem.
• 2:40
  SPEAKER_00: Okay.
• 2:41
  SPEAKER_00: If you get through step one and you solve the problem, cool.
• 2:44
  SPEAKER_00: No need to move on to the next step.
• 2:45
  SPEAKER_00: Okay.
• 2:46
  SPEAKER_00: But otherwise, go through these one by one.
• 2:50
  SPEAKER_00: This will also help you, by the way, when you get to the point of asking questions, you will have the right information to give somebody to make them not upset at you, to give them something that shows that you have put the work in yourself.
• 3:04
  SPEAKER_00: Okay, number one, and here's where a lot of newer developers, especially, fall down.
• 3:10
  SPEAKER_00: They fail this step and then try to go on a step two.
• 3:13
  SPEAKER_00: So don't miss this.
• 3:15
  SPEAKER_00: Step number one, clearly identify the issue.
• 3:20
  SPEAKER_00: Don't just start trying to fix it.
• 3:23
  SPEAKER_00: Identify what the problem is first.
• 3:27
  SPEAKER_00: Okay?
• 3:28
  SPEAKER_00: That means that when your system pops up an error message, don't just go, oh no, I got an error message, close it out, and say, now what?
• 3:37
  SPEAKER_00: You've you've missed part of the first step, which is to read the error message.
• 3:45
  SPEAKER_00: The error messages today actually tell you, in a lot of cases, they tell you what the problem is.
• 3:53
  SPEAKER_00: Maybe not the root problem, but they tell you what their problem is.
• 3:59
  SPEAKER_00: Things like uh we have a type mismatch, or we um have you know bad data, invalid data, or whatever the case may be, they tell you some type of message that gives you a clue as to what is going on.
• 4:15
  SPEAKER_00: So clearly identify the issue.
• 4:18
  SPEAKER_00: Read the error message, write it down, not paraphrase, get the actual message.
• 4:26
  SPEAKER_00: That way, if you do end up Googling, we'll get to that later, but if you Google it, well, then you have the actual error message to put in there.
• 4:34
  SPEAKER_00: So you get an actual result, not you know, no results because it's not the actual error message, it's just an approximation of the error message.
• 4:43
  SPEAKER_00: Um, reading log statements.
• 4:45
  SPEAKER_00: If you have logging going on, and hopefully you do, then read the logs, see what happened.
• 4:49
  SPEAKER_00: Watch what happened up to that point, see what was going on, identify the state of the application.
• 4:58
  SPEAKER_00: So, for instance, if you can, if you know where the error is, put a breakpoint there and then run the application again.
• 5:05
  SPEAKER_00: And when it stops at that breakpoint, you hopefully know that the error is coming next.
• 5:11
  SPEAKER_00: Before you get to that error, look at what are the variables holding, what information do they have, what data is in memory, what's it working with and working on to understand what was the state of the application when it broke?
• 5:28
  SPEAKER_00: And then identify which action triggers the issue.
• 5:33
  SPEAKER_00: So is it certain input, is it certain time, etc.
• 5:37
  SPEAKER_00: Okay?
• 5:38
  SPEAKER_00: So try and figure out what's causing this, what the actual issue is, where the issue is, you know, anything else you can find about the system, the state of it at the time.
• 5:50
  SPEAKER_00: Now, that's step number one.
• 5:52
  SPEAKER_00: And again, you may find the issue at that point.
• 5:56
  SPEAKER_00: Okay.
• 5:57
  SPEAKER_00: But if not, then number two, recreate the issue reliably.
• 6:02
  SPEAKER_00: So this is where you might say, okay, it looks like whenever I try to insert data into this table, the application crashes.
• 6:11
  SPEAKER_00: So create a little test application.
• 6:14
  SPEAKER_00: The only thing it does is inserts data into your database, wherever the problem was, and see if it crashes too.
• 6:23
  SPEAKER_00: And if it does, you have a simple recreation of your application.
• 6:28
  SPEAKER_00: Not all the bells and whistles, not all the proprietary stuff, not all of the stuff that shouldn't matter, just the actual thing that causes the problem.
• 6:38
  SPEAKER_00: Try and recreate reliably.
• 6:40
  SPEAKER_00: So set up a test environment.
• 6:42
  SPEAKER_00: Verify the error occurs in that environment.
• 6:46
  SPEAKER_00: Because if you know where the error is and you know what's going on at the time of the error, you should be able to recreate it in another environment, in a clean project.
• 6:56
  SPEAKER_00: And if not, well, then you're missing some kind of context.
• 7:01
  SPEAKER_00: Like, is it that machine?
• 7:03
  SPEAKER_00: Is it some kind of configuration on that computer?
• 7:06
  SPEAKER_00: Is there something I'm assuming that's not the case?
• 7:10
  SPEAKER_00: Like, for example, maybe you're assuming you have a connection to the SQL Server and it accidentally has a connection to the MySQL Server.
• 7:17
  SPEAKER_00: And that's different.
• 7:19
  SPEAKER_00: Maybe that's it.
• 7:20
  SPEAKER_00: Okay?
• 7:21
  SPEAKER_00: So try to recreate in a test environment.
• 7:25
  SPEAKER_00: And that's going to help you down the road when it comes to talking to people as well.
• 7:29
  SPEAKER_00: At least now you have an example of the problem.
• 7:32
  SPEAKER_00: Now, once you have an example of the problem, or if not, once you're figuring out how to recreate in the actual environment that crashes, step through the code to observe the issue.
• 7:45
  SPEAKER_00: This is where you can use breakpoints or advanced breakpoints.
• 7:49
  SPEAKER_00: For example, a breakpoint just pauses your code at a certain spot.
• 7:53
  SPEAKER_00: An advanced breakpoint might just count how many times the breakpoint gets hit.
• 7:58
  SPEAKER_00: So we can say, hey, I've got this loop.
• 8:00
  SPEAKER_00: How many times does it get hit?
• 8:02
  SPEAKER_00: I'm expecting 100.
• 8:04
  SPEAKER_00: And then you put a breakpoint after the loop and count the previous breakpoint and says 10,000.
• 8:09
  SPEAKER_00: And you're like, ah, that's not right.
• 8:11
  SPEAKER_00: Or it might say two and go, ah, that's not right.
• 8:14
  SPEAKER_00: So now you use advanced breakpoints to give you more information.
• 8:17
  SPEAKER_00: Use debugging log statements.
• 8:19
  SPEAKER_00: So you can put debugging statements in your code to say this method was hit, this method was hit, this method was hit, and go on down a list.
• 8:27
  SPEAKER_00: Or say, hey, here's a data at this spot, here's the data at this spot, and get more information about every step along the way where you may find, hey, wait, we're missing a method call in here.
• 8:37
  SPEAKER_00: That method never got called, or this method got called, but then it short-circuited the process, or whatever the case may be.
• 8:45
  SPEAKER_00: It helps you understand what's going on.
• 8:47
  SPEAKER_00: And then this is also helpful sometimes, is to talk through what each line will do and what the inputs and outputs will be.
• 8:56
  SPEAKER_00: So out loud, this may be where you bring the rubber duck in.
• 9:00
  SPEAKER_00: You talk through every line what you think the compiler is going to do.
• 9:06
  SPEAKER_00: This may be tedious, maybe slow, but what it helps you do is when you're talking out loud to something, even a rubber duck, that when you're talking out loud, you kind of reveal some of your assumptions.
• 9:20
  SPEAKER_00: Where you go, and then the file gets loaded, and you're like, wait, wait, wait, what file?
• 9:24
  SPEAKER_00: Where did that file come from?
• 9:25
  SPEAKER_00: I don't have the file.
• 9:26
  SPEAKER_00: Oh, we're not loading the file.
• 9:28
  SPEAKER_00: There's the problem.
• 9:30
  SPEAKER_00: Okay, so by talking it through, you start talking through your assumptions.
• 9:35
  SPEAKER_00: Okay.
• 9:36
  SPEAKER_00: Number four, break apart the system.
• 9:41
  SPEAKER_00: So if you have this long, complicated process and it's breaking somewhere in there or it's it's breaking at one piece, break apart and test each section independently.
• 9:52
  SPEAKER_00: So this is where unit tests can be really helpful.
• 9:54
  SPEAKER_00: You validate multiple inputs and outputs for each little piece, each little unit along the way, and attempt to create the error in a specific method.
• 10:05
  SPEAKER_00: So maybe you've narrowed it down to a section, now break it down even further into a specific method.
• 10:10
  SPEAKER_00: So you can say, okay, when I pass in a to and a you know, test is the word, that breaks something.
• 10:19
  SPEAKER_00: Let's find out why.
• 10:21
  SPEAKER_00: Okay.
• 10:22
  SPEAKER_00: And so then you can create a unit test to test that and say, yep, that's when it breaks.
• 10:27
  SPEAKER_00: So, and then replicate that problem in a new application.
• 10:31
  SPEAKER_00: Okay.
• 10:31
  SPEAKER_00: Again, we're trying to pull this out into a test project.
• 10:37
  SPEAKER_00: Recreate the problem in a new application, make it as simple as possible, make the code generic and non-proprietary.
• 10:44
  SPEAKER_00: This is where you find out, oh, some of that proprietary code, some of that really tricky logic we created.
• 10:50
  SPEAKER_00: Well, that doesn't actually work.
• 10:52
  SPEAKER_00: And that's what's causing the problem.
• 10:54
  SPEAKER_00: Because if you try to recreate with some generic code and you find out, well, that works, then why doesn't ours work?
• 11:00
  SPEAKER_00: Maybe you've been calling your internal company DLL, and it does some things for you like truncating strings and you know doing all uppercase in your string, whatever it's doing, right?
• 11:12
  SPEAKER_00: And you're calling that over and over again.
• 11:14
  SPEAKER_00: Well, take that out and put in your own code in that section and just see if it still has a problem.
• 11:22
  SPEAKER_00: Because then you're eliminating some issues and you've got something to recreate.
• 11:27
  SPEAKER_00: And this is where step six comes in.
• 11:30
  SPEAKER_00: Talk it through with someone.
• 11:31
  SPEAKER_00: Start again with that rubber duck.
• 11:34
  SPEAKER_00: So the overall, the problem, how you recreate it, the whole thing.
• 11:39
  SPEAKER_00: Talk it through with someone, start the rubber duck, because it's, you know, you can take up as much time as you want with that rubber duck.
• 11:45
  SPEAKER_00: But what'll happen is you'll start talking through what's going on and it might trigger something.
• 11:50
  SPEAKER_00: Then talk to a coworker or a friend.
• 11:53
  SPEAKER_00: Doesn't even have to be a developer.
• 11:55
  SPEAKER_00: Just talk to someone, say, hey, this is what I'm doing.
• 11:57
  SPEAKER_00: Just listen.
• 11:58
  SPEAKER_00: And maybe it might ask a stupid question that triggers something.
• 12:02
  SPEAKER_00: Okay.
• 12:03
  SPEAKER_00: Only after all those things do you then go talk to the internet and say, hey, internet, I've got this problem, because maybe there's a bug in the system.
• 12:11
  SPEAKER_00: Maybe there's a bug in.NET that's causing the problem.
• 12:14
  SPEAKER_00: Now, most likely the answer is no, the problem is in your code.
• 12:18
  SPEAKER_00: But by going through all those steps first, you'll have all the information about how you can recreate it, what the error was, what the log statements told you, what the process was, the actual code you could give someone, because it's generic and not proprietary, and it recreates the problem that you can show someone and they can test it and see the problem too.
• 12:41
  SPEAKER_00: Because then they can say, okay, here's all the work you've done.
• 12:44
  SPEAKER_00: I can see that.
• 12:45
  SPEAKER_00: And it's still causing this problem.
• 12:47
  SPEAKER_00: Okay, I spot the problem and I'm gonna feel you know fine about sharing it with you.
• 12:53
  SPEAKER_00: You know, we all have blind spots.
• 12:56
  SPEAKER_00: We all don't, no one knows everything.
• 12:57
  SPEAKER_00: And so, sure, you know, I spotted a problem, I realized, oh, you didn't realize that in this case, this happens.
• 13:04
  SPEAKER_00: Okay, not a problem.
• 13:05
  SPEAKER_00: You've now learned something new and you fixed the problem.
• 13:09
  SPEAKER_00: Or they realize, hey, I can't get this solved either.
• 13:14
  SPEAKER_00: Looks like it is a problem with the overall system.
• 13:17
  SPEAKER_00: We can escalate that up to, let's say, Microsoft support, and they can look at it.
• 13:21
  SPEAKER_00: So, but by doing all those steps first, you have reworked the problem.
• 13:27
  SPEAKER_00: You have tested things out, you've gone as far as you can go, and you have made sure that you have a full understanding of everything you can about what the problem is and how it operates.
• 13:40
  SPEAKER_00: Knowing all of that will help you solve most of your problems.
• 13:45
  SPEAKER_00: But if you can't solve a problem, knowing all of that will help you communicate clearly in a way that shows this is not a homework question.
• 13:54
  SPEAKER_00: This is not me just trying to avoid work.
• 13:57
  SPEAKER_00: This is I'm stuck, I've done all the work I can, and I just need someone to help me out.
• 14:04
  SPEAKER_00: And it's much more likely that people will be willing to help you out if you do those steps.
• 14:08
  SPEAKER_00: I have seen people complain about things like Stack Overflow.
• 14:12
  SPEAKER_00: I have never had a problem with Stack Overflow.
• 14:14
  SPEAKER_00: I have asked multiple questions on Stack Overflow.
• 14:17
  SPEAKER_00: I have asked questions to Microsoft employees before.
• 14:21
  SPEAKER_00: I've never had a problem.
• 14:22
  SPEAKER_00: I've never had people get angry at me or downvote me.
• 14:26
  SPEAKER_00: And part of the reason why is because I don't come to them until I've gone through steps one through five thoroughly.
• 14:33
  SPEAKER_00: I don't go to step two until I understand fully the answers to step one.
• 14:39
  SPEAKER_00: I don't go through to step three until I understand fully the answers to step two.
• 14:43
  SPEAKER_00: And I go through step by step by step so that when I'm done, when I ask a question, it's thoroughly documented.
• 14:50
  SPEAKER_00: I have this long list of information.
• 14:52
  SPEAKER_00: Here's a system I'm on, here's the versions of everything I'm using, here is the recreation spot where I've recreated the problem.
• 15:01
  SPEAKER_00: Here's the code I'm using, here's the error message I'm getting, here's the problem, here's like I summarize everything, then I have all the details so that people know this is what my problem is.
• 15:14
  SPEAKER_00: And that tends to, I won't say it always will, because there's always angry people on the internet, but it will help with that process.
• 15:22
  SPEAKER_00: I also talk to others first before I just go ask a random stranger on the internet.
• 15:28
  SPEAKER_00: I try and ask my coworkers and my friends first for help before I go out and ask just random people.
• 15:34
  SPEAKER_00: Okay?
• 15:35
  SPEAKER_00: So this process will take you time.
• 15:38
  SPEAKER_00: You will struggle through this process.
• 15:41
  SPEAKER_00: And when you start working the process, you might not understand the whole thing.
• 15:46
  SPEAKER_00: You might take a lot of time getting through steps one through five.
• 15:50
  SPEAKER_00: That's okay.
• 15:51
  SPEAKER_00: Take the time, don't shortcut the process.
• 15:54
  SPEAKER_00: Like I said, this is how you become a much better developer.
• 15:59
  SPEAKER_00: This is how you become a senior developer.
• 16:01
  SPEAKER_00: Okay.
• 16:02
  SPEAKER_00: This is part of the process, is understanding how to debug a system.
• 16:06
  SPEAKER_00: And it's not just go ask somebody else.
• 16:09
  SPEAKER_00: Okay.
• 16:10
  SPEAKER_00: Learn to do it on your own.
• 16:12
  SPEAKER_00: Learn to build this skill up.
• 16:14
  SPEAKER_00: You will always have problems in your code because you don't write perfect code and neither does anybody else.
• 16:19
  SPEAKER_00: So you're always going to have these problems.
• 16:21
  SPEAKER_00: You're always going to have to work through them.
• 16:23
  SPEAKER_00: But the more you can work through it yourself, the more you build up this skill, the faster you will be at debugging problems.
• 16:31
  SPEAKER_00: The less you will write actual bad code because you will have seen it and you'll have learned how to fix it ahead of time.
• 16:38
  SPEAKER_00: And the better you will be at moving through an application and making those fixes.
• 16:44
  SPEAKER_00: Okay?
• 16:44
  SPEAKER_00: So those are my six steps.
• 16:45
  SPEAKER_00: I encourage you to follow them.
• 16:47
  SPEAKER_00: Take the time to work through them and make sure you really understand the problem and how to recreate it before you go and get help from someone else.
• 16:56
  SPEAKER_00: Thanks for listening.
• 16:57
  SPEAKER_00: As always, I am Tim Corey.
• 16:59
  SPEAKER_02: Thank you for joining us for this episode of Def Questions.
• 17:02
  SPEAKER_02: Tim is committed to making it easier for you to become a developer.
• 17:05
  SPEAKER_02: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 17:13
  SPEAKER_02: You can also send your questions to questions at Iamtimcorey.com.
• 17:18
  SPEAKER_02: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 17:25
  SPEAKER_02: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.