Latest / DevQuestions with Tim Corey / 221. Learn How To Simplify Difficult Tasks In Software Development

Transcript

221. Learn How To Simplify Difficult Tasks In Software Development · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: How do I handle a difficult task in a sprint?
• 0:03
  SPEAKER_01: How do I stop from being overwhelmed by complicated projects?
• 0:07
  SPEAKER_01: Working as a software developer, you're going to face overwhelming projects a lot.
• 0:13
  SPEAKER_01: In fact, it's a big reason why the role exists in the first place.
• 0:17
  SPEAKER_01: If our job was easy, we wouldn't be needed.
• 0:20
  SPEAKER_01: People using low-code or no-code solutions would have replaced us by now.
• 0:24
  SPEAKER_01: So when you're faced with a complicated, confusing task, how do you solve it?
• 0:29
  SPEAKER_01: In today's episode, we're going to talk through how to overcome difficult tasks.
• 0:42
  SPEAKER_00: Welcome to the Dev Questions podcast with Tim Corey.
• 0:46
  SPEAKER_01: Software development is more than just writing code.
• 0:50
  SPEAKER_01: So let's talk about the rest of it.
• 0:51
  SPEAKER_01: Specifically, let's talk about how to simplify difficult tasks instead of getting overwhelmed.
• 0:58
  SPEAKER_01: Now, the answer to this really comes down to just one thing.
• 1:03
  SPEAKER_01: And I know you're used to lists and other things or possibilities.
• 1:06
  SPEAKER_01: It's just one thing.
• 1:08
  SPEAKER_01: Break the problem down into manageable chunks.
• 1:11
  SPEAKER_01: That's it.
• 1:13
  SPEAKER_01: That's the whole thing.
• 1:14
  SPEAKER_01: And if you want to stop right now and be done, that's fine.
• 1:17
  SPEAKER_01: But I'm going to show you six different ways of doing that.
• 1:21
  SPEAKER_01: Okay?
• 1:21
  SPEAKER_01: You can solve almost any problem, regardless of its size, if you just break it down into smaller chunks.
• 1:29
  SPEAKER_01: So let's talk through how to do that.
• 1:31
  SPEAKER_01: Now, I'm going to give you an example from my life, and I've told you four, I think, at least once, but it's probably the clearest example.
• 1:39
  SPEAKER_01: I've got lots of examples of doing this, but this is one of the clearest ones because of how overwhelming it was.
• 1:45
  SPEAKER_01: So I used to work as a basically a I worked for a company that would then contract out my services.
• 1:55
  SPEAKER_01: So we were a consulting/slash work for hire type company that would come in and solve software development problems among others.
• 2:06
  SPEAKER_01: I ended up working as a network engineer as well and other things.
• 2:09
  SPEAKER_01: But we would solve problems when it came to technology.
• 2:13
  SPEAKER_01: And we had a company come to us and say, hey, we've got a whole bunch of conveyors that we want to stop and start at any time from anywhere.
• 2:25
  SPEAKER_01: Now, if you're not familiar, in most industries, it really should be all, but in the industries where you have conveyors and other working, moving machinery, you have a button that's prevalent that's called an e-stop or emergency stop.
• 2:40
  SPEAKER_01: And it's usually a big red button that you just hit with your hand and it will turn off the machines in that area.
• 2:46
  SPEAKER_01: And that's a safety thing.
• 2:47
  SPEAKER_01: So let's say you get your hand caught in something, you want to be able to hit that button and stop it from being pinched further or causing further damage.
• 2:56
  SPEAKER_01: So that's a physical button at one or more physical locations.
• 3:03
  SPEAKER_01: But when they were working through what they wanted, they said, hey, we've got these wireless devices.
• 3:10
  SPEAKER_01: Now, if you're not familiar, they're called PDAs at the time.
• 3:12
  SPEAKER_01: Okay, this is back in the early 2000s, or a handheld computer, basically.
• 3:17
  SPEAKER_01: Um, but it was a digital assistant, what the thought was.
• 3:21
  SPEAKER_01: Um this device you held in your hand that barely could do anything.
• 3:25
  SPEAKER_01: But what they wanted to do was use that wirelessly to turn on and off conveyor systems.
• 3:32
  SPEAKER_01: So have that e-stop capability from wherever they were from a wireless device.
• 3:38
  SPEAKER_01: Here's the problem.
• 3:40
  SPEAKER_01: Wireless was barely a thing at the time.
• 3:44
  SPEAKER_01: Handheld devices were barely a thing at the time.
• 3:47
  SPEAKER_01: And so the technology didn't really exist to put the two together.
• 3:52
  SPEAKER_01: In fact, my boss, you know, bid this out and then came to me and said, hey, do this.
• 3:57
  SPEAKER_01: And I did some research and I said, hey, you know, there's companies out there that are doing this.
• 4:03
  SPEAKER_01: In fact, one of the largest in the world is building out software like this, but the buy-in for the beta program, which isn't up and running yet, but will be hopefully in the next year, that buy-in is one million dollars.
• 4:19
  SPEAKER_01: Our customer did not pay us nearly one million dollars.
• 4:22
  SPEAKER_01: Okay.
• 4:22
  SPEAKER_01: Um, take a couple zeros off of that, if not more.
• 4:26
  SPEAKER_01: Okay, so if big companies are doing this for millions of dollars and they're not even ready to do it yet, how can I implement this?
• 4:38
  SPEAKER_01: And he's like, I've got faith in you.
• 4:41
  SPEAKER_01: Okay, that was an insurmountable task.
• 4:44
  SPEAKER_01: But what I ended up doing was I ended up breaking it down into chunks.
• 4:50
  SPEAKER_01: So I I knew we had wireless PDAs, okay, PDAs that could talk to the network.
• 4:57
  SPEAKER_01: All right.
• 4:58
  SPEAKER_01: So I know that that's where I want to control things.
• 5:01
  SPEAKER_01: Well, that PDA, I couldn't put a lot of apps on there.
• 5:05
  SPEAKER_01: There wasn't, it was not easy to do that, but I could put a web page on there.
• 5:10
  SPEAKER_01: Okay.
• 5:11
  SPEAKER_01: It had a browser.
• 5:12
  SPEAKER_01: So, well, I can build a web page.
• 5:15
  SPEAKER_01: So that was my next step.
• 5:16
  SPEAKER_01: I I said, okay, I've got the wireless device and I've got a web page I can put on there.
• 5:21
  SPEAKER_01: Well, I can build a web page that has interaction, interactable buttons.
• 5:25
  SPEAKER_01: Okay.
• 5:26
  SPEAKER_01: So now I know I can get that done, and I know that I can put a server on the network that have a local uh web page that I could serve out.
• 5:36
  SPEAKER_01: So I could build out a ASP net, or actually it's ASP at the time, not net, um ASP web application with the list of conveyors from SQL.
• 5:46
  SPEAKER_01: Okay.
• 5:47
  SPEAKER_01: So now I've got the list of conveyors on the wireless device based upon dynamic information from SQL.
• 5:54
  SPEAKER_01: Okay, so we're getting steps further, but you might think, well, Tim, but that that's not control yet.
• 5:59
  SPEAKER_01: No, you're right.
• 6:00
  SPEAKER_01: We're breaking it down into pieces.
• 6:03
  SPEAKER_01: So now I've got the ability to have an app on the IAS server on a server that can send information to the PDA.
• 6:14
  SPEAKER_01: Next up, I built a command line app that read the status of the conveyors from the control system.
• 6:22
  SPEAKER_01: Now that was on a different machine.
• 6:24
  SPEAKER_01: So now I've got a different machine with a different app that's a command line app that runs all the time that reads the status.
• 6:32
  SPEAKER_01: I believe it was every second or so, it would read the statuses of all of the different conveyors.
• 6:39
  SPEAKER_01: And then I had that application update the same SQL database.
• 6:45
  SPEAKER_01: So now the SQL database has the live status of all the conveyors.
• 6:50
  SPEAKER_01: And so then that gets displayed on the web page, which then gets put onto the PDA.
• 6:56
  SPEAKER_01: Well, then I started working on having buttons on the web app that could say turn off or turn on, based upon if it's off or on, um, the conveyors, basically an eStop.
• 7:11
  SPEAKER_01: And that's in the information into SQL.
• 7:14
  SPEAKER_01: But then I had the command line application read from SQL on a recurring basis all the new command updates.
• 7:22
  SPEAKER_01: And then would take those command updates and it would send them on to the control system.
• 7:29
  SPEAKER_01: So now I can push a button on a web page on my PDA, and that information goes through SQL into the other application, into the control system, and turns off the conveyor.
• 7:42
  SPEAKER_01: And the opposite was true as well.
• 7:44
  SPEAKER_01: Okay, so I got it to work and we got it working for the customer in a way that they that they approved of, they liked.
• 7:51
  SPEAKER_01: And yes, it was kludgy.
• 7:53
  SPEAKER_01: Yes, it had multiple steps along the way, but we were able to do something that those very large companies were still struggling to figure out how to do.
• 8:01
  SPEAKER_01: Now, when they came out with their applications eventually, they were probably better than mine.
• 8:06
  SPEAKER_01: I'm sure they were better than mine.
• 8:07
  SPEAKER_01: But we got something that worked for the customer and was successful.
• 8:12
  SPEAKER_01: We meet, we met the requirements by breaking down the project into small chunks.
• 8:20
  SPEAKER_01: So let's talk through the different ways to break down a problem like that.
• 8:26
  SPEAKER_01: Okay, I'm gonna highlight six of them.
• 8:28
  SPEAKER_01: There are others, but these are kind of the major ones.
• 8:31
  SPEAKER_01: So the first one is to break it into big chunks and then break each big chunk into smaller chunks.
• 8:38
  SPEAKER_01: Okay, so for example, let's say you were gonna create a Twitter clone.
• 8:42
  SPEAKER_01: Okay, well, that's a that's a lot.
• 8:45
  SPEAKER_01: Okay, there's a lot of stuff in there, and people think that a Twitter clone would be super simple.
• 8:49
  SPEAKER_01: It's not.
• 8:50
  SPEAKER_01: There's lots to it.
• 8:51
  SPEAKER_01: But let's break down into big chunks, okay?
• 8:55
  SPEAKER_01: Well, there's authentication, there's push notifications, there is users, there's tweets, there's interactions, and there's advertisements.
• 9:05
  SPEAKER_01: Those are big chunks, okay?
• 9:07
  SPEAKER_01: And you couldn't necessarily just do one chunk as it is, but you've broken it down into smaller, smaller uh chunks.
• 9:15
  SPEAKER_01: We can then break down even further.
• 9:17
  SPEAKER_01: So let's talk about push notifications.
• 9:19
  SPEAKER_01: Okay, so you break that down into smaller ones, like um when to notify, um, how to identify if a notification should go through or not, um, and so many other things.
• 9:30
  SPEAKER_01: You break that down into smaller bits, and then you're able to build each of those bits, and then you have the push notification system.
• 9:37
  SPEAKER_01: And then from there, you build the next system, the next system, and you've you've broken it down to very, very small chunks that you can then digest.
• 9:46
  SPEAKER_01: Number two, um, this works well when you have clients you're working with who are not technical or not as technical.
• 9:54
  SPEAKER_01: And this is when you sketch out the user interface.
• 9:58
  SPEAKER_01: So this can help reveal what the application might look like and kind of help break it down into smaller pieces.
• 10:06
  SPEAKER_01: So you sketch out the user interface and they start to see, oh, well, I would need to have this information there and that information there.
• 10:12
  SPEAKER_01: And it starts to reveal what information you need and what pieces you might need.
• 10:17
  SPEAKER_01: And then you've you can say, okay, I can I can do these pieces.
• 10:21
  SPEAKER_01: Uh so for example, if you watch through the suggestion app application we built on YouTube.
• 10:27
  SPEAKER_01: Well, we built that with a UI sketch first.
• 10:31
  SPEAKER_01: So we sketched out the UI and said, okay, here's the pieces we need, and that kind of helped inform the instead of one big application.
• 10:38
  SPEAKER_01: Well, now you've got the various pieces we need we can build from there.
• 10:43
  SPEAKER_01: Number three is the opposite way.
• 10:46
  SPEAKER_01: Okay, you structure out the data and you say, here's the data we need, and that helps break down the the big complex thing you have to do into okay, how do we get this data?
• 10:58
  SPEAKER_01: How do you update this data?
• 10:59
  SPEAKER_01: And you go from there.
• 11:00
  SPEAKER_01: For example, maybe you are uh working on a realty site for selling houses.
• 11:06
  SPEAKER_01: Okay, well, maybe you figure out what data you need to collect, and then from there you start building the structure and go, okay, now I need to know how to collect this data.
• 11:16
  SPEAKER_01: Now you know how to display this data, and it starts to give you more of a structure of what you need to do for that overall task.
• 11:25
  SPEAKER_01: Number four is you work a direction.
• 11:28
  SPEAKER_01: Okay, you go from the start to the finish or the finish to the start.
• 11:32
  SPEAKER_01: For example, the um the wireless conveyor system I built, the wireless conveyor control system I built.
• 11:39
  SPEAKER_01: I went from kind of the end, which was the handheld PDA controlling things, and I worked backwards until I got to the point where I could send data from that farthest back piece all the way through to the controller and then to the PDA.
• 11:56
  SPEAKER_01: And then I could send data from the PDA all the way back through to the other end.
• 12:01
  SPEAKER_01: So I worked from one end to the other, breaking down piece by piece and not worrying about everything, worrying about just this part, and then one step previous, and one step previous, and one step previous.
• 12:15
  SPEAKER_01: So working in a direction.
• 12:17
  SPEAKER_01: Number five is cut off chunks.
• 12:20
  SPEAKER_01: Okay.
• 12:21
  SPEAKER_01: So maybe it's a big, massive application.
• 12:24
  SPEAKER_01: You got to do tons of stuff, it's overwhelming.
• 12:27
  SPEAKER_01: Um, and you say, you know what, I'm going to break off the pieces that I know I can do.
• 12:33
  SPEAKER_01: Um this is easiest if maybe you're building a microservice-based application, or you're going to build lots of microservices.
• 12:40
  SPEAKER_01: Well, okay, maybe you don't know how to do everything yet, but you can build a microservice that sends out emails.
• 12:46
  SPEAKER_01: And you can build a microservice that you know um does talks to the user or gets information from the client or takes orders or fulfills orders.
• 12:56
  SPEAKER_01: Like you start breaking it down, and then what you have left is a smaller chunk than when you first started.
• 13:02
  SPEAKER_01: And you may still have a pretty large chunk, but it's you've taken the easy stuff off the top.
• 13:07
  SPEAKER_01: Then you can use our techniques and break it apart into bigger chunks or work from one and the other or something else to break that big chunk into smaller chunks and then do those little pieces.
• 13:21
  SPEAKER_01: Number six is identify and eliminate the unknowns.
• 13:25
  SPEAKER_01: So, one of the reasons why a big complicated project is scary or a big complicated task is scary is because you have a whole bunch of unknowns.
• 13:35
  SPEAKER_01: So maybe let's go back to the Twitter um example.
• 13:39
  SPEAKER_01: Maybe you're just going to do push notifications and you think, wow, there's a lot to push probably.
• 13:43
  SPEAKER_01: And actually, I don't know if you know, but there's like 50 steps to push.
• 13:46
  SPEAKER_01: It's not just do I push or not.
• 13:48
  SPEAKER_01: Um, lots of steps.
• 13:50
  SPEAKER_01: So if you're doing that, you're like, I don't know everything I need to do.
• 13:56
  SPEAKER_01: Well, that makes it very, very scary and very, very difficult to know how do you estimate how much time it's going to take and how do you even go about solving the problem.
• 14:06
  SPEAKER_01: So identify and eliminate the unknowns.
• 14:10
  SPEAKER_01: If you don't know how to do, let's say, authentication, build out a demo for authentication and figure it out.
• 14:15
  SPEAKER_01: Okay.
• 14:16
  SPEAKER_01: This is why you should be building and practice projects a lot.
• 14:21
  SPEAKER_01: Practice projects help you eliminate unknowns.
• 14:25
  SPEAKER_01: When you eliminate unknowns, well, then things become clearer and a whole lot easier to do.
• 14:31
  SPEAKER_01: So that's number six.
• 14:32
  SPEAKER_01: Identify and eliminate the unknowns.
• 14:35
  SPEAKER_01: Now, you can mix and match these six techniques in order to make your problem more manageable.
• 14:41
  SPEAKER_01: It's not just one technique or the best technique.
• 14:44
  SPEAKER_01: Mix and match.
• 14:45
  SPEAKER_01: Okay.
• 14:45
  SPEAKER_01: Maybe you break your project into smaller chunks, and then you know, one chunk might be something that's more UI related.
• 14:52
  SPEAKER_01: You create, you know, the UI sketches to help break that down even further.
• 14:56
  SPEAKER_01: Another one might be where you break off pieces that you know how to do.
• 15:00
  SPEAKER_01: Another one might be you eliminate some unknowns.
• 15:02
  SPEAKER_01: Whatever the case may be, you mix and match these techniques in order to make your problems more manageable.
• 15:08
  SPEAKER_01: Now, one key part of this is to identify and eliminate those assumptions as well.
• 15:14
  SPEAKER_01: So, yes, maybe there's unknowns, but sometimes there's assumptions.
• 15:19
  SPEAKER_01: And assumptions can really bite you.
• 15:23
  SPEAKER_01: Because maybe you assume that the application is going to work with SQL database, but that's an assumption until you figure it out.
• 15:32
  SPEAKER_01: Or maybe you assume that it's only gonna be this scope and actually it's a bigger scope or a smaller scope.
• 15:39
  SPEAKER_01: I've had that happen before where I get overwhelmed by, oh my goodness, there's so much to do, and I find out, oh no, I'm just doing a little piece of it.
• 15:45
  SPEAKER_01: Well, that's a big deal different, and it changes how complex the project is.
• 15:52
  SPEAKER_01: So the above methods are gonna help expose the assumptions.
• 15:55
  SPEAKER_01: So the six different techniques, but then get clear resolution of those assumptions before continuing.
• 16:02
  SPEAKER_01: So don't just allow assumptions to linger.
• 16:06
  SPEAKER_01: Make sure you eliminate them as you break the project down, as you work through breaking that project into more manageable chunks in order to understand it better.
• 16:16
  SPEAKER_01: Okay, so make sure that you don't have assumptions.
• 16:20
  SPEAKER_01: All right, so those are six techniques to help you with overwhelming projects or overwhelming tasks to break it down into much more manageable uh pieces that you can work through and estimate as well.
• 16:33
  SPEAKER_01: Thanks for listening.
• 16:34
  SPEAKER_01: As always, I am Tim Corey.
• 16:36
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 16:39
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to imtimcorey.com and enroll in a course.