Latest / DevQuestions with Tim Corey / 160 Why Do Software Development Projects Fail?

Transcript

160 Why Do Software Development Projects Fail? · 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: Why do software development projects fail?
• 0:29
  SPEAKER_02: What are some tips to improve the odds of success for your project?
• 0:34
  SPEAKER_02: This is a question that came up on the suggestion site, and it's one I want to tackle in today's episode of DevQuestions.
• 0:41
  SPEAKER_02: Now, if you have a question that you want to get answered, go to suggestions.imtimcorey.com and ask your question there or upvote a question that seems relevant to what you want to hear answered in the DevQuestions podcast or in other types of mediums.
• 0:57
  SPEAKER_02: Okay, so what makes software development projects fail?
• 1:02
  SPEAKER_02: Because quite frankly, a lot of projects fail before they even get off the ground.
• 1:09
  SPEAKER_02: It's tricky to get a software development project right.
• 1:12
  SPEAKER_02: And so there's been a lot of systems that have attempted to make it more reliable.
• 1:18
  SPEAKER_02: So we've heard things like, oh, waterfall is bad, and you shouldn't use the waterfall technique anymore.
• 1:25
  SPEAKER_02: That's that technique of you you figure out the design of a project, you you map it all out, you you figure out all of the design stuff, you design everything up front, and then you build the code, and then you give it to the customer.
• 1:39
  SPEAKER_02: And that's bad now because the fact we have things like Agile.
• 1:44
  SPEAKER_02: And the idea behind Agile is it makes, in theory, it makes your project more reliable.
• 1:50
  SPEAKER_02: It makes it more likely that you'll get something to market successfully.
• 1:55
  SPEAKER_02: Because you create small little pieces and then give those to the customer right away, and they can say, hey, I want, I don't like that.
• 2:02
  SPEAKER_02: I was thinking this.
• 2:04
  SPEAKER_02: And so it allows you to make changes more rapidly.
• 2:07
  SPEAKER_02: That's the theory.
• 2:09
  SPEAKER_02: And so that's just one of many tools out there that have come about in order to make projects more successful.
• 2:16
  SPEAKER_02: Other things are test-driven development, the idea that we write tests before we write the code, so that when we write the code, we can ensure more success in the outcome and not have to wait until it gets into production before we find out there's these odd edge case bugs.
• 2:34
  SPEAKER_02: Or if it does get into production, we have a way to change things more safely, where we feel more confident in the change we make.
• 2:44
  SPEAKER_02: That's a little piece of overall project success, but it's also things like issue trackers and Kanban boards, where we can figure out what are the priorities here?
• 2:54
  SPEAKER_02: And do I want to adjust how much goes into this particular sprint or this particular section of development and how you want to move things around and prioritize things and give numbers to them and all the rest.
• 3:08
  SPEAKER_02: There's also things like continuous integration where we're constantly testing our code and putting it into the overall code so we can make sure that our changes over here don't affect something over there.
• 3:21
  SPEAKER_02: There's design patterns, things that we have developed over the years to figure out how to better write applications at size.
• 3:30
  SPEAKER_02: And then there's things like system diagrams and workflow mapping, and all these tools are designed in theory to help your project succeed.
• 3:42
  SPEAKER_02: But here's the thing that's really important.
• 3:46
  SPEAKER_02: None of these guarantee success.
• 3:48
  SPEAKER_02: And in fact, all of these have been used on failing projects.
• 3:55
  SPEAKER_02: And also, projects who have done none of these things have succeeded.
• 4:00
  SPEAKER_02: So these are not magic, magic beans we can throw around and say, okay, this is going to succeed, this will work, this will make our project successful.
• 4:10
  SPEAKER_02: So, what's the secret?
• 4:11
  SPEAKER_02: What's the secret to a successful project?
• 4:15
  SPEAKER_02: The secret is that tools and techniques don't replace good project management.
• 4:21
  SPEAKER_02: That's something that people often look at is what tool can I buy to kind of buy success?
• 4:28
  SPEAKER_02: That's not how it works.
• 4:30
  SPEAKER_02: The secret is that those tools can help you succeed, they can be of value, but the reality is that you need to implement some good project management techniques.
• 4:42
  SPEAKER_02: So let's talk about those.
• 4:43
  SPEAKER_02: Number one, start with good requirements.
• 4:48
  SPEAKER_02: Assumptions kill projects.
• 4:51
  SPEAKER_02: They're brutal.
• 4:51
  SPEAKER_02: I've got an example of this that's not in software development, but I figured it kind of illustrate.
• 4:56
  SPEAKER_02: Okay, so if I come to you and say, or maybe you come to me, you come to me and say, I want to rent a vehicle, and I want to spend no more than$100.
• 5:08
  SPEAKER_02: And that's your that's your requirements.
• 5:11
  SPEAKER_02: I might give you a bike.
• 5:14
  SPEAKER_02: And you're like, no, I don't want a bicycle.
• 5:16
  SPEAKER_02: I I want something that has that's fast.
• 5:18
  SPEAKER_02: Okay, that's another requirement you just added to that budget.
• 5:22
  SPEAKER_02: Okay, I'll give you a small plane.
• 5:25
  SPEAKER_02: Well, no, no, no, no.
• 5:26
  SPEAKER_02: That's not what I was expecting.
• 5:28
  SPEAKER_02: What I was expecting was a car.
• 5:31
  SPEAKER_02: You asked, I said, I want to rent something, and I in my mind was thinking car.
• 5:37
  SPEAKER_02: But me as the renter was like, hey, your requirements are cheap.
• 5:42
  SPEAKER_02: Okay, bicycle.
• 5:44
  SPEAKER_02: No, no, no, fast and cheap.
• 5:47
  SPEAKER_02: Private plane, small little plane.
• 5:49
  SPEAKER_02: Well, no, no, no, no, I want something that drives on the road.
• 5:52
  SPEAKER_02: Oh, okay.
• 5:53
  SPEAKER_02: So you want a motorcycle?
• 5:56
  SPEAKER_02: No, no, no, four door.
• 5:57
  SPEAKER_02: Like, see, until you really specify really good requirements, what you think and what the other person thinks can be totally different.
• 6:09
  SPEAKER_02: Because when you said, I want to rent a vehicle, in your mind you were thinking car.
• 6:15
  SPEAKER_02: You didn't say car, but you were thinking it.
• 6:19
  SPEAKER_02: And that's where projects can really start out of the gate wrong.
• 6:25
  SPEAKER_02: Is you have in your mind car, but I don't have that in my mind.
• 6:31
  SPEAKER_02: And so what I'm thinking through is based upon what you have said, what you've communicated, and then I fill in the rest.
• 6:39
  SPEAKER_02: I assume things.
• 6:42
  SPEAKER_02: And so that's a problem.
• 6:43
  SPEAKER_02: That's something we need to get on the same page about.
• 6:46
  SPEAKER_02: So start with good requirements that do not have assumptions.
• 6:51
  SPEAKER_02: You've got to kill as many assumptions as possible, if not all of them.
• 6:56
  SPEAKER_02: So that's number one.
• 6:57
  SPEAKER_02: You've probably heard it before, but it's a great place to start, is if you don't start well with good requirements, you're not gonna have a good project because what's gonna happen is you're gonna deliver something the other person wasn't expecting.
• 7:13
  SPEAKER_02: This is why Agile is seen as such a great process.
• 7:17
  SPEAKER_02: Not be it's not because it really is that much better necessarily.
• 7:21
  SPEAKER_02: There are some benefits there, but the the real, you know, the real killer feature, the real thing that's the most important is that you get something in the customer's hands sooner.
• 7:34
  SPEAKER_02: Because that's when it removes some of those assumptions, where the user actually sees it and goes, that's not what I was expecting.
• 7:43
  SPEAKER_02: And you can very easily or very quickly pivot to what they were expecting, because you haven't put a lot of effort in yet in the project.
• 7:52
  SPEAKER_02: So that's a theory behind Agile, why it's such a you know, a popular idea.
• 7:58
  SPEAKER_02: There's some definite downsides there, and I think people get Agile wrong, but um, but there are some benefits there, and that's one of the things is it's it helps you eliminate some of those assumptions by putting something quick into their hands where they can say, no, I wasn't expecting this, and then you can have a conversation.
• 8:16
  SPEAKER_02: But if you just have a conversation up front and can talk through, you can sometimes eliminate some of those expectations by being very clear about exactly what they're going to get, or about exactly what you want if you're on the other side of the project.
• 8:33
  SPEAKER_02: Number two, establish version one deliverables.
• 8:39
  SPEAKER_02: This is dates and features.
• 8:42
  SPEAKER_02: So establish exactly what you will deliver, when and what.
• 8:48
  SPEAKER_02: Okay, so when, what date, and what features.
• 8:52
  SPEAKER_02: Now, you may have to be careful about giving dates because estimation is always hard.
• 9:01
  SPEAKER_02: But think of it this way: let's go back to our rental idea.
• 9:05
  SPEAKER_02: I say, you know, you say to me, I want to rent a car.
• 9:08
  SPEAKER_02: Okay, now we're on the same page.
• 9:09
  SPEAKER_02: We got a car rented, I go, cool, no problem.
• 9:13
  SPEAKER_02: You show up on Monday and say, where's my car?
• 9:16
  SPEAKER_02: And I say, I don't have it until next month.
• 9:19
  SPEAKER_02: Well, it's too late now.
• 9:21
  SPEAKER_02: Like, so if you talk about, and this comes back to assumptions though, too, if you talk about what's the delivery date and how important is it to hit that date.
• 9:33
  SPEAKER_02: Let's just say that you're building software that has to be running for a specific holiday.
• 9:39
  SPEAKER_02: Well, if you get delivered a week late, a week after the holiday is over, what's the point?
• 9:47
  SPEAKER_02: So you have to know is that a hard date or a soft date?
• 9:50
  SPEAKER_02: Is that a date that can slip, or is that a firm?
• 9:53
  SPEAKER_02: We have to have it by this date.
• 9:55
  SPEAKER_02: And that will help drive some of your other assumptions about what has to be in the project, and then also what you do or do not have for features.
• 10:06
  SPEAKER_02: Because if that's a hard date, then you say, okay, well, we're gonna get this absolute core done by that date.
• 10:13
  SPEAKER_02: We wanna have these other features done, but if something has to slip, it's gonna be those extra features that we might not have time for because that date cannot slip.
• 10:22
  SPEAKER_02: So establish a version one deliverable.
• 10:26
  SPEAKER_02: Understand exactly what that is.
• 10:29
  SPEAKER_02: Number three, stop feature creep.
• 10:34
  SPEAKER_02: This is hard.
• 10:35
  SPEAKER_02: This is really hard when you don't really control the features.
• 10:40
  SPEAKER_02: Okay, maybe you're just the lowly developer, the person who's just doing the work, and you have a boss or you have management or the project owner that has power over you, has the ability to say, no, you will do this.
• 10:56
  SPEAKER_02: That's hard, but you need to stop that feature creep.
• 10:59
  SPEAKER_02: And there's ways of doing it even when you're not in control.
• 11:03
  SPEAKER_02: So, feature creep is the idea that we're gonna build this one-story house that has two bedrooms and one bathroom.
• 11:12
  SPEAKER_02: And then as you're building it, so you've poured the foundation, you've you've started building the framing of it, and then you go, you know what?
• 11:19
  SPEAKER_02: I kind of want to have a second edition, a second story.
• 11:23
  SPEAKER_02: So it would kind of be almost too late, but you know what?
• 11:27
  SPEAKER_02: We'll figure it out.
• 11:28
  SPEAKER_02: And you put somebody on, you know, you know what?
• 11:30
  SPEAKER_02: I really want to have a bigger footprint for the house.
• 11:33
  SPEAKER_02: Let's let's add another room out to the side.
• 11:36
  SPEAKER_02: Well, now it's not under the foundation, but that's okay.
• 11:38
  SPEAKER_02: We got some rocks we can stick under there and get that to work.
• 11:41
  SPEAKER_02: And that's kind of what happens when you build projects.
• 11:44
  SPEAKER_02: You start off with two bedroom, one bath, one-story house, and you start adding these weird features that kind of hang off.
• 11:51
  SPEAKER_02: And you know, you're already adding bedrooms, so what's one more bedroom, right?
• 11:55
  SPEAKER_02: It you know, you're we're gonna move these outlets around, but that's not a problem, right?
• 11:59
  SPEAKER_02: We're gonna move the plumbing around, but that's fine, right?
• 12:03
  SPEAKER_02: It's not.
• 12:04
  SPEAKER_02: You know, there's gonna be some consequences of that.
• 12:08
  SPEAKER_02: Well, that's what happens in software development, is when you start adding these features, you know, you're rerouting plumbing, you're rerouting the electrical, you're rerouting stuff in your code that all of a sudden now you've introduced bugs because you have workarounds to get things from here over to there because it wasn't designed to do that originally, and it makes things messy.
• 12:29
  SPEAKER_02: So, how do you stop feature creep?
• 12:32
  SPEAKER_02: Well, the way you stop it is first of all, having that very clear deliverable for version one.
• 12:39
  SPEAKER_02: And saying, well, that sounds like a not version one thing because it's not part of our original deliverable.
• 12:45
  SPEAKER_02: It's not part of what we agreed to for this date with these features.
• 12:50
  SPEAKER_02: And they may say, yes, but we need to have it.
• 12:53
  SPEAKER_02: And that's when you talk about, okay, that's going to make these changes.
• 12:59
  SPEAKER_02: Because this is reality, right?
• 13:01
  SPEAKER_02: If you are building a house and you said, I want to add another room, at the very least, you're adding more building material.
• 13:10
  SPEAKER_02: You're also adding more time.
• 13:12
  SPEAKER_02: Because, again, at the very least, you have to cut out more boards.
• 13:17
  SPEAKER_02: You have to pour more foundation, you have to run more electrical.
• 13:22
  SPEAKER_02: So, in the same way with a software development project, it's not just a okay, we add more things.
• 13:30
  SPEAKER_02: We have to figure out, okay, that's either going to take more time or incur more cost, or it's going to remove other features.
• 13:40
  SPEAKER_02: So if you have a drop-dead date, if you have a firm deadline, you say, okay, what do we remove?
• 13:48
  SPEAKER_02: Because we're adding something, we have to remove something.
• 13:52
  SPEAKER_02: This is balancing the scales.
• 13:54
  SPEAKER_02: You cannot just add to one side and expect the scales not to go out of balance.
• 13:59
  SPEAKER_02: So, how do you remove, what do we, what are we going to remove?
• 14:02
  SPEAKER_02: And it's had that logical conversation about, you know, this is not a great time to add a feature, but if it's really important to you, we can do it.
• 14:11
  SPEAKER_02: And if it's really important, then we'll try our very best to put this in.
• 14:17
  SPEAKER_02: But we're going to figure out what goes out.
• 14:21
  SPEAKER_02: Is it that the timeline gets extended, or is it to remove some features?
• 14:25
  SPEAKER_02: What would you like to do?
• 14:27
  SPEAKER_02: And put it on their lap.
• 14:29
  SPEAKER_02: And if they say, well, none of those things, you can't add and not take away.
• 14:36
  SPEAKER_02: Okay, it's it's a math problem at that point.
• 14:38
  SPEAKER_02: If it's going to take you five weeks to do this, and you have this plus something else, then that's no longer five weeks.
• 14:48
  SPEAKER_02: You've got to add some time as well.
• 14:50
  SPEAKER_02: So have the logical conversation about feature creep, but do your very best to stop it before it even starts.
• 14:58
  SPEAKER_02: Number four, communicate the danger of changes mid-development.
• 15:04
  SPEAKER_02: Okay.
• 15:05
  SPEAKER_02: So that's you're going to have to do that.
• 15:08
  SPEAKER_02: You have to communicate ahead of time.
• 15:10
  SPEAKER_02: Hey, listen, this is what's going to happen.
• 15:12
  SPEAKER_02: So feature creep, remember from previous point, well, plan and communicate ahead of time to say, listen, this is our version one.
• 15:20
  SPEAKER_02: We've talked about this.
• 15:21
  SPEAKER_02: Okay.
• 15:22
  SPEAKER_02: Now, if we make changes to this, this is what's going to happen.
• 15:27
  SPEAKER_02: You prepare them for the conversation you will have if they try to bring new features in.
• 15:33
  SPEAKER_02: All right.
• 15:34
  SPEAKER_02: But on the other side of this is that as a software developer, plan for changes.
• 15:41
  SPEAKER_02: And this is kind of what you call defensive programming.
• 15:45
  SPEAKER_02: The idea that, listen, we can't plan for everything.
• 15:48
  SPEAKER_02: We do not want to write code for every eventuality.
• 15:53
  SPEAKER_02: But we know that people are going to try and change their minds midway through.
• 16:00
  SPEAKER_02: Now, some things might be small.
• 16:01
  SPEAKER_02: Hey, I want to move this button over here, or let's make that button green instead of blue.
• 16:06
  SPEAKER_02: Not a big deal.
• 16:07
  SPEAKER_02: But sometimes it's, hey, you know what?
• 16:09
  SPEAKER_02: I know you build this whole desktop app, but we'd love to have it in the web.
• 16:14
  SPEAKER_02: That's no big deal, right?
• 16:16
  SPEAKER_02: So there's small things and there's big things.
• 16:18
  SPEAKER_02: But if as a software developer, you can kind of prepare yourself for that.
• 16:24
  SPEAKER_02: Maybe you see that they want the latest flashy thing, or maybe they want to do all this cool stuff and you've backed them down to something simpler, but you know that it's coming back at some point.
• 16:37
  SPEAKER_02: Maybe you decide, hey, let's put as much code as possible into the class library so we can change out that UI more easily.
• 16:46
  SPEAKER_02: Or let's build an API for this, because it would help our front end, but we kind of know that that mobile thing that's probably coming back.
• 16:56
  SPEAKER_02: Like we pushed them off for now.
• 16:58
  SPEAKER_02: We said, you know what, let's do a progressive web application.
• 17:01
  SPEAKER_02: But we know at some point they're gonna want a dedicated, installed uh iOS and Android app.
• 17:08
  SPEAKER_02: Then maybe you plan for that ahead of time a little bit, a little bit of defensive programming.
• 17:14
  SPEAKER_02: Do not just write for all the eventualities.
• 17:18
  SPEAKER_02: Okay.
• 17:18
  SPEAKER_02: Don't put an API in if you aren't pretty certain they're gonna need it.
• 17:23
  SPEAKER_02: But think that through and try to kind of predict a little bit and maybe even put some slack in the schedule so that you can adjust to it.
• 17:34
  SPEAKER_02: You can handle some unknown stuff that they throw at you without badly trashing the schedule.
• 17:42
  SPEAKER_02: Okay.
• 17:42
  SPEAKER_02: Be a little bit offensive in how you plan out the project.
• 17:47
  SPEAKER_02: Number five, keep the project small.
• 17:51
  SPEAKER_02: The bigger the project is, the harder it is to keep in check.
• 17:56
  SPEAKER_02: Okay.
• 17:57
  SPEAKER_02: So if you keep it small, you can do more.
• 18:02
  SPEAKER_02: Okay.
• 18:03
  SPEAKER_02: Um, this is why microservices, for all their faults, and I do not think that microservices is the right call for most organizations, at least not full scale.
• 18:12
  SPEAKER_02: But this is why microservices can be a real benefit.
• 18:17
  SPEAKER_02: Because they're meant to be 100 lines of code, 150 lines of code, that's it.
• 18:22
  SPEAKER_02: Like that's this little thing.
• 18:25
  SPEAKER_02: So if you keep it small, you can build one of those in a day or two.
• 18:31
  SPEAKER_02: You can have it into production in a day or two.
• 18:34
  SPEAKER_02: You don't have to have as long drawn out process.
• 18:37
  SPEAKER_02: Well, when you do that, then you can make changes to, you can iterate rapidly, you can grow it over time, you can change behind the scenes what happens or where it logs to or what database it uses.
• 18:48
  SPEAKER_02: All those things can happen more quickly.
• 18:51
  SPEAKER_02: Whereas if you say, you know what, I'm gonna build this complete uh CRM, complete CRM, and you decide we're gonna put all the features in here and kind of cram everything in, and you're trying to build it all at once, that's a problem because it's going to take years to get even close to the version one where everything's working.
• 19:13
  SPEAKER_02: All right.
• 19:14
  SPEAKER_02: So try and keep it small, which leads into the next point, which is break your product into parts.
• 19:21
  SPEAKER_02: All right.
• 19:21
  SPEAKER_02: The example here is when you're building a car.
• 19:25
  SPEAKER_02: I know you don't build cars very often, but imagine a car manufacturer.
• 19:31
  SPEAKER_02: If they said, we're gonna build a car, and they start with some metal and some rubber and some plastic and try to assemble the car from that, where they start building gears and then they build that's too big.
• 19:50
  SPEAKER_02: Instead, what they do is they design the parts they need and they have each part built separately.
• 19:57
  SPEAKER_02: That's a separate process.
• 19:59
  SPEAKER_02: And then at some point, they have the assembly line, which assembles all those things together.
• 20:04
  SPEAKER_02: And yes, some things may get built on there, but very little.
• 20:07
  SPEAKER_02: It's mostly taking what's already built in pieces and putting it together into the hole.
• 20:13
  SPEAKER_02: So they have each piece tested, each piece working, and they put it together.
• 20:18
  SPEAKER_02: In the same way, your application, maybe you don't need to have the entire application from end to end working.
• 20:27
  SPEAKER_02: Maybe you can have a little piece working and then another little piece working and then another little piece and link them together, hook them together, whether it's adding a new form or whether it is adding a new service.
• 20:41
  SPEAKER_02: Again, microservices are not the answer to everything.
• 20:45
  SPEAKER_02: But there is the idea of a modular monolith.
• 20:50
  SPEAKER_02: The idea that you can break apart your monolith application a little more easily, add things to it over time, grow it over time, instead of trying to build everything all at once.
• 21:02
  SPEAKER_02: So break it down into parts, see which parts you can build that don't have to rely on every other part being done too, and start from there.
• 21:13
  SPEAKER_02: Number seven, don't build for Google Scale.
• 21:18
  SPEAKER_02: This is a trap that people fall in, especially as new developers, but even as experienced developers.
• 21:25
  SPEAKER_02: You fall in this trap of I need to build it so it works for huge influxes of people.
• 21:32
  SPEAKER_02: We need to build it so that a million people can hit this all at once.
• 21:37
  SPEAKER_02: No, don't do that.
• 21:39
  SPEAKER_02: Build it efficiently.
• 21:41
  SPEAKER_02: Don't waste efficiency because you can, but at the same time, worry about scalability later when you need it.
• 21:49
  SPEAKER_02: For instance, Blazor Server has a connection back to the server.
• 21:54
  SPEAKER_02: So it uses Signal R to talk from the server to the client side.
• 21:59
  SPEAKER_02: And it's A very small little connection.
• 22:02
  SPEAKER_02: And a virtual machine can run 10,000 to 20,000 of those connections concurrently.
• 22:10
  SPEAKER_02: And that's the big thing people talk to me about is well, that's not good enough.
• 22:15
  SPEAKER_02: That's not good enough.
• 22:16
  SPEAKER_02: I might have 50,000 people on my site at the same time.
• 22:21
  SPEAKER_02: Really?
• 22:22
  SPEAKER_02: Really?
• 22:22
  SPEAKER_02: No one knows who you are.
• 22:24
  SPEAKER_02: You haven't launched your domain name yet, let alone have an actual product yet.
• 22:29
  SPEAKER_02: Let's start with five people at once, 10 people at once.
• 22:34
  SPEAKER_02: I have over 300,000 closing on 400,000 subscribers.
• 22:40
  SPEAKER_02: I use Signal R, not a problem.
• 22:42
  SPEAKER_02: I've never had a scalability issue with Signal R with any of my services that people talk to.
• 22:48
  SPEAKER_02: The suggestion site uses that Blazor server with Signal R.
• 22:51
  SPEAKER_02: Not a problem.
• 22:52
  SPEAKER_02: Even when I announced it and launched it and it was the heaviest hit because everyone's going to it, I'm not having issues like that.
• 23:00
  SPEAKER_02: Because I'm not really that scale.
• 23:02
  SPEAKER_02: I'm not Google scale.
• 23:04
  SPEAKER_02: I'm not the scale where I have, you know, I'm not a public university where we're doing registration on the same day for all 50,000 students.
• 23:12
  SPEAKER_02: That's not me.
• 23:14
  SPEAKER_02: Now, if you are, then yeah, plan for that.
• 23:17
  SPEAKER_02: But until you have that, plan for what you need and then how you can grow, just have that in your mind.
• 23:26
  SPEAKER_02: For instance, for me, if I were to need to scale up my signal R connection, I can do that using Azure's Signal R service.
• 23:35
  SPEAKER_02: Well, that's not a big deal, not a big change.
• 23:38
  SPEAKER_02: I don't have it in place now.
• 23:40
  SPEAKER_02: And it would take me a little bit to get there.
• 23:43
  SPEAKER_02: But by the time I start realizing, hey, we're at 5,000, 6,000 concurrent people, I'll start thinking about what happens when you hit 10,000.
• 23:54
  SPEAKER_02: Okay?
• 23:54
  SPEAKER_02: So plan to be efficient.
• 23:57
  SPEAKER_02: Try to write efficient code, but don't make so complex your code because you're trying to figure out how to be super scalable.
• 24:09
  SPEAKER_02: Worry about scalability later and just plan now for an efficient application.
• 24:15
  SPEAKER_02: Number eight, learn to successfully build small things before you build bigger things.
• 24:22
  SPEAKER_02: This is one that people hate to hear, especially when you're first starting into development.
• 24:27
  SPEAKER_02: But it's important the first application you build should not be a learn learning management system or a customer relationship management system.
• 24:36
  SPEAKER_02: These are not, these are very large systems.
• 24:38
  SPEAKER_02: A student information system, no, too big.
• 24:41
  SPEAKER_02: Pick something small.
• 24:43
  SPEAKER_02: Build a small project first.
• 24:46
  SPEAKER_02: Build a very small project first.
• 24:48
  SPEAKER_02: Build a Windows Form application with no back-end project first and grow over time.
• 24:57
  SPEAKER_02: Your first project in the real world, your first project where you're building something should not be huge.
• 25:06
  SPEAKER_02: And you know what?
• 25:07
  SPEAKER_02: If you're getting hired into a job, you might have to, but practice first.
• 25:12
  SPEAKER_02: Learn how to build smaller projects first.
• 25:15
  SPEAKER_02: Because the best teacher for a lot of these things is experience.
• 25:21
  SPEAKER_02: Now, number nine.
• 25:24
  SPEAKER_02: All right, balance your optimism with reality.
• 25:28
  SPEAKER_02: This is what all developers struggle with.
• 25:32
  SPEAKER_02: The idea that, you know, when you, you know, in the US, we have a holiday called Thanksgiving.
• 25:37
  SPEAKER_02: And for Thanksgiving, it's basically a food holiday.
• 25:40
  SPEAKER_02: It's it's great.
• 25:41
  SPEAKER_02: Um, you know, my mother was always about feeding the whole, you know, the whole neighborhood, basically.
• 25:47
  SPEAKER_02: We had tons of people over, had tons of food, had tons of pie, everything else.
• 25:51
  SPEAKER_02: And so there's lots of great stuff on the table.
• 25:53
  SPEAKER_02: And I could have huge portions.
• 25:56
  SPEAKER_02: And when you look at all the food there, you're like, I want all of this.
• 26:00
  SPEAKER_02: I want to have six different kinds of pie.
• 26:03
  SPEAKER_02: I want to have the three different kinds of turkey and ham and all the two different kinds of stuffing and potatoes and all the rest.
• 26:10
  SPEAKER_02: And you start filling your plate and you realize I don't have enough space in my plate, I want a big portion of everything.
• 26:16
  SPEAKER_02: And the expression in US is your eyes are bigger than your stomach.
• 26:20
  SPEAKER_02: The idea that what you're looking at, what you want, and you start envisioning I can eat all of this, I want all of this.
• 26:27
  SPEAKER_02: When you start actually eating it, you realize I can't eat all of this.
• 26:31
  SPEAKER_02: I should save some for later.
• 26:33
  SPEAKER_02: All right.
• 26:34
  SPEAKER_02: Or maybe a lot for later because I can't eat all of this.
• 26:39
  SPEAKER_02: The same thing happens with developers when you look at projects.
• 26:43
  SPEAKER_02: We look at projects, we say, yep, that's easy.
• 26:45
  SPEAKER_02: I know how to do that.
• 26:46
  SPEAKER_02: I can do that.
• 26:46
  SPEAKER_02: That's a weekend project.
• 26:48
  SPEAKER_02: I love weekend projects.
• 26:50
  SPEAKER_02: They last about a month.
• 26:51
  SPEAKER_02: Because when you start saying that's a weekend project, then you start getting into them, you realize that, oh, well, I have to create a new database.
• 27:01
  SPEAKER_02: Oh, I have to figure out where to put that database.
• 27:03
  SPEAKER_02: Okay, now I gotta worry about permissions.
• 27:04
  SPEAKER_02: Now I gotta worry about setting that up and monitoring that.
• 27:08
  SPEAKER_02: Okay, now I gotta put logging in place and get that set up and tested and integrated in my rest of my logging.
• 27:13
  SPEAKER_02: And oh, now you gotta figure out how to connect this to Azure and CI CD.
• 27:18
  SPEAKER_02: And before you know it, all this stuff, even just around your code, is taking up more time than you expected the whole project to last.
• 27:26
  SPEAKER_02: But then you start getting the code and you're like, oh, well, how do I do that?
• 27:31
  SPEAKER_02: And you start figuring that out and testing things out, and oh, that's a little more complicated.
• 27:35
  SPEAKER_02: And oh, I couldn't do things that way, I have to do this.
• 27:38
  SPEAKER_02: And now you're starting to write more code, and it takes you know a week to write the code or two weeks to write the code.
• 27:45
  SPEAKER_02: And before you know it, the whole month has gone by for this weekend project.
• 27:50
  SPEAKER_02: So balance your optimism with reality.
• 27:56
  SPEAKER_02: Balance your optimism with what you've seen before.
• 27:59
  SPEAKER_02: And this is where, again, having an experience of going through and building projects is really important.
• 28:06
  SPEAKER_02: That's why you should build practice projects.
• 28:09
  SPEAKER_02: Because if this is your first project, you don't know how to gauge how long things will take.
• 28:15
  SPEAKER_02: And trust me, after 100 projects, you still struggle with that.
• 28:19
  SPEAKER_02: But you can say, hey, you know what?
• 28:21
  SPEAKER_02: My last weekend project took a month.
• 28:23
  SPEAKER_02: Maybe I should plan for more time than just a weekend.
• 28:27
  SPEAKER_02: Maybe I should think through in lessons learned and figure out how to better estimate for next time.
• 28:34
  SPEAKER_02: And it's always going to be something you struggle with because software development is hard.
• 28:39
  SPEAKER_02: It's not the cut-and-dried, you know, cut these eight two by fours and put them in this order.
• 28:45
  SPEAKER_02: That's not how software development works.
• 28:47
  SPEAKER_02: There's a lot of creativity and a lot of problem solving, and you know, banging your head against a desk because of that one little bug.
• 28:56
  SPEAKER_02: So timing is hard.
• 28:58
  SPEAKER_02: Practicing and figuring out what it's going to take will help, but at the end of the day, it's still going to struggle to figure out what the time is.
• 29:05
  SPEAKER_02: So balancing your optimism with some reality of what you've done before and try and get a better time frame or a better estimate of how long the project will take.
• 29:17
  SPEAKER_02: That way, you won't be setting expectations poorly for those who are depending on the project.
• 29:23
  SPEAKER_02: So those are nine things that will help with project development.
• 29:27
  SPEAKER_02: But when it comes right down to it, you need to apply all nine of these things and work hard to communicate clearly, to estimate properly, and to protect what you've said you will do with that, you know, against scope creep and all the rest, so that you can do your best to meet expectations for the project.
• 29:50
  SPEAKER_02: Because a successful project that gets deployed too late can be seen as a failure.
• 29:55
  SPEAKER_02: And a project that may deliver on time but doesn't have the features that were expected can be seen as a failure.
• 30:03
  SPEAKER_02: But that same project, if communicated properly, can be seen as a success.
• 30:09
  SPEAKER_02: So I hope that helps.
• 30:11
  SPEAKER_02: I hope that gives you some sparks of ideas to how to make these things better.
• 30:15
  SPEAKER_02: Remember, you can't just buy a tool to make this go away, to make the project better.
• 30:21
  SPEAKER_02: Now, tools can be helpful, tools can make your life easier, and tools can help you succeed, but you have to apply these nine principles in order to really have a good chance at success for your project.
• 30:36
  SPEAKER_02: All right, thanks for the question.
• 30:38
  SPEAKER_02: Thanks for listening, and as always, I am Tim Corey.
• 30:41
  SPEAKER_01: Thank you for joining us for this episode of Def Questions.
• 30:44
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 30:48
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 30:55
  SPEAKER_01: You can also send your questions to questions at IamTimcorey.com.
• 31:00
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 31:07
  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.