Latest / DevQuestions with Tim Corey / 211. When To Break The Rules as a Developer

Transcript

211. When To Break The Rules as a Developer · 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: As you learn software development, you'll start to pick up rules and systems like dry, don't repeat yourself, or the solid principles, or any number of design patterns.
• 0:36
  SPEAKER_02: Things like implementing dependency injection and logging also become fairly standard rules.
• 0:42
  SPEAKER_02: So when is it okay to break the rules?
• 0:45
  SPEAKER_02: Are there times when developers should ignore the best practices?
• 0:48
  SPEAKER_02: Or are best practices too important to ignore?
• 0:52
  SPEAKER_02: These are the questions we're going to tackle in today's episode of DevQutions.
• 0:58
  SPEAKER_02: So is it okay to break the rules?
• 1:01
  SPEAKER_02: The answer is yes, which probably shocks you that I didn't say it depends.
• 1:05
  SPEAKER_02: But here's the deal: the key is when.
• 1:08
  SPEAKER_02: And the answer to that is it depends.
• 1:11
  SPEAKER_02: Okay, so it's yes, it's okay to break the rules, but when is it depends?
• 1:19
  SPEAKER_02: Okay, so let's talk about when to break the rules.
• 1:23
  SPEAKER_02: Now, normally I give you a list of answers or a list of ideas, but in this case, I'm gonna give you a clear, simple principle to help guide you.
• 1:32
  SPEAKER_02: And then we'll talk about some examples to help show you that principle.
• 1:37
  SPEAKER_02: So the principle is to ask the question does this rule make my life simpler?
• 1:45
  SPEAKER_02: Now note that I did not say your application, I said your life.
• 1:50
  SPEAKER_02: I also didn't say better, I said simpler.
• 1:54
  SPEAKER_02: So let's talk about making your life simpler.
• 1:59
  SPEAKER_02: So, for example, that might mean making your application easier to maintain.
• 2:05
  SPEAKER_02: For instance, a single file.
• 2:07
  SPEAKER_02: A single file is super easy to maintain as compared to having files all over the place.
• 2:14
  SPEAKER_02: That's easier to maintain.
• 2:16
  SPEAKER_02: Not just for you, again, for your team.
• 2:19
  SPEAKER_02: Another example might be making your code easier to read through.
• 2:24
  SPEAKER_02: So less navigating to get to the logic.
• 2:28
  SPEAKER_02: You may have seen applications where you have a method, but that method calls another method, which you go hunt that down, that calls another method, which calls another method, and you're like going 10, 12, 15 layers deep to find out what that code is, or part of that code that the original call was talking about.
• 2:48
  SPEAKER_02: And you have to keep all that in your head.
• 2:50
  SPEAKER_02: That's a lot to navigate through compared to having the code in one spot, in one method.
• 2:55
  SPEAKER_02: So making your code easier to read through is another way.
• 3:01
  SPEAKER_02: Now, also it might mean making your code more simplistic.
• 3:06
  SPEAKER_02: For example, easier for others to maintain.
• 3:09
  SPEAKER_02: Sometimes you might know how to, for example, if you're trying to do a comparison to see, hey, does this word, is this word matched?
• 3:20
  SPEAKER_02: Okay, so maybe you're looking for a specific word and you say, I can write this really complicated regular expression, a regex, in order to identify all the possibilities.
• 3:31
  SPEAKER_02: That's complicated, but it will work.
• 3:35
  SPEAKER_02: But how do you debug that in case you realize it's not quite right?
• 3:39
  SPEAKER_02: Well, you have to figure out what each bit of the regex is doing and so on.
• 3:43
  SPEAKER_02: Or you could maybe make that simpler by saying, if it's this or if it's this, then it matches.
• 3:50
  SPEAKER_02: Well, that's a really simple way to identify because it's it's easier to read, which means maybe more people could maintain it rather than just the few who know regular expressions well.
• 4:02
  SPEAKER_02: So far it sounds like what I'm advocating for is a monolith application with all the code in one file.
• 4:09
  SPEAKER_02: But remember, I didn't say to put all your code one file.
• 4:15
  SPEAKER_02: I said, does the rule make my life simpler?
• 4:20
  SPEAKER_02: Have you ever opened a code file that has 2,000 lines of code?
• 4:26
  SPEAKER_02: I have quite a bit, unfortunately.
• 4:29
  SPEAKER_02: When you do, is that simpler?
• 4:32
  SPEAKER_02: Well, no, because you've got all this mess to kind of sort through and figure out what's going on.
• 4:38
  SPEAKER_02: And it's, you know, trying to track it down.
• 4:41
  SPEAKER_02: And if you find out, you know, there's a code bit that may not be working, you have to figure out is that code repeated somewhere else?
• 4:49
  SPEAKER_02: And because it probably is.
• 4:51
  SPEAKER_02: And so then you have to figure out all those places, make sure you get them all, and they might be a little bit different in each spot.
• 4:57
  SPEAKER_02: So that's not simpler, but that's the balance that you have to hit when you're looking at your code and following rules or breaking rules, is looking at that simplicity.
• 5:11
  SPEAKER_02: Sometimes simplicity means multiple files.
• 5:15
  SPEAKER_02: Sometimes simplicity means having some abstractions.
• 5:19
  SPEAKER_02: Sometimes simplicity means that you have multiple projects, but there's that balance of does it make it simpler or does it make it more complex?
• 5:30
  SPEAKER_02: What I'm doing.
• 5:31
  SPEAKER_02: So let's talk through some examples because I think this will help kind of drive this home.
• 5:38
  SPEAKER_02: So, first example, let's say you have a person model.
• 5:41
  SPEAKER_02: Okay, the person model has a first name and a last name.
• 5:44
  SPEAKER_02: It's all it has in there, right?
• 5:46
  SPEAKER_02: And you use this person model in your data access class where you pull the first and last name from a database table somewhere.
• 5:55
  SPEAKER_02: Okay, but you also use that person model when you're capturing first and last name from a form on your web application, let's say.
• 6:04
  SPEAKER_02: So you could put that model in a shared class library that both projects could could access.
• 6:12
  SPEAKER_02: That makes it simpler.
• 6:14
  SPEAKER_02: Because then you only have the model in one place, dry, don't repeat yourself.
• 6:20
  SPEAKER_02: So therefore both can access it, right?
• 6:23
  SPEAKER_02: Well, that in theory fulfills the principle of dry.
• 6:28
  SPEAKER_02: But does it make your life truly simpler?
• 6:31
  SPEAKER_02: Well, let's evaluate.
• 6:34
  SPEAKER_02: There's a shared project we have to maintain now.
• 6:37
  SPEAKER_02: Okay?
• 6:38
  SPEAKER_02: A third project, potentially at least, but a third project, does it make it much more difficult?
• 6:44
  SPEAKER_02: Probably not, but there is a third project to maintain.
• 6:48
  SPEAKER_02: But if I decide to add validation on the model, where I say, you know, please enter your first the first name or please make sure the first name is at least three characters, you know, in an error message, and I put that as part of the validation logic on the model, I'm putting UI-specific language on a model that the database uses.
• 7:09
  SPEAKER_02: Or maybe another user interface uses that has different UI-specific language.
• 7:16
  SPEAKER_02: Now I've got some complexity here.
• 7:18
  SPEAKER_02: Do I have some kind of gating mechanism in my validation logic that says, well, if you're being called from WPF, then do this, you're being called from Blazor, do that.
• 7:29
  SPEAKER_02: That seems more complex, right?
• 7:31
  SPEAKER_02: So now you've got to say, is it making it simpler or not?
• 7:37
  SPEAKER_02: Also, there's now a coupling between your UI and your class library.
• 7:42
  SPEAKER_02: Both have to be recompiled if a shared library changes.
• 7:46
  SPEAKER_02: So is that third library the better option?
• 7:52
  SPEAKER_02: Because that's kind of the rule, right?
• 7:53
  SPEAKER_02: The rule is you create a shared library.
• 7:56
  SPEAKER_02: But sometimes the answer is no, you don't.
• 8:01
  SPEAKER_02: But I'm not saying never do that.
• 8:03
  SPEAKER_02: I'm saying that's that's the rule because it happens a lot, because that works in a lot of cases.
• 8:09
  SPEAKER_02: But it doesn't work in every case.
• 8:11
  SPEAKER_02: So you have to figure out when's it time to break that rule?
• 8:15
  SPEAKER_02: Well, when it makes your code or potentially makes your code more complicated, when it makes your setup more complicated.
• 8:22
  SPEAKER_02: Sometimes the easier solution is to have two models, one in the UI, one in the class library, that both have the properties first name and last name.
• 8:33
  SPEAKER_02: I mean, that's not hard, right?
• 8:35
  SPEAKER_02: Like copying and pasting, that's not real hard.
• 8:39
  SPEAKER_02: You may say, well, Tim, yeah, but we copy and paste code, we're violating dry.
• 8:44
  SPEAKER_02: Kind of.
• 8:45
  SPEAKER_02: But when it comes to UI models versus you know DTOs or data access models, they're they can deviate, they can be different.
• 8:55
  SPEAKER_02: UI models can have different validation.
• 8:58
  SPEAKER_02: So all of a sudden they're not repeating themselves, they're different.
• 9:01
  SPEAKER_02: Plus, the fact you're not doing logic here, you're just doing properties.
• 9:04
  SPEAKER_02: There's a difference.
• 9:06
  SPEAKER_02: So you have to think through which do I do?
• 9:10
  SPEAKER_02: Is it easier just to copy and paste and have one less project to maintain, a less coupling, and potentially save myself an issue of having UI logic in the data access library?
• 9:25
  SPEAKER_02: Or is it better to have that shared project?
• 9:29
  SPEAKER_02: Again, you get to choose based upon what is simpler for your situation.
• 9:36
  SPEAKER_02: Number two, example, let's say you're building an Azure function.
• 9:40
  SPEAKER_02: And that Azure function is going to send an email to a user when it's triggered.
• 9:44
  SPEAKER_02: Okay?
• 9:45
  SPEAKER_02: Real simple.
• 9:47
  SPEAKER_02: Dependency injection is a valuable tool that makes code easier to maintain and more loosely coupled.
• 9:55
  SPEAKER_02: But does it make my life simpler in this case?
• 9:59
  SPEAKER_02: Okay, so the answer is it depends.
• 10:04
  SPEAKER_02: And you have to evaluate if dependency injection is the right choice or not.
• 10:10
  SPEAKER_02: For example, most Azure functions really should be with 100 lines of code or less.
• 10:17
  SPEAKER_02: I say should be because we all know we violate these rules.
• 10:21
  SPEAKER_02: But that's the purpose of an Azure function is to be tiny, to be small, to be something that runs very, very quickly.
• 10:28
  SPEAKER_02: Well, in 100 lines of code, do I need to have dependency injection?
• 10:34
  SPEAKER_02: Or is it okay if I have my dependencies in the code?
• 10:38
  SPEAKER_02: Because part of dependency injection is to you kind of surface your dependencies and say, these are the things I depend on.
• 10:45
  SPEAKER_02: But when you have just 100 lines of code, you can see it really easily.
• 10:49
  SPEAKER_02: Also, depend uh Azure functions most often are accomplished in one method.
• 10:56
  SPEAKER_02: So you have one method that has dependencies.
• 11:00
  SPEAKER_02: Maybe you don't need it.
• 11:03
  SPEAKER_02: If you don't have it, you don't have to do a setup of dependency injection.
• 11:06
  SPEAKER_02: You don't have to do the injection, all the rest of the stuff.
• 11:10
  SPEAKER_02: You don't have to have that system running in your function every time it starts up.
• 11:15
  SPEAKER_02: It can be much quicker, much more efficient if you don't have all that additional startup overhead.
• 11:22
  SPEAKER_02: And it can make sense to just have inline dependencies with the new instantiation right in line.
• 11:31
  SPEAKER_02: So even that, it depends because what is simpler in Azure Function might not be simpler in a larger application.
• 11:42
  SPEAKER_02: So again, you can look at the quote unquote rule of use depending dependency injection because it makes your life easier, and say, well, yes, generally it does, which is why it's generally accepted.
• 11:57
  SPEAKER_02: But there are specific times when it doesn't make my life simpler.
• 12:02
  SPEAKER_02: Therefore, I don't use it in those times.
• 12:06
  SPEAKER_02: Another example: design patterns.
• 12:09
  SPEAKER_02: Design patterns are the buzzword of software development.
• 12:13
  SPEAKER_02: But what they are is the result of real-world experience in building applications.
• 12:19
  SPEAKER_02: People have built applications and said, hey, we see this thing as being useful, this pattern.
• 12:25
  SPEAKER_02: And so they've codified these into named patterns that we say, hey, this pattern is helpful here, and this pattern is helpful there.
• 12:35
  SPEAKER_02: But if I'm building a console application to automate a process, should I implement all the design patterns?
• 12:42
  SPEAKER_02: Well, that sounds silly, right, when you put it that way.
• 12:46
  SPEAKER_02: But does that mean I don't need any patterns?
• 12:49
  SPEAKER_02: The answer is that the principle we are talking about, does the particular pattern make my life simpler?
• 12:58
  SPEAKER_02: So maybe the facade pattern can be used to wrap an API so you that your application needs a call.
• 13:05
  SPEAKER_02: There's a lot of APIs that are really squirrely in how they work and they even change often.
• 13:09
  SPEAKER_02: But maybe you create a wrapper around that to make it easier to just say, you know, do work, do work, and it just does the work.
• 13:18
  SPEAKER_02: You don't have to worry about how to implement a specific API.
• 13:22
  SPEAKER_02: You have the facade that wraps around it that makes your life easier.
• 13:26
  SPEAKER_02: That could be a good thing.
• 13:28
  SPEAKER_02: Or maybe use a factory pattern to generate the objects your application needs to do the work.
• 13:34
  SPEAKER_02: So maybe you generate different objects to do different work, and you can use the factory pattern to make that easier.
• 13:40
  SPEAKER_02: So there's times when those patterns might apply in your application.
• 13:44
  SPEAKER_02: But that doesn't mean you need, for example, CQRS or those kinds of things.
• 13:49
  SPEAKER_02: You don't need everything that patterns provide.
• 13:54
  SPEAKER_02: You can identify the ones that make your application simpler.
• 14:00
  SPEAKER_02: Number four, and the last example I'll use today is let's say you want to build a complex application.
• 14:06
  SPEAKER_02: Let's say you're building, I don't know, a student information system, and you decide that you're going to map this whole thing out.
• 14:15
  SPEAKER_02: Do you build a monolith or do you build a microservice-based system?
• 14:20
  SPEAKER_02: And I hear this get thrown out a lot because I've heard people that are very much set on I know which way is better.
• 14:28
  SPEAKER_02: And often I hear microservice-based system.
• 14:32
  SPEAKER_02: So let's talk about this because it does depend and you need to figure out what's going to make your life simpler.
• 14:41
  SPEAKER_02: So a monolith will be easy to read through and it's gonna be more simplistic.
• 14:46
  SPEAKER_02: If your UI needs something, then it makes a method call and gets it.
• 14:51
  SPEAKER_02: A microservice-based system will have multiple easy to maintain applications that are easy to update.
• 14:59
  SPEAKER_02: So that's a benefit for them.
• 15:02
  SPEAKER_02: Now, the downside of a monolith is that it's harder to update and it can be more complex internally.
• 15:09
  SPEAKER_02: So, for example, if you're gonna update a part of a monolith, well, you have to take the whole thing down in order to put the new code in because it's a monolith, it's it's one block.
• 15:20
  SPEAKER_02: The downside of microservices are that they're gonna have more connections and more systems to maintain, and they're more complex in their connections between services.
• 15:32
  SPEAKER_02: So, on one hand, you've got a monolith that you know has some upsides and downsides, but microservices have upsides and downsides.
• 15:41
  SPEAKER_02: So, what's right for you?
• 15:43
  SPEAKER_02: You choose the one that is simpler for you and for your life.
• 15:48
  SPEAKER_02: So, in the end, often monoliths are the simpler option.
• 15:52
  SPEAKER_02: You have to deal with one repo, one database, one deployment, and one code base.
• 15:58
  SPEAKER_02: And you get what you want through method calls.
• 16:02
  SPEAKER_02: That's pretty simple.
• 16:04
  SPEAKER_02: Now, the only time that I see microservices becoming simpler than that is when your monolith is extremely complicated and hard to manage.
• 16:15
  SPEAKER_02: So, in that case, sometimes a microservice-based architecture could relieve some of that complexity.
• 16:25
  SPEAKER_02: But often, the simpler option is to make your monolith better, because you write good code or bad code in either scenario.
• 16:34
  SPEAKER_02: So, write better code for your monolith sometimes saves you from needing to go with a microservice solution.
• 16:42
  SPEAKER_02: The key thing here is you're looking at adding complexity with a design pattern or with any kind of rule or or principle, you're most likely going to add complexity.
• 16:58
  SPEAKER_02: But is that add complexity making your life simpler?
• 17:03
  SPEAKER_02: Is it making it easier for you to debug?
• 17:05
  SPEAKER_02: Is it making it easier for you to update?
• 17:08
  SPEAKER_02: Is it making it easier for you to maintain?
• 17:11
  SPEAKER_02: Is it making it easier for you to give this to somebody else to do?
• 17:15
  SPEAKER_02: These are all things to evaluate when you're looking at should I keep a rule or break a rule?
• 17:22
  SPEAKER_02: Do not just follow rules blindly.
• 17:26
  SPEAKER_02: Do not.
• 17:27
  SPEAKER_02: My best piece of advice for you is know why you're making every decision you do.
• 17:34
  SPEAKER_02: Not just because Tim told you, not just because some other random person on the internet says the way to do it, not just because Microsoft said do this.
• 17:45
  SPEAKER_02: Know why you're doing it.
• 17:47
  SPEAKER_02: All right.
• 17:48
  SPEAKER_02: That's going to help you identify the simpler option.
• 17:53
  SPEAKER_02: Now, as a software developer, you need to know when to break the rules.
• 17:58
  SPEAKER_02: If you don't, you're gonna make some poor decisions.
• 18:01
  SPEAKER_02: Knowing when to break the rules only comes through experience.
• 18:05
  SPEAKER_02: And that's why practice is so important.
• 18:08
  SPEAKER_02: You make the mistakes on projects that don't matter rather than in production systems where the mistakes can sometimes not be easily undone.
• 18:18
  SPEAKER_02: I've seen too many people think that design patterns are requirements and they put them in and make a system complex.
• 18:26
  SPEAKER_02: And it's too late if it gets into production sometimes, because it's very, very hard to unwind all of that when the system is actively running.
• 18:36
  SPEAKER_02: So I would encourage you to practice.
• 18:39
  SPEAKER_02: Practice will help you figure out these things.
• 18:42
  SPEAKER_02: Figure out when breaking your rule is actually simpler in the long run.
• 18:47
  SPEAKER_02: Just make sure you don't think that simple means just for today.
• 18:52
  SPEAKER_02: We're talking about long term, not just even for you, but in general, is it simpler?
• 18:59
  SPEAKER_02: But does it make your life simpler?
• 19:01
  SPEAKER_02: Okay.
• 19:02
  SPEAKER_02: So there's a lot to evaluate.
• 19:05
  SPEAKER_02: Yes, rules are there because generally they are the better option.
• 19:10
  SPEAKER_02: Generally, if you understand what the rule actually means, they apply.
• 19:15
  SPEAKER_02: And generally, they will make your application simpler.
• 19:20
  SPEAKER_02: But it's only when you first understand the rule itself and why it even exists, because a lot of design patterns don't exist for every situation.
• 19:32
  SPEAKER_02: And they'll say that.
• 19:33
  SPEAKER_02: But then even knowing that, the next thing is knowing your application and knowing if that change will make things simpler or not in the long term.
• 19:45
  SPEAKER_02: Okay?
• 19:46
  SPEAKER_02: So it takes a lot of work, it takes a lot of practice, but rules are meant to be broken in software development.
• 19:53
  SPEAKER_02: That's why you call them patterns or principles.
• 19:56
  SPEAKER_02: They're not hard and fast rules, they're not laws.
• 20:00
  SPEAKER_02: Okay?
• 20:01
  SPEAKER_02: You can break them if it makes sense, but just understand when it makes sense.
• 20:07
  SPEAKER_02: Right?
• 20:08
  SPEAKER_02: Thanks for watching and thanks for listening.
• 20:10
  SPEAKER_02: And as always, I am Tim Corey.
• 20:13
  SPEAKER_01: Thank you for joining us for this episode of Dev Questions.
• 20:16
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 20:20
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 20:27
  SPEAKER_01: You can also send your questions to questions at IamTimcorey.com.
• 20:32
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 20:39
  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.