Latest / DevQuestions with Tim Corey / 104 When Should I Optimize & When Should I Add New Features?

Transcript

104 When Should I Optimize & When Should I Add New Features? · 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: When should I focus on optimizing my application and when should I focus on new features?
• 0:31
  SPEAKER_02: What's that balance and how do I know when I'm hitting it correctly and when I'm skewing too far towards one or the other?
• 0:38
  SPEAKER_02: This is a question that's asked on the suggestion site, and I thought it'd be a great one to cover in today's episode of DevQuestions.
• 0:45
  SPEAKER_02: Now, if you have a question, go to suggestions.imtimcorey.com and ask your question there and mark it as a dev question.
• 0:53
  SPEAKER_02: That way you may see your question answered on a future episode of DevQuestions.
• 0:58
  SPEAKER_02: So let's get into this.
• 1:00
  SPEAKER_02: When is it time to optimize your application?
• 1:02
  SPEAKER_02: And when is it time to add new features?
• 1:05
  SPEAKER_02: Is there a balance there we can we can know how to hit well?
• 1:08
  SPEAKER_02: And I think the answer is yes.
• 1:10
  SPEAKER_02: We can know how to evaluate where we are at any given time to know what the right next step is.
• 1:19
  SPEAKER_02: Now, to set this up, I think we understand the three priorities of an application, at least in my opinion.
• 1:28
  SPEAKER_02: The number one priority above anything else, your application needs to run.
• 1:35
  SPEAKER_02: If you have a great application, it has all the design patterns followed, it is efficient, it's awesome, it's got tons of features, and it doesn't run, it's worthless.
• 1:48
  SPEAKER_02: If you have a barely functioning application, but it does what it's supposed to, then you've accomplished your primary mission.
• 1:57
  SPEAKER_02: So a working application is always your first priority.
• 2:02
  SPEAKER_02: Now, the next priority is going to be ease of maintenance.
• 2:07
  SPEAKER_02: And that sounds weird, but let's talk about why.
• 2:10
  SPEAKER_02: So if you have a working application, but it's not easy to maintain, what happens is it very quickly becomes something where you don't want to touch it.
• 2:20
  SPEAKER_02: It's like it's working and we kind of cross our fingers and tiptoe lightly around it, and no one wants to touch it.
• 2:27
  SPEAKER_02: Well, you can't make any changes then.
• 2:29
  SPEAKER_02: You can't grow the application, you can't modify it, you can't improve it because no one wants to touch it.
• 2:35
  SPEAKER_02: It's a fragile artifact.
• 2:37
  SPEAKER_02: You don't want that.
• 2:38
  SPEAKER_02: So you want an ease of maintenance.
• 2:41
  SPEAKER_02: You want to be able to be comfortable making changes.
• 2:44
  SPEAKER_02: Otherwise, your application will stop right where it's at.
• 2:47
  SPEAKER_02: Or it will break because it's not easy to make changes, and you make something incorrect in your change, and all of a sudden your application's down, and maybe even have users depending on it now, and all of a sudden everyone's mad at you, and you're frustrated, your boss is frustrated, your company is frustrated, your customers are frustrated, and it's just a mess.
• 3:07
  SPEAKER_02: And so you put it all back, and then your boss or your boss's boss comes to you and says, Don't ever do that again.
• 3:14
  SPEAKER_02: Well, that's a bad situation because now they're gonna want changes, but they don't want you to do what you just did, which was break everything.
• 3:22
  SPEAKER_02: So you want to make sure that you focus on ease of change.
• 3:26
  SPEAKER_02: That means having a good CICD process, that continuous integration, continuous deployment, where it's a known process, how you get from source code to running application.
• 3:39
  SPEAKER_02: And you have a development environment, a testing environment, a staging environment.
• 3:43
  SPEAKER_02: So you don't just have the it's working in production, that's all I have, because then you tiptoe around it again.
• 3:50
  SPEAKER_02: So make sure that your next thing, your first thing is to make sure it works.
• 3:55
  SPEAKER_02: Second thing is you have an ease of change, being able to easily make changes that work.
• 4:01
  SPEAKER_02: But then the number third, number three thing is that your application is efficient.
• 4:06
  SPEAKER_02: If you have an application that's super slow, your users don't want to use it.
• 4:11
  SPEAKER_02: They're gonna want to bypass it, they're gonna want to use something else, they're gonna want to try Excel or something else to try and get around the slowness of your application.
• 4:21
  SPEAKER_02: You don't want that.
• 4:22
  SPEAKER_02: You want your application to be performant, you want it to be helpful to users, you want to save the users' time.
• 4:29
  SPEAKER_02: So that efficiency then starts coming into play when you say, well, should I make more features and take them to production?
• 4:38
  SPEAKER_02: That's number one, get things to work, or should I make things more efficient?
• 4:42
  SPEAKER_02: That's number three, but it's still important.
• 4:45
  SPEAKER_02: So where is the the next change?
• 4:48
  SPEAKER_02: Maybe the first applic, first part of the application works, but now do I keep adding features or do I make it more efficient?
• 4:55
  SPEAKER_02: And this is where efficiency becomes a feature.
• 4:59
  SPEAKER_02: And this is what I want you to think about is that efficiency isn't just about making you feel better, making the application run better for the sake of running better.
• 5:10
  SPEAKER_02: It's a feature.
• 5:12
  SPEAKER_02: Let's take a blown-out of proportion example just to kind of illustrate this.
• 5:17
  SPEAKER_02: Imagine you have an application that a hundred users use.
• 5:22
  SPEAKER_02: We're gonna have two different features.
• 5:25
  SPEAKER_02: And I want you to evaluate and think through very carefully which feature you think we should add first.
• 5:31
  SPEAKER_02: So feature A is going to make the lives of two users much better.
• 5:38
  SPEAKER_02: It's gonna save them eight hours a week.
• 5:42
  SPEAKER_02: Okay?
• 5:42
  SPEAKER_02: That's a lot.
• 5:43
  SPEAKER_02: It's a full day per week per person.
• 5:46
  SPEAKER_02: So that's two full days a week is gonna save them.
• 5:50
  SPEAKER_02: Now imagine that you have feature B, and that's only gonna save your users 30 minutes per week per person, but it's 90 users.
• 6:03
  SPEAKER_02: Now, which feature should you implement?
• 6:05
  SPEAKER_02: The one that saves two users a full day per week each, or the one that saves 90 users out of the out of the hundred, saves 90 users half an hour per week each.
• 6:17
  SPEAKER_02: Well, if you do the math, you're saving 16 hours for feature A, or you're saving 45 hours for feature B.
• 6:25
  SPEAKER_02: That seemed kind of simple, and that is simplified and simplistic.
• 6:30
  SPEAKER_02: But when you think through, you say, well, it seems obvious that feature B is the way to go.
• 6:35
  SPEAKER_02: But feature B isn't about adding a new widget or adding a new page or adding a new system.
• 6:42
  SPEAKER_02: It's about making your overall application more efficient.
• 6:47
  SPEAKER_02: Because if you can save the majority of your users a little bit of time, it's better than saving a few users a lot of time, usually.
• 6:57
  SPEAKER_02: So when you look at it that way and you look at efficiency as a feature, it makes it much clearer which way you should go.
• 7:06
  SPEAKER_02: If efficiency is stopping users from doing something, that's like a bug.
• 7:12
  SPEAKER_02: If it's just slowing them down, that's a feature issue.
• 7:16
  SPEAKER_02: And it's something that you should be put into your evaluation structure just like any other feature.
• 7:23
  SPEAKER_02: So if it's slowing down 10 users and it's costing them eight hours each per week, that's 80 hours per week that you're costing with this slowdown here.
• 7:34
  SPEAKER_02: But if the other feature you want to implement is going to save 20 users eight hours a week, well, that's 160 hours.
• 7:44
  SPEAKER_02: So that means that your efficiency isn't the highest priority, it's this other feature over here.
• 7:51
  SPEAKER_02: So by putting that evaluation in place, you can start to evaluate your efficiency as a feature.
• 7:59
  SPEAKER_02: Now, it's not always going to be apples to apples.
• 8:02
  SPEAKER_02: Maybe it's not just saving time, maybe it's adding new abilities, or it's doing something else that's necessary, bug fixes or whatever else.
• 8:11
  SPEAKER_02: But that gives you a better idea of how to look at efficiency as opposed to changes or new features in your application.
• 8:20
  SPEAKER_02: Look at efficiency as just one more feature of your application.
• 8:25
  SPEAKER_02: Because that's the goal of your application, is to give the users something.
• 8:31
  SPEAKER_02: Give them something that they can use and give them something that they can use well.
• 8:35
  SPEAKER_02: Well, efficiency is part of use it well.
• 8:40
  SPEAKER_02: So think that through when you're thinking about what's important to do next.
• 8:45
  SPEAKER_02: Make sure you evaluate carefully and don't go too far down the rabbit hole of it needs to be super efficient when maybe you're saving a few seconds a month or a few seconds a day, even.
• 8:59
  SPEAKER_02: Maybe that's not necessary to do compared to making it easier to maintain.
• 9:05
  SPEAKER_02: Because maybe there's some code you could write that's more efficient by a little bit, but it's harder to maintain.
• 9:12
  SPEAKER_02: Well, remember maintenance number two.
• 9:14
  SPEAKER_02: Ease of maintenance is the second most important priority of your application.
• 9:19
  SPEAKER_02: So think that one through and say, well, maybe that little bit of efficiency isn't worth it compared to what I have to do to reduce my ease of maintenance.
• 9:30
  SPEAKER_02: All right.
• 9:30
  SPEAKER_02: So that's how I think about efficiency in terms of when to do it and when to uh spend more time on it with your application.
• 9:40
  SPEAKER_02: I hope that answered your question.
• 9:41
  SPEAKER_02: Again, if you have a question, go to suggestions.iamtimcorey.com, leave that suggestion, or upvote one that's already there.
• 9:48
  SPEAKER_02: This is the primary place where I pull questions from to answer on dev questions.
• 9:54
  SPEAKER_02: Thanks for listening, and as always, I am Tim Corey.
• 9:57
  SPEAKER_01: Thank you for joining us for this episode of Dev Questions.
• 10:00
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 10:03
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 10:11
  SPEAKER_01: You can also send your questions to questions at IamTimcore.com.
• 10:16
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 10:23
  SPEAKER_01: When you're ready to learn to think and code like a professional developer, head over to IamtimCore.com and enroll in a course.