Latest / DevQuestions with Tim Corey / 109 How Do I Balance Design Patterns and Code Complexity?

Transcript

109 How Do I Balance Design Patterns and Code Complexity? · 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:24
  SPEAKER_02: How do I balance code complexity with design patterns?
• 0:29
  SPEAKER_02: Meaning, how do I figure out where the balance is between a simple application and one that follows well-architected patterns?
• 0:37
  SPEAKER_02: So, this is the question was asked on the suggestion site, and I thought it'd be a great one to dive into in today's episode of DevQuestions.
• 0:44
  SPEAKER_02: Now, if you have a suggestion for a future question, go to suggestions.imtimcorey.com, ask it there, and hopefully you'll see your question answered in a future episode of DevQuons.
• 0:56
  SPEAKER_02: Now, design patterns, let's talk first their definition.
• 1:00
  SPEAKER_02: It's a strategy to solve a common problem.
• 1:03
  SPEAKER_02: So there's lots of design patterns out there.
• 1:06
  SPEAKER_02: So which ones do you use?
• 1:08
  SPEAKER_02: How many do you use?
• 1:10
  SPEAKER_02: Can you overuse, kind of like what we talked about the previous week about overusing principles?
• 1:15
  SPEAKER_02: Can we overuse design patterns?
• 1:17
  SPEAKER_02: Can we use too many of them?
• 1:19
  SPEAKER_02: Because there's lots of them.
• 1:21
  SPEAKER_02: Do we use only three in our application?
• 1:23
  SPEAKER_02: Five, seven?
• 1:24
  SPEAKER_02: And a lot of the same principles you talked about last week will apply here.
• 1:28
  SPEAKER_02: Go check out that episode if you want some of the foundational stuff.
• 1:32
  SPEAKER_02: But let's talk specifically about design principles.
• 1:36
  SPEAKER_02: So it's a strategy to solve a common problem.
• 1:39
  SPEAKER_02: All right?
• 1:40
  SPEAKER_02: That's what its purpose is.
• 1:42
  SPEAKER_02: All right.
• 1:43
  SPEAKER_02: So what we need to do is a cost-benefit analysis.
• 1:48
  SPEAKER_02: And this is a business term that's been around for a while, our business phrase, but let's talk about this in real-world examples.
• 1:54
  SPEAKER_02: So I used to live in Pennsylvania.
• 1:56
  SPEAKER_02: And in Pennsylvania, the winters got a little miserable.
• 1:59
  SPEAKER_02: I wasn't really a big fan of cold and they got quite cold.
• 2:03
  SPEAKER_02: And we got a lot of snow as well.
• 2:05
  SPEAKER_02: So there might be a foot or two of snow outside, and it might be 20 or 15 degrees Fahrenheit for those of you that use Celsius.
• 2:15
  SPEAKER_02: Sorry, I don't know the conversion for that.
• 2:17
  SPEAKER_02: But cold, real cold.
• 2:18
  SPEAKER_02: How about that?
• 2:19
  SPEAKER_02: Um, so when I was thinking about going to get the mail, which is about 50 feet away from my front door, I might put on a pair of boots and a coat and run out, get the mail, and come back in.
• 2:33
  SPEAKER_02: Now, if I am going to go out and shovel the driveway, and my driveway took a long time to shovel, it was quite uh large just because of the space it was uh set up for parking cars.
• 2:45
  SPEAKER_02: Well, I would spend three, four, five hours outside shoveling snow.
• 2:51
  SPEAKER_02: I would dress differently than going to the mailbox.
• 2:54
  SPEAKER_02: I would wear gloves, I would wear multiple layers of pants, I would wear a sweatshirt and a coat, I would make sure I had a hoodie on so I could put something over my hand, my head as well as my head needs a lot of protection, um, a hat as well, and I would really bundle up well to go outside.
• 3:14
  SPEAKER_02: I might even wear a scarf.
• 3:16
  SPEAKER_02: Why didn't I do that to go to the mailbox?
• 3:20
  SPEAKER_02: It's the same temperature outside, there's the same amount of snow outside, but yet I dress differently for being out there for five hours versus just going the 50 feet and back.
• 3:32
  SPEAKER_02: Well, the reason why is because I did a cost-benefit analysis.
• 3:36
  SPEAKER_02: Yes, I was going to get a little chilly with going to the mailbox, but I wasn't gonna be out there very long.
• 3:44
  SPEAKER_02: And so it didn't make sense for me to find an extra pair, an extra layer to put it on for my pants and put extra socks on and get my hat on and my hoodie on and an extra coat on and get everything zipped up.
• 3:58
  SPEAKER_02: It would, it takes me 10 minutes to get ready to go outside when I'm layering up like that.
• 4:03
  SPEAKER_02: But when I run to the mailbox, I don't even lace my shoes.
• 4:06
  SPEAKER_02: I just stick my laces in my boots and wear them on untied because I'm doing something really quick, no big deal.
• 4:14
  SPEAKER_02: I sometimes don't even wear a coat.
• 4:16
  SPEAKER_02: It's yes, it's cold out there, but I'm not gonna be out there that long.
• 4:19
  SPEAKER_02: I did a cost-benefit analysis and found that it's just not worth tracking down all that stuff, layering all up, spending all that time when I'm not gonna get that cold because the duration is so short.
• 4:33
  SPEAKER_02: As opposed to when I'm gonna go shovel, yes, I need all that because that 10 minutes of layering up will save me from getting frozen when I go out there to shovel for hours.
• 4:47
  SPEAKER_02: So that's the that's what a cost-benefit analysis is, where you say, is the pain or the time or the energy or the effort is that worth the the reward from doing so.
• 5:02
  SPEAKER_02: That's all I'm doing.
• 5:03
  SPEAKER_02: So when it comes to writing code, you should think through that same cost benefit analysis.
• 5:10
  SPEAKER_02: So let's just say you're thinking about implementing a design pattern.
• 5:16
  SPEAKER_02: Whatever that pattern might be.
• 5:18
  SPEAKER_02: Well, if you are using a microservice or building a microservice, that might be 50 lines of code or 100 lines of code at max.
• 5:28
  SPEAKER_02: Well, that's not a lot of code.
• 5:31
  SPEAKER_02: Maybe you don't need to have a principle or a pattern there, or three patterns or five patterns.
• 5:36
  SPEAKER_02: Maybe you just need to just write the code.
• 5:38
  SPEAKER_02: Whereas if you're writing a monolith, which might be a massive application with hundreds of thousands of lines of code, yeah, you need to use some patterns to help manage that and help solve common problems.
• 5:54
  SPEAKER_02: Because those problems are big, they're magnified when you have a million lines of code as opposed to a hundred lines of code.
• 6:03
  SPEAKER_02: So there's that benefit of saying it doesn't really benefit us to do this pattern because it doesn't give us a whole lot.
• 6:14
  SPEAKER_02: Okay.
• 6:15
  SPEAKER_02: So that's the idea of you know, how do you set this up?
• 6:19
  SPEAKER_02: Another example might be when you're building a microservice, we might only have one project.
• 6:27
  SPEAKER_02: Okay, so you'll have one project that's just the code for your microservice.
• 6:32
  SPEAKER_02: In fact, an Azure function app is a great example of a microservice where it's one file in one project in one application.
• 6:43
  SPEAKER_02: That's all it is.
• 6:44
  SPEAKER_02: It's one method, really.
• 6:45
  SPEAKER_02: I mean, there's a few supporting things to get started, but it's one method.
• 6:50
  SPEAKER_02: Now you can add more, you can add a class library, you can add um dependency injection, you can add all this other stuff around it, but really do you need that?
• 7:02
  SPEAKER_02: In most cases, probably not.
• 7:04
  SPEAKER_02: Now, in some cases, you might.
• 7:06
  SPEAKER_02: But in most cases, you just need that one method because it's doing something simple.
• 7:11
  SPEAKER_02: But if you have this massive million-line project, maybe it's broken up into a hundred projects.
• 7:20
  SPEAKER_02: Maybe you have a hundred different project files on your solution.
• 7:24
  SPEAKER_02: This is a very common thing in larger businesses to have these massive sets of projects where you're not just opening up one project to two projects inside your solution, you're opening up a hundred or two hundred or eight hundred.
• 7:38
  SPEAKER_02: And that seems overwhelming, but when you're talking about the size of the application, it might make sense.
• 7:45
  SPEAKER_02: So you need to think through what's the benefit here versus the cost.
• 7:51
  SPEAKER_02: So when thinking through patterns, we should think through does it make my application better, easier to understand, easier to maintain?
• 8:01
  SPEAKER_02: Okay, does it make my life better or does it not?
• 8:06
  SPEAKER_02: And then do you have a problem or do you have a solution in need of a problem?
• 8:12
  SPEAKER_02: Okay, I hear a lot of people who are learning design patterns, which is a pretty common thing to learn in school, they learn these design patterns and say, okay, where can I use this?
• 8:23
  SPEAKER_02: How do I use this?
• 8:24
  SPEAKER_02: Show me using this.
• 8:25
  SPEAKER_02: I want to use this.
• 8:26
  SPEAKER_02: And that can be great, but it might not be the right approach.
• 8:31
  SPEAKER_02: Because then what you do is you say, okay, I've got this cool tool, I want to start using it.
• 8:37
  SPEAKER_02: Instead of saying, I have a problem, is there a tool that can help me?
• 8:42
  SPEAKER_02: That's the difference.
• 8:43
  SPEAKER_02: So when you approach learning software development as I've learned all these design patterns, then what you start doing is saying, I have all these tools, let's use them.
• 8:54
  SPEAKER_02: And you end up introducing complexity, making things worse instead of better, because you've got a solution or a set of solutions, and you're in search of problems for them to solve.
• 9:06
  SPEAKER_02: And so you say, oh, that pattern applies here, that pattern applies here.
• 9:10
  SPEAKER_02: It might.
• 9:11
  SPEAKER_02: And that can work, but is it right for your application?
• 9:15
  SPEAKER_02: Okay, take a step back.
• 9:17
  SPEAKER_02: Does it make my life easier?
• 9:19
  SPEAKER_02: Does it make my code better?
• 9:21
  SPEAKER_02: Does it make it easier to maintain?
• 9:23
  SPEAKER_02: Because if it doesn't do these things, then yes, it can fit there.
• 9:28
  SPEAKER_02: That doesn't mean you should use it there.
• 9:30
  SPEAKER_02: Okay.
• 9:31
  SPEAKER_02: This is the reason why I haven't taught design patterns per se in the C sharp master course.
• 9:39
  SPEAKER_02: Because that's really, in my opinion, not the time to learn them.
• 9:45
  SPEAKER_02: The time to learn them is after you have mastered working with C sharp.
• 9:52
  SPEAKER_02: Because then you can say, okay, I've learned how to build applications.
• 9:56
  SPEAKER_02: I've built multiple applications, and I'm starting to see some pain.
• 10:01
  SPEAKER_02: I'm starting to see some common things that I'm I'm running into where I'm going, ooh, this is this is hard to work with.
• 10:09
  SPEAKER_02: This is complex.
• 10:10
  SPEAKER_02: And then you learn design patterns, go, there's a design pattern that makes my life easier here.
• 10:17
  SPEAKER_02: And you apply it.
• 10:18
  SPEAKER_02: And all of a sudden, you take your knowledge of C sharp and it becomes better and more rich and full because you go, okay, I know that I've seen this problem, and now I have found a way to make it better, to make my code more efficient, to make my life easier, to just make something that is improves my code's overall quality.
• 10:44
  SPEAKER_02: Okay.
• 10:45
  SPEAKER_02: So that's when you should really learn about design patterns, and really when you should start applying them, is after you understand the problems.
• 10:54
  SPEAKER_02: So you properly apply the solutions where needed.
• 10:58
  SPEAKER_02: Because sometimes you may look at a code and say, it doesn't have any problems.
• 11:02
  SPEAKER_02: It's running great, it works great, it's simple, it's easy to understand.
• 11:06
  SPEAKER_02: I don't need to apply this pattern to make it better.
• 11:12
  SPEAKER_02: Okay, an example of this is the mediator pattern.
• 11:16
  SPEAKER_02: This can very easily get blown out of control.
• 11:20
  SPEAKER_02: Where you might have lots and lots and lots of classes and maybe lots and lots of projects that have broken everything apart into little pieces.
• 11:31
  SPEAKER_02: But now when you try to see the flow of your application and try and track down a bug, you have to go through 18 different projects and 35 different classes, and things are loosely coupled in a way that's actually hard to maintain.
• 11:48
  SPEAKER_02: That might not be right for every application.
• 11:51
  SPEAKER_02: Okay, so maybe you take a step back and go, that's not right for this application.
• 11:56
  SPEAKER_02: It is right for really big applications or really complex applications where you're making things simpler.
• 12:03
  SPEAKER_02: But that's a high complexity to start with.
• 12:05
  SPEAKER_02: Again, remember, if it's a high complexity, you have to have even higher complexity that you're reducing because of what you're adding.
• 12:13
  SPEAKER_02: Okay.
• 12:14
  SPEAKER_02: So you may think that through and say, oh, you know what?
• 12:18
  SPEAKER_02: Yeah, I've learned it and I know it, but I'm not going to just solve every problem with this tool because this tool isn't right for every situation.
• 12:27
  SPEAKER_02: All right.
• 12:28
  SPEAKER_02: So those are the things to think through when you are looking at design patterns.
• 12:32
  SPEAKER_02: Do a cost-benefit analysis.
• 12:35
  SPEAKER_02: Is the cost worth the benefit?
• 12:39
  SPEAKER_02: Okay.
• 12:40
  SPEAKER_02: So if you spent all day working and you got a dollar, well, you're making money, right?
• 12:46
  SPEAKER_02: Yeah, but is it worth it?
• 12:48
  SPEAKER_02: Okay.
• 12:49
  SPEAKER_02: Whereas maybe if you spent an hour working and got$100, you go, yeah, it was worth the struggle because I got paid a lot.
• 12:58
  SPEAKER_02: So there's that cost-benefit analysis.
• 13:00
  SPEAKER_02: Do that with your code.
• 13:02
  SPEAKER_02: Does it make, does the cost of implementing that item, that design pattern, does it is the cost of the add complexity, the added maintenance uh work, is that worth the benefit it gives you in the long run?
• 13:18
  SPEAKER_02: All right.
• 13:18
  SPEAKER_02: So that's my answer to the question.
• 13:20
  SPEAKER_02: I hope that answered your question.
• 13:21
  SPEAKER_02: If you have a question, go to suggestions.imtimcorey.com, ask your question there, and hopefully you'll see your question answered on a future episode of Dev Questions.
• 13:32
  SPEAKER_02: Thanks for listening.
• 13:32
  SPEAKER_02: And as always, I am Tim Corey.
• 13:35
  SPEAKER_01: Thank you for joining us for this episode of Dev Questions.
• 13:38
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 13:41
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 13:48
  SPEAKER_01: You can also send your questions to questions at IamtimCore.com.
• 13:54
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 14:01
  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.