Latest / DevQuestions with Tim Corey / 310. Short Attention Spans Hurt Software and Developers

Transcript

310. Short Attention Spans Hurt Software and Developers · DevQuestions with Tim Corey

• 0:00
  SPEAKER_00: The average attention span has been getting shorter and shorter.
• 0:04
  SPEAKER_00: And attention is more and more divided.
• 0:07
  SPEAKER_00: It used to be that five to seven minutes was an ideal length of time for a YouTube video.
• 0:13
  SPEAKER_00: Now the majority of videos are switching over to short form TikTok style videos.
• 0:18
  SPEAKER_00: And even that format is no longer quick enough.
• 0:21
  SPEAKER_00: Creators are starting to put the good parts of the video up front to hook and keep their audience for even that one-minute time frame, because otherwise, they'll just skip off the video.
• 0:32
  SPEAKER_00: While this trend is overall having a negative impact on society, for software developers, it's even worse.
• 0:39
  SPEAKER_00: So let's talk about how shortened attention spans are hurting software development in today's episode of DevQuestions.
• 0:54
  SPEAKER_01: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:58
  SPEAKER_00: Software development is more than just writing code.
• 1:01
  SPEAKER_00: So let's talk about the rest of it.
• 1:03
  SPEAKER_00: Specifically, let's talk about how shortened attention spans hurt both software and software developers.
• 1:10
  SPEAKER_00: And let's start with the harsh truth.
• 1:13
  SPEAKER_00: You almost certainly aren't a victim.
• 1:16
  SPEAKER_00: Your attention span is a learned habit, not a medical condition.
• 1:21
  SPEAKER_00: Yes, there are medical conditions.
• 1:23
  SPEAKER_00: Yes, there are things you can do for that, but for the most part, it's probably a learned habit.
• 1:29
  SPEAKER_00: You've been doing the equivalent of sitting on a couch eating junk food for months and then wonder why you have a hard time carrying heavy boxes up the stairs.
• 1:38
  SPEAKER_00: You definitely might struggle to focus on a task for any length of time, but that doesn't mean you're helpless.
• 1:45
  SPEAKER_00: It just means you need to build up your strength in order to do the things you need to do.
• 1:50
  SPEAKER_00: Okay?
• 1:50
  SPEAKER_00: So it's not just about I'm just have a short attention span.
• 1:55
  SPEAKER_00: No, there's something you can do about that.
• 1:58
  SPEAKER_00: It just takes work.
• 2:00
  SPEAKER_00: But let's start with why attention span is needed, why focus is needed for a developer.
• 2:08
  SPEAKER_00: Number one, and we're gonna put this in the con in the I in the context of AI, even though this video has nothing to do with AI.
• 2:16
  SPEAKER_00: Okay.
• 2:17
  SPEAKER_00: So number one, context is important and it takes time to load.
• 2:22
  SPEAKER_00: When you think about AI, you know, one of the things that's really important is that context window.
• 2:28
  SPEAKER_00: You know, if you can take a million tokens in the context window, that's better than 100,000 tokens in theory.
• 2:35
  SPEAKER_00: Because it can know more and take more into account when it's creating its answers.
• 2:42
  SPEAKER_00: So the idea behind this is let's say you have an application that has, I don't know, 100,000 lines of code.
• 2:52
  SPEAKER_00: Well, that's that probably can't be loaded even into a uh a context window of a million tokens.
• 2:59
  SPEAKER_00: But you can load a whole big chunk of it into the context window.
• 3:04
  SPEAKER_00: And so the AI can know about more of the application than it otherwise would have if it had a smaller window, like let's say 10,000 tokens.
• 3:13
  SPEAKER_00: Well, at that point, it knows about one meth or you know, one method or one class or one little bit.
• 3:20
  SPEAKER_00: It doesn't know about the rest of your application because it can't kind of keep that in its brain.
• 3:25
  SPEAKER_00: Well, in the same way for you, context is important.
• 3:30
  SPEAKER_00: So knowing what the application does, knowing how it interacts with the various pieces, knowing what methods are out there, how the formatting uh for the application is, what you need, you know, what you're already using, how it works, like these are things that you need to understand in order to make a wise decision about any change.
• 3:53
  SPEAKER_00: And that takes time to load.
• 3:57
  SPEAKER_00: So when I when I open up an application, it's got a bug in it, I review what the application does, what dependencies it has.
• 4:04
  SPEAKER_00: This is where dependency injection is helpful because you look to the top of the class and you go, okay, here's the things that are being injected.
• 4:10
  SPEAKER_00: What do those things do?
• 4:12
  SPEAKER_00: And you have a better understanding of how the application is going to flow and then where the affected parts might be.
• 4:22
  SPEAKER_00: That context is important.
• 4:24
  SPEAKER_00: If you just look at a specific method, you might not understand why it's failing because it might not be in that specific method.
• 4:32
  SPEAKER_00: It might be that method that interacts with another method, which interacts with a different service, which interacts with across the web, and so on.
• 4:41
  SPEAKER_00: So, number one, context is important.
• 4:46
  SPEAKER_00: Number two, disruptions wipe out a lot of our short-term memory.
• 4:50
  SPEAKER_00: Think about like a workspace.
• 4:52
  SPEAKER_00: So you got this table where you're laying out this context, and you're saying, okay, I understand what this method is doing, and this, you know, this class is doing how it fits in with the rest of the application.
• 5:03
  SPEAKER_00: You're you're laying out these papers on a workspace.
• 5:07
  SPEAKER_00: And then you have a disruption.
• 5:08
  SPEAKER_00: Well, what are you doing really?
• 5:10
  SPEAKER_00: It's kind of like you're just taking your hand and shoving aside a whole bunch of paperwork and saying, okay, let's work on this new thing.
• 5:18
  SPEAKER_00: But then when you're done working on that new thing, you have to kind of reassemble your workspace and you might miss a document or two.
• 5:26
  SPEAKER_00: And so what happens is when you miss a documentary, you you miss a bit of the context.
• 5:31
  SPEAKER_00: And all of a sudden, you might miss a connection or or might not understand why something is happening, or you might fail to account for a certain specific situation.
• 5:42
  SPEAKER_00: That's number two.
• 5:43
  SPEAKER_00: Think of it kind of like you have RAM in your brain.
• 5:46
  SPEAKER_00: Um you have RAM and you have ROM, right?
• 5:48
  SPEAKER_00: So the RAM is the memory that is short term that you're kind of keeping in your head for a short amount of time.
• 5:56
  SPEAKER_00: And then when you go do something else, it kind of dribbles out.
• 6:00
  SPEAKER_00: Um, we used to take tests in school.
• 6:03
  SPEAKER_00: This is one of the things that you would do is you would shove as much as possible in that short-term memory, where you cram right before the exam to remember all these terms and all these formulas or whatever else.
• 6:13
  SPEAKER_00: And then as soon as the exam's over, it's gone.
• 6:15
  SPEAKER_00: Like it just gone.
• 6:17
  SPEAKER_00: Um, this is what we're doing when we are looking at a problem.
• 6:21
  SPEAKER_00: We're building up more and more in that short-term memory in order to have quicker and quicker connections and understand more about the problem.
• 6:30
  SPEAKER_00: And disruption kind of cleans out spots of that.
• 6:34
  SPEAKER_00: Not all of it.
• 6:35
  SPEAKER_00: You'll remember some of it, but you might forget what you forgot, right?
• 6:40
  SPEAKER_00: You might not remember everything.
• 6:42
  SPEAKER_00: Number three, and this is really valuable for software developers, more background processing happens when you spend more time in the foreground.
• 6:52
  SPEAKER_00: What am I saying here?
• 6:54
  SPEAKER_00: If I spend all day, let's say eight hours, I spend eight hours on a problem or a project, and I'm working on that project continuously or almost continuously, you know, lunch break or whatever.
• 7:06
  SPEAKER_00: Um, but basically for eight hours, most of the day, um, I'm spending working on one problem or one area or one thing, you know, one project.
• 7:19
  SPEAKER_00: I'm gonna be spending a lot of time with that context in my brain, with the problems I'm working through in my brain as I work through it.
• 7:30
  SPEAKER_00: When that happens, it's more likely that when I go for a walk or I take a shower or I lay down in bed to close my eyes, I'm gonna have thoughts pop in my brain and go, oh, that's how it solved that problem.
• 7:45
  SPEAKER_00: Oh, that's a feature I could add.
• 7:48
  SPEAKER_00: Oh, I hadn't thought about that.
• 7:50
  SPEAKER_00: That's your background processing, right?
• 7:52
  SPEAKER_00: Your brain is still processing things even after you have stopped intentionally thinking about the problem.
• 8:01
  SPEAKER_00: That can be some of the most valuable things that come out of that.
• 8:07
  SPEAKER_00: You know, there are things that I have thought of in the shower to the point where I keep my phone near the shower so I can write down my phone as waterproof.
• 8:15
  SPEAKER_00: So I'll grab a phone and write a note in there and say, oh, gotta remember that.
• 8:20
  SPEAKER_00: My phone is near my bed, it's my alarm clock.
• 8:22
  SPEAKER_00: Well, I'll grab my phone and put a note in my phone because I'll realize, oh, I need to remember that.
• 8:30
  SPEAKER_00: I that that could be helpful.
• 8:32
  SPEAKER_00: That background processing is helping me solve problems.
• 8:37
  SPEAKER_00: However, if I spend 15 minutes on a problem and then move to a different problem and move to a different problem, and then I you keep go to meetings and I do this and I do that, and I'm all over all day, less of that background processing happens, where my brain doesn't have enough information continuing to think about it.
• 9:00
  SPEAKER_00: It's it's you know, I instead of building up that engine where I'm I'm putting more and more fuel into it and so it can go further, it's it's basically start of fuel because it's it's going from thing to thing to thing.
• 9:10
  SPEAKER_00: And my brain is just overwhelmed and tired, not really uh finding those valuable connections.
• 9:18
  SPEAKER_00: And I can often tell when I've had distracted days or days where I've done a lot of different things.
• 9:24
  SPEAKER_00: And this happens.
• 9:24
  SPEAKER_00: It's it's a normal part of life.
• 9:27
  SPEAKER_00: But when it happens, I'll I can tell by having less of those shower thoughts or thoughts when I'm laying down in bed, or you know, when I'm out for a walk.
• 9:37
  SPEAKER_00: I often find that my brain doesn't come up with those new things because it's not really working on those problems.
• 9:44
  SPEAKER_00: So my background processes aren't really happening, or they're they're not really being effective.
• 9:50
  SPEAKER_00: So more background processing happens when you spend more time in the foreground.
• 9:56
  SPEAKER_00: Number four, a lot of bugs and security vulnerabilities occur in the connection points.
• 10:03
  SPEAKER_00: What do we mean by this?
• 10:05
  SPEAKER_00: Well, applications typically aren't one executable, that's it.
• 10:10
  SPEAKER_00: Usually they are, if you're running an executable, it would be, well, it's talking to an API that's talking to a database, that's talking to a caching service, that's talking across the web, that has user secrets in key vault or something else.
• 10:26
  SPEAKER_00: Like there's a whole lot of connection points.
• 10:27
  SPEAKER_00: And that's a very simple application.
• 10:30
  SPEAKER_00: Um the those things are where the bugs often happen and security vulnerabilities.
• 10:39
  SPEAKER_00: It's not that the API is necessarily vulnerable, it's that the API and the database, that connection between the two, causes a vulnerability, more likely.
• 10:49
  SPEAKER_00: Well, understanding those connection points and understanding what the bugs might be, the vulnerabilities means you have to have more of that context in your brain.
• 11:01
  SPEAKER_00: You have to be thinking not just about how do I make this one little thing, this one little query more efficient.
• 11:07
  SPEAKER_00: You have to be thinking about the database talking to the API, talking to the caching service, et cetera, so that you understand that whole flow.
• 11:17
  SPEAKER_00: Now, not every time do you need to be thinking about everything.
• 11:21
  SPEAKER_00: But when you have that time to focus, you're focusing on the bigger picture, where you're maybe putting in a new form on a website where you're adding the website to the API, to the caching service, to the database.
• 11:37
  SPEAKER_00: You know, when you're doing that whole process, you need to have all that in your brain, think about all the different interactions so you have a better idea of where the bugs might occur and the security vulnerabilities might occur, because you are thinking about all the whole process as opposed to I just do this one, I just do this next one, I just do this next one, I just do this next one.
• 12:01
  SPEAKER_00: Because if you just focus on each individual piece, then what happens is they all work well in isolation, but those connection points cause problems.
• 12:15
  SPEAKER_00: And because you were doing shorter things and not keeping that overall context in your brain, then you miss those connection points as possible in amidst potential bugs and security vulnerabilities.
• 12:30
  SPEAKER_00: Now, I'm not saying don't break up tasks.
• 12:33
  SPEAKER_00: Definitely break up your tasks, but maybe do them together, as in task one, then task two, then task three, in order together.
• 12:42
  SPEAKER_00: That way you also keep that in mind.
• 12:44
  SPEAKER_00: So you're building that maybe a store procedure, you're building that query, you're thinking about the front end still.
• 12:51
  SPEAKER_00: Again, your background processes are still working on that front end problem.
• 12:55
  SPEAKER_00: So you go, wait, um, that's a problem because of this.
• 12:59
  SPEAKER_00: And you start to see those things.
• 13:01
  SPEAKER_00: Number five, a lot of bugs also live in the edge cases.
• 13:07
  SPEAKER_00: When you are being quick and when you're being distracted by other things, you tend to focus on getting the happy path up and running.
• 13:19
  SPEAKER_00: Meaning you're thinking about the input form, you're thinking about making the input form work.
• 13:26
  SPEAKER_00: But when you spend time and work on it and don't get distracted, you can focus on making sure that even the edge cases work.
• 13:36
  SPEAKER_00: Because that's where you find a lot of the bugs.
• 13:39
  SPEAKER_00: Um, SQL injection is a really popular one for this, where it will work normally just fine.
• 13:45
  SPEAKER_00: But because you didn't think of that whole process, you there's an edge case here, um, which is also the connection point issue.
• 13:53
  SPEAKER_00: Um, but what happens is it works fine in the normal case, but you can also inject SQL in it and get back different data.
• 14:01
  SPEAKER_00: That's a big problem.
• 14:04
  SPEAKER_00: So a lot of bugs live in edge cases, but when you are rushing, when you're not thinking about the problem as a whole, when you're getting distracted, you know, or maybe you get this is a big one.
• 14:15
  SPEAKER_00: When you get the the feature implemented, but before you can continue on the process and test it, you get distracted.
• 14:22
  SPEAKER_00: When you come back, you go, oh, I'm just wrapping this up, right?
• 14:25
  SPEAKER_00: And you forget to do all those testing cases because it's working now and you forget that you hadn't done them all, that's where you have bugs.
• 14:36
  SPEAKER_00: Uh number six, additional speed comes from an already loaded context window.
• 14:43
  SPEAKER_00: If I'm going to fix one bug in, let's say the suggestion site.
• 14:48
  SPEAKER_00: Um, if I go to the suggestion site and I'm gonna fix one bug, I'm gonna try and fix a few bugs.
• 14:55
  SPEAKER_00: Because I don't touch the suggestion site very often.
• 14:58
  SPEAKER_00: It's it just works, right?
• 14:59
  SPEAKER_00: So when I go there to make a modification, I'm gonna have to re-go over that context.
• 15:07
  SPEAKER_00: Okay.
• 15:08
  SPEAKER_00: It uses, uh I believe it's been a while, uh, MongoDB, I think it uses Red S2.
• 15:14
  SPEAKER_00: Um, not positive on that one.
• 15:15
  SPEAKER_00: I think it does.
• 15:16
  SPEAKER_00: Um and then it um it uses C sharp and it has this front end, this library, and it you know, hears all the code and understanding all those processes and all the dependencies that you know emails out um things as well.
• 15:31
  SPEAKER_00: And it has a dependency on Azure and like there's all these things that I'm gonna have to put in my brain.
• 15:36
  SPEAKER_00: But once I do and I fix one bug, it's a whole lot easier to fix a few more.
• 15:42
  SPEAKER_00: Because I'm already there.
• 15:44
  SPEAKER_00: I've already got the process down, I even have the process down of the CI CD process.
• 15:49
  SPEAKER_00: What steps do I need to take to get this into development?
• 15:53
  SPEAKER_00: What steps do I need to take to make sure my development machine is up and running the right way and so I can test out the new features and make sure they're working correctly, and what steps do I need to take to get this into production?
• 16:05
  SPEAKER_00: Right?
• 16:05
  SPEAKER_00: So I've done all those things once, and that first time takes a little extra time.
• 16:10
  SPEAKER_00: But now my brain's already loaded with context.
• 16:14
  SPEAKER_00: So I can get additional speed in fixing the next five bugs or whatever I have, because I I don't have to do that over again.
• 16:24
  SPEAKER_00: And it's super easy to go in there and go boom, boom, boom, boom, boom, fix a whole bunch more, which is why you know if you ever look at my my commits and my my uh pull requests, you won't usually see one, you'll see a multiple right in a row.
• 16:38
  SPEAKER_00: Because I got into a system and just made a whole bunch of changes.
• 16:42
  SPEAKER_00: So I don't spend a whole lot of time working on any of my systems and and sites because I first of all try to write really good code.
• 16:50
  SPEAKER_00: Um not that it always is at first, but um when I write really good code, then it doesn't have to change as often.
• 16:57
  SPEAKER_00: But then when I do, I'm gonna go in there and make sure I not only fix the problems, I'm also gonna update all the dependencies, make sure they're all update and tested.
• 17:06
  SPEAKER_00: Um I'm gonna add maybe a feature or two that I've been looking for that you know I've kind of cached out there for someday to add that feature.
• 17:14
  SPEAKER_00: I'm gonna probably do that as well.
• 17:16
  SPEAKER_00: A couple of you know uh you know, nice to have things as well.
• 17:20
  SPEAKER_00: Um but I'll do all those things all at once.
• 17:23
  SPEAKER_00: That way it's so much easier to make those changes and to um get things out more quickly.
• 17:31
  SPEAKER_00: So that's why attention is attention spans and focus is so important.
• 17:37
  SPEAKER_00: Now, life is hard.
• 17:40
  SPEAKER_00: Um employers don't love to give you tons of focus time.
• 17:45
  SPEAKER_00: It just is necessarily a thing.
• 17:48
  SPEAKER_00: Because you have a meeting in the morning to talk about what you're gonna do, you have a meeting in the afternoon to talk about what you did, you have a meeting in the middle of the day to talk about why you're not getting things done, and you have a follow-up meeting after that to talk about why the meeting that you had in the morning wasn't as efficient as it could be.
• 18:04
  SPEAKER_00: And all of a sudden you can have like, you know, nothing but meetings, and your boss goes, Why aren't you getting things done?
• 18:09
  SPEAKER_00: You're like, I never have time.
• 18:11
  SPEAKER_00: So I understand this.
• 18:13
  SPEAKER_00: And I'm not saying that you can just wave a magic wand and have eight hours of focus a day.
• 18:20
  SPEAKER_00: That's not necessarily going to happen.
• 18:23
  SPEAKER_00: But there are things you can do to work on that.
• 18:27
  SPEAKER_00: You can do, you know, establish some things to help your um ability to focus.
• 18:36
  SPEAKER_00: But part of this is on practice.
• 18:39
  SPEAKER_00: And so let's talk about the what things can you do to improve your attention span.
• 18:44
  SPEAKER_00: Some of these things are on you, some of these things are things you can do to help your employer help you.
• 18:50
  SPEAKER_00: But number one, and it's really the answer to almost every question about how do you improve, is practice.
• 18:59
  SPEAKER_00: Too often people think, well, I watch a video or I do this or I do that in order to improve.
• 19:05
  SPEAKER_00: No, the the most important thing you can do is practice.
• 19:08
  SPEAKER_00: And this is from a guy who provides a whole lot of training videos.
• 19:12
  SPEAKER_00: The answer to how to improve is almost always practice.
• 19:17
  SPEAKER_00: Now, yes, watching videos to prepare, cool.
• 19:21
  SPEAKER_00: Watching videos to help you understand what you're doing, sure.
• 19:25
  SPEAKER_00: But at the end of the day, practice is the most important thing.
• 19:29
  SPEAKER_00: Now, how do you practice improving your attention span?
• 19:32
  SPEAKER_00: Uh, one of the ways I have found that been super helpful for me.
• 19:36
  SPEAKER_00: Um, I don't do it as often anymore because I have really worked at improving my attention span to the point where it just kind of comes naturally.
• 19:45
  SPEAKER_00: Um, still takes work sometimes, but it's easier.
• 19:48
  SPEAKER_00: But the way I had started out was the Pomodoro technique.
• 19:53
  SPEAKER_00: So the Pomodoro technique, um, there's lots of different nuances to it, you know, depending, you know, which person is teaching it, but essentially what it is is you section off a time.
• 20:05
  SPEAKER_00: I think that, you know, again, different places, different, different times.
• 20:09
  SPEAKER_00: It's either 15 or 20 minutes usually.
• 20:11
  SPEAKER_00: Um, I tend to go for the longer times, like 20 minutes, um, but where you say, okay, I'm gonna work on this task for 20 minutes.
• 20:20
  SPEAKER_00: And it's not going to be, I'm gonna work on my task list for 20 minutes.
• 20:25
  SPEAKER_00: No, no, no.
• 20:26
  SPEAKER_00: That one task.
• 20:27
  SPEAKER_00: You might say, well, I was done 15 minutes.
• 20:30
  SPEAKER_00: Okay.
• 20:31
  SPEAKER_00: Then what you're gonna do is you're spending the next five minutes making it better.
• 20:35
  SPEAKER_00: Not going on to the next task, making that better.
• 20:38
  SPEAKER_00: Focus on that one thing for 20 minutes.
• 20:40
  SPEAKER_00: You might say, well, you're gonna waste time.
• 20:42
  SPEAKER_00: Well, first of all, no, because when you focus on making something better, then you have better long-term results.
• 20:50
  SPEAKER_00: Okay.
• 20:50
  SPEAKER_00: You're gonna focus more on edge cases, you're gonna focus more on those connection points and other issues that are going to improve your overall code.
• 21:00
  SPEAKER_00: You're gonna decrease the number of bugs and security vulnerabilities, et cetera.
• 21:04
  SPEAKER_00: So you focus on that for 20 minutes.
• 21:06
  SPEAKER_00: And then you take a five-minute break or a three-minute break, depends.
• 21:10
  SPEAKER_00: Again, I usually do five.
• 21:11
  SPEAKER_00: So a five-minute break where you don't do work.
• 21:14
  SPEAKER_00: Um, you kind of clear your brain or you do something else.
• 21:17
  SPEAKER_00: And then you go back and do another 20 minutes, then five off, then 20 minutes, then 15 off.
• 21:23
  SPEAKER_00: And you start that whole process over again.
• 21:26
  SPEAKER_00: So what you will find is that it's really hard.
• 21:30
  SPEAKER_00: And that the Pomadro technique uh talks about the idea that when you get distracted, when a phone rings, when you're um when your a text comes up in your phone, you look at it, uh, when email pops up and you quickly answer it, or uh uh a team's message or whatever else, that you restart.
• 21:48
  SPEAKER_00: You're like, nope, gotta start over.
• 21:51
  SPEAKER_00: And at first, you will only get a few Pomodoros done a day, if that.
• 21:56
  SPEAKER_00: But over time, you will see that you get more and more.
• 22:00
  SPEAKER_00: More done.
• 22:01
  SPEAKER_00: Now, I don't typically work the entire day that way.
• 22:04
  SPEAKER_00: I typically say, hey, I love to get eight done today.
• 22:08
  SPEAKER_00: Just eight.
• 22:09
  SPEAKER_00: And I'll try and get eight done and see if we can't get that done.
• 22:13
  SPEAKER_00: And maybe I get six done and go, I feel good about six.
• 22:16
  SPEAKER_00: So try and get that practice in by practicing just 20 minutes.
• 22:24
  SPEAKER_00: Now, you can improve that by saying, okay, I I've got that rhythm down, but I'm going to start tackling bigger problems or something else.
• 22:34
  SPEAKER_00: I'm going to do one hour.
• 22:36
  SPEAKER_00: And that's that's outside of technique.
• 22:37
  SPEAKER_00: It's something on your own.
• 22:39
  SPEAKER_00: But I'm going to do one hour.
• 22:41
  SPEAKER_00: I'm not going to have any distractions for one hour.
• 22:45
  SPEAKER_00: So I'm going to focus on this task.
• 22:47
  SPEAKER_00: Maybe I'm I'm working on designing a system or I'm working on identifying a new feature and how to implement it.
• 22:54
  SPEAKER_00: One hour.
• 22:55
  SPEAKER_00: Focus on just that.
• 22:57
  SPEAKER_00: And you will be amazed at once you get to the point where you can do that, how valuable that is.
• 23:05
  SPEAKER_00: But it comes through practice.
• 23:07
  SPEAKER_00: Number two, eliminate distractions.
• 23:11
  SPEAKER_00: When you're working, try to turn your phone off, your personal phone, especially.
• 23:17
  SPEAKER_00: But if you can, your work phone, that's too, that's great.
• 23:21
  SPEAKER_00: Now that's hard in some in some organizations.
• 23:23
  SPEAKER_00: They don't allow that.
• 23:24
  SPEAKER_00: Understandable.
• 23:26
  SPEAKER_00: But whenever possible, try to eliminate those distractions.
• 23:29
  SPEAKER_00: What I do, even though we communicate over Teams, what I'll do is Teams is on a phone and on my computer, I'll turn it off on my computer and I'll put my phone face down and on Vibrate.
• 23:41
  SPEAKER_00: So I won't hear it.
• 23:42
  SPEAKER_00: Or even on do not disturb.
• 23:44
  SPEAKER_00: And then I will focus on what I'm working on for an hour, and then I'll look at my phone and go, oh, I need to answer that.
• 23:53
  SPEAKER_00: And I'll get back to somebody.
• 23:55
  SPEAKER_00: Almost never is it a critical thing where, oh my goodness, I have to respond right away.
• 24:01
  SPEAKER_00: But too often we we deal with the quick question, or hey, I got a question about this, or hey, can we talk five minutes about that as top of the heap important when the reality is it isn't.
• 24:14
  SPEAKER_00: So try as much as possible to eliminate distractions.
• 24:19
  SPEAKER_00: I love noise-canceling headphones.
• 24:21
  SPEAKER_00: Over-the-ear noise-canceling headphones.
• 24:24
  SPEAKER_00: They're awesome.
• 24:25
  SPEAKER_00: I have worked in too many environments with other people.
• 24:27
  SPEAKER_00: They're distracting.
• 24:29
  SPEAKER_00: So putting headphones on, I don't tend to listen to music because music distracts me, even though you'd think, well, no, it's just music you understand.
• 24:40
  SPEAKER_00: But no, what happens is I catch myself singing along, which means half my brain is thinking about that music.
• 24:45
  SPEAKER_00: Even if it is the background process is thinking about music, I don't want that.
• 24:50
  SPEAKER_00: I want it to be thinking about the thing I'm working on so that later it can it can tell me when it came up with a solution.
• 24:57
  SPEAKER_00: So I'll tend to listen to cafe sounds or nature sound or something else where it's there's nothing in there except a repeating just background sound.
• 25:08
  SPEAKER_00: And that way I can have that noise-canceling headphones and the sound coming from that continuous sound eliminates any other noise in the office.
• 25:19
  SPEAKER_00: That can be really helpful.
• 25:21
  SPEAKER_00: So eliminate as many distractions as possible.
• 25:25
  SPEAKER_00: Number three, and this goes with number two, batch your work.
• 25:30
  SPEAKER_00: Too often you have your, unfortunately, outlook open and you get an email and you get distracted and answer that and go back to your work.
• 25:41
  SPEAKER_00: And then a Teams message pops up and you go, you know, answer that and go back to work.
• 25:45
  SPEAKER_00: And what happens is you're never really focusing on one thing at a time.
• 25:51
  SPEAKER_00: Batch your work.
• 25:53
  SPEAKER_00: Talk to your boss about this.
• 25:54
  SPEAKER_00: This may require some buy-in.
• 25:57
  SPEAKER_00: But what you're telling your boss is listen, when I come in for the, you know, I come in at 8 o'clock in the morning, I'm gonna spend the first half hour of my work day answering emails, answering teams' messages, and you know, cleaning up from the night before, whatever.
• 26:10
  SPEAKER_00: And then from 8:30 to 10 a.m., I want to focus in on working on this project.
• 26:19
  SPEAKER_00: And then at 10 a.m., I'll answer emails, I will answer teams' messages, I'll, you know, use the restroom, I'll talk to coworkers, whatever.
• 26:28
  SPEAKER_00: And then from you know, 10:30 or, you know, 10, probably 10:30, um, from 1030 to 11:30, I'm gonna work and focus in on work.
• 26:37
  SPEAKER_00: And then the afternoon is gonna be meetings, it's gonna be, you know, after lunch, it's gonna be meetings, it's gonna be, you know, busy work, you know, those kind of things that that just take time.
• 26:48
  SPEAKER_00: So if you do those batches though, where you're saying I'm gonna batch work in the morning and in you know, in the mid-after mid-morning as well, then you have two chunks where sure it's only two and a half hours of your day, but you have two and a half hours of focused work.
• 27:03
  SPEAKER_00: And you're gonna see a marked improvement in how much work you can do in a day.
• 27:08
  SPEAKER_00: And your boss is going to like it over time.
• 27:11
  SPEAKER_00: Now, you have to work with your boss usually to make sure that they don't just you know schedule you for early meetings or uh require you to answer your phone during that time or whatever the case may be.
• 27:23
  SPEAKER_00: Try to as much as possible eliminate those distractions with help and batch your work.
• 27:29
  SPEAKER_00: That way you can spend more time with that context window open.
• 27:34
  SPEAKER_00: Number four, that's gonna be a hard one, especially in the era of AI.
• 27:40
  SPEAKER_00: Do one thing at a time.
• 27:42
  SPEAKER_00: You know, I've seen more and more people talking about AI agents and how they have agents and subagents and they can spin off multiple tasks and they go from thing to thing to thing, where they're they're reviewing the work of one AI and then sending it off to do more work, and then they go to the next AI, review that work, and send it off.
• 28:01
  SPEAKER_00: That may feel efficient, but what's happening is you have no context window.
• 28:07
  SPEAKER_00: You are destroying your context window and having a very tiny one open up for every new project.
• 28:14
  SPEAKER_00: So what happens is you miss all those connections, those bugs, you know, that the happen the edge cases and those connections, and in general with the more complex code, you're more likely to miss those things because you are doing more at a surface level.
• 28:30
  SPEAKER_00: You are not going deep anywhere.
• 28:33
  SPEAKER_00: So try as much as possible to do one thing at a time.
• 28:37
  SPEAKER_00: If you're using an AI agent, sure.
• 28:41
  SPEAKER_00: Give them the task.
• 28:43
  SPEAKER_00: And when they're doing it, don't just say, oh, I'm gonna move on to the next task.
• 28:48
  SPEAKER_00: No, no, no.
• 28:48
  SPEAKER_00: Focus in on what they've already done.
• 28:51
  SPEAKER_00: Review the plan, review the code they've written, spend more time in code review for the last thing they did, because they're gonna mess something up and you need to make sure you modify that.
• 29:03
  SPEAKER_00: So spend as much time as possible working with that agent on one thing at a time.
• 29:10
  SPEAKER_00: That's number four.
• 29:11
  SPEAKER_00: Number five, intentionally focus on other areas.
• 29:16
  SPEAKER_00: So, or in other areas.
• 29:18
  SPEAKER_00: So when you're when you're doing things other than software development, practice this idea of focus.
• 29:26
  SPEAKER_00: One of the ones that's really easy to kind of see yourself distracted in is movies.
• 29:31
  SPEAKER_00: If you're gonna watch a movie on the couch or watch a sporting event or something else like that, what are you doing?
• 29:36
  SPEAKER_00: I have caught myself on multiple devices at the same time while quote unquote watching a movie.
• 29:43
  SPEAKER_00: The reality is sometimes there's time for that.
• 29:45
  SPEAKER_00: You know, sometimes, you know, for example, at night, I will often uh watch a TV show or a movie on one screen while playing World of Warcraft.
• 29:55
  SPEAKER_00: It's my downtime, it's my last time.
• 29:57
  SPEAKER_00: I am doing two things at once, but I'm not really paying attention to the movie.
• 30:00
  SPEAKER_00: I'm not watching anything new.
• 30:02
  SPEAKER_00: I'm watching things I watched before, that's just, you know, background noise, or I'll listen to a book even while I, you know, go and collect flowers and kill stuff.
• 30:11
  SPEAKER_00: Like, so there are there is time for that.
• 30:14
  SPEAKER_00: But when you're going to, you know, watch a significant other, or when you're going to sit down to hang out with your friends, don't get on your phone.
• 30:24
  SPEAKER_00: Focus in on just talking to your friends or just watching the movie with your friends and focus on just that one task.
• 30:31
  SPEAKER_00: It's gonna be hard, but you can do it.
• 30:34
  SPEAKER_00: When you go for a walk, go for a walk.
• 30:38
  SPEAKER_00: Don't go for a walk while doing other things.
• 30:41
  SPEAKER_00: Just go for a walk.
• 30:43
  SPEAKER_00: I have found that you know, one of my side hobbies is my primary side hobby, is photography.
• 30:50
  SPEAKER_00: And I like to take photographs of especially animals and wildlife.
• 30:54
  SPEAKER_00: Um, so I will go out and go to a park.
• 30:59
  SPEAKER_00: And because I am out in the woods and I am looking to take a picture of something, I don't have headphones in.
• 31:06
  SPEAKER_00: I'm not listening to something else, but I'm listening for those animals, I'm listening for the crunch of leaves, et cetera.
• 31:12
  SPEAKER_00: So I'm focused on one thing.
• 31:16
  SPEAKER_00: And I'll tell you what, that really helps with practicing that focus.
• 31:22
  SPEAKER_00: Because at first you kind of feel like, oh, I should, you know, listen to a book.
• 31:26
  SPEAKER_00: I'm always listening to a book, but not there.
• 31:30
  SPEAKER_00: And so what it helps is it helps that that singular focus because that builds up that skill so I can do it in my software development career, because I'm practicing it in other areas as well.
• 31:44
  SPEAKER_00: This is a scary one.
• 31:45
  SPEAKER_00: Take five minutes and meditate.
• 31:47
  SPEAKER_00: This might blow your brain at first, because you're going to sit there and go, okay, I gotta do this for school, or I gotta remember to put that in the grocery list, or I gotta try and clear your brain.
• 32:00
  SPEAKER_00: Now, part of the way you can clear your brain is by having a list for everything.
• 32:04
  SPEAKER_00: I have lists on my phone for everything.
• 32:06
  SPEAKER_00: Whenever I come across a new article I want to talk about or a new idea, for example, all these dev questions end up usually in my phone at one point or another as a note where I'll be out somewhere, the doctor's office, wherever else.
• 32:20
  SPEAKER_00: I'll go, oh, I should talk about that.
• 32:23
  SPEAKER_00: And I'll write it down on my phone.
• 32:25
  SPEAKER_00: That way I don't have to keep it in my context window.
• 32:28
  SPEAKER_00: I don't have to remember something.
• 32:31
  SPEAKER_00: Clear it out.
• 32:32
  SPEAKER_00: We have a grocery list for our house because we don't want to remember, oh, I've got to remember milk and eggs and paper towels.
• 32:39
  SPEAKER_00: Don't try to remember it.
• 32:41
  SPEAKER_00: Put in a list and forget about it.
• 32:43
  SPEAKER_00: Then you clear that context for something more important.
• 32:46
  SPEAKER_00: So meditation will really help, first of all, clear out those things because you're gonna find that those things pop up over and over and over again until you clear my brain.
• 32:57
  SPEAKER_00: But eventually you get to the point where you can just sit for five minutes and be quiet.
• 33:03
  SPEAKER_00: That will really help improve your focus.
• 33:08
  SPEAKER_00: How well a developer can focus will have a direct impact on the quality of the code they write.
• 33:14
  SPEAKER_00: It's important that you recognize that and practice building up your ability to focus, since it will have a direct impact on your career.
• 33:24
  SPEAKER_00: All right.
• 33:24
  SPEAKER_00: Thanks for listening.
• 33:25
  SPEAKER_00: As always, I am Tim Corey.
• 33:28
  SPEAKER_01: Thank you for joining us for this episode of DevQuestions.
• 33:31
  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.