Latest / DevQuestions with Tim Corey / 163 How Do I Structure My Application?

Transcript

163 How Do I Structure My Application? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:03
  SPEAKER_01: 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_01: 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_01: Now, here's your host, expert developer and online educator, Tim Corey.
• 0:25
  SPEAKER_02: How do I structure my application?
• 0:28
  SPEAKER_02: What are the best practices for how to create that perfect structure?
• 0:32
  SPEAKER_02: This is a question from a suggestion site, and it's one we're going to tackle in today's episode of DevQuestions.
• 0:38
  SPEAKER_02: Now, if you have a question, go to suggestions.imtimcorey.com and ask your suggestion there or ask your question there, or look at somebody else's question and upvote it to hopefully see it in a future episode of DevQuestions.
• 0:53
  SPEAKER_02: So, what's the perfect structure for your application?
• 0:56
  SPEAKER_02: How do you lay things out so that they're designed really well?
• 1:01
  SPEAKER_02: And you probably know what I'm going to say right now, but it depends.
• 1:06
  SPEAKER_02: And yes, it depends is almost always the right answer.
• 1:11
  SPEAKER_02: May not be the one that explains everything fully, but it's the right answer because it does depend.
• 1:17
  SPEAKER_02: It depends a lot on a lot of different things besides just what you asked.
• 1:23
  SPEAKER_02: But let's talk about the ways to structure an application.
• 1:27
  SPEAKER_02: Because let's start there.
• 1:28
  SPEAKER_02: There's lots of different ways to structure an application.
• 1:31
  SPEAKER_02: If there's one perfect one, we'd only have one, right?
• 1:34
  SPEAKER_02: So you can have domain-driven design, or you can have the onion architecture, or three-layer design, or CQRS, or everything in the code behind of your forms.
• 1:47
  SPEAKER_02: You know who you are.
• 1:49
  SPEAKER_02: So what's the right way?
• 1:51
  SPEAKER_02: Well, the right way depends on the size and complexity of your application.
• 1:57
  SPEAKER_02: So a key point here, it's one we have to understand before moving forward.
• 2:03
  SPEAKER_02: And we'll talk about the five things to work through when it comes to uh figuring out the right architecture, right layout for you.
• 2:12
  SPEAKER_02: But the key point to understand first is that architectural design patterns have a cost.
• 2:19
  SPEAKER_02: The thing they fix needs to be more expensive than the cost of the pattern.
• 2:26
  SPEAKER_02: It's really important to understand that.
• 2:28
  SPEAKER_02: Anytime you add in a design pattern or add in this structure or this layout, there's a cost to it.
• 2:36
  SPEAKER_02: And it needs to be less than the cost of not doing it.
• 2:43
  SPEAKER_02: So you have to have this balance because you know there's a there's a really easy way to see this.
• 2:50
  SPEAKER_02: Is I have a video on YouTube that is on the perfect console application.
• 2:57
  SPEAKER_02: And we build out the, and it's yes, tongue-in-cheek, it's a little bit facetious, but we build out this really complex uh console application, which by the way, is also really good at teaching you things like how to put dependency injection in a console application, how to talk to your app settings and other things that you kind of do need for some console applications.
• 3:18
  SPEAKER_02: But at the end of the day, we build a hello world application.
• 3:22
  SPEAKER_02: Did it need all those different files and that dependency injection and structure and all the rest to say hello world?
• 3:29
  SPEAKER_02: Well, no, we just need one line that said console.write line, hello world.
• 3:34
  SPEAKER_02: Done.
• 3:35
  SPEAKER_02: Okay, so we didn't need all that complexity.
• 3:39
  SPEAKER_02: But on the other side, I see enterprise applications that have Windows Forms, let's say, as their user interface.
• 3:48
  SPEAKER_02: And when you open the code behind for Windows Forms, you see all their UI logic, all their business logic, all their data access logic.
• 3:58
  SPEAKER_02: It's all in the code behind.
• 4:00
  SPEAKER_02: That's also not a great design.
• 4:02
  SPEAKER_02: Okay.
• 4:03
  SPEAKER_02: So how do you figure out that middle ground?
• 4:06
  SPEAKER_02: How do you figure out when to apply patterns or when to create certain structures or when to break things apart, when to separate things in different ways?
• 4:15
  SPEAKER_02: So let's talk through that.
• 4:16
  SPEAKER_02: I think there's really five keys here.
• 4:18
  SPEAKER_02: The first key is to start simple.
• 4:22
  SPEAKER_02: One user interface, one class library.
• 4:25
  SPEAKER_02: Start there.
• 4:27
  SPEAKER_02: And yes, I do want to see some of that broken apart.
• 4:30
  SPEAKER_02: Now, okay, a very small application might not need a class library.
• 4:34
  SPEAKER_02: For creating a microservice, you might not even need that class library.
• 4:38
  SPEAKER_02: But if we're talking about some type of monolith, and monolith is not a bad word.
• 4:42
  SPEAKER_02: Monolith is probably the right way to go in most circumstances.
• 4:45
  SPEAKER_02: But start with one UI and one class library and try and keep it just there.
• 4:51
  SPEAKER_02: Start there.
• 4:52
  SPEAKER_02: And then as you go through your design process, as you go through your building process, if you say, you know what?
• 4:57
  SPEAKER_02: No, we need some more complexity.
• 4:59
  SPEAKER_02: Maybe we need a folder structure in here.
• 5:01
  SPEAKER_02: Maybe we need some more separation or grouping things a certain way.
• 5:06
  SPEAKER_02: Only refactor, only bring in those patterns when complexity is significant.
• 5:15
  SPEAKER_02: There's a principle called dry, don't repeat yourself.
• 5:20
  SPEAKER_02: And this is one of the most abused principles out there because everyone knows it.
• 5:24
  SPEAKER_02: And so everyone also applies it in the wrong spots, too, accidentally.
• 5:29
  SPEAKER_02: And one of the ways I see it applied poorly is when you see yourself repeating something once.
• 5:36
  SPEAKER_02: So you have two copies of something and you say, ah, dry, don't repeat yourself.
• 5:42
  SPEAKER_02: And so you create a class for that and you create a method in that, you put it into pants and injection, and you sell this up so you have one place, one method call for where you would otherwise have two methods or two bits of logic.
• 6:00
  SPEAKER_02: That's probably an abuse of dry.
• 6:02
  SPEAKER_02: Because really, for dry, you want to say, hey, you know what?
• 6:06
  SPEAKER_02: I've done this three times, I've done this four times.
• 6:08
  SPEAKER_02: I started to see a significant repetition because a little repetition is okay.
• 6:15
  SPEAKER_02: And in fact, it's better than bringing the complexity in of trying to refactor that out into a separate method and calling that in a lot of circumstances.
• 6:26
  SPEAKER_02: So that refactoring needs to happen only when complexity is significant.
• 6:34
  SPEAKER_02: Number three, don't separate related things.
• 6:39
  SPEAKER_02: Too often I see people looking to create separation everywhere.
• 6:44
  SPEAKER_02: Where they say, okay, every bit of code has to be in a library somewhere.
• 6:48
  SPEAKER_02: It cannot be connected to anything else.
• 6:50
  SPEAKER_02: We're gonna have five different libraries.
• 6:52
  SPEAKER_02: The user interface is gonna have zero code in it.
• 6:55
  SPEAKER_02: It's all gonna go right to a library.
• 6:58
  SPEAKER_02: Okay, that's a problem.
• 7:00
  SPEAKER_02: Because what you're doing is you're separating things that probably go together.
• 7:05
  SPEAKER_02: I've had people ask me, they say, okay, Tim, I know that there's a one-way relationship with a library where the library doesn't know about the caller.
• 7:14
  SPEAKER_02: So say user interface can call the library, but the library can't call the user interface.
• 7:19
  SPEAKER_02: That's a problem because my code needs to know about the user interface.
• 7:24
  SPEAKER_02: And the user interface needs to know about my code.
• 7:27
  SPEAKER_02: What you just described is user interface code.
• 7:32
  SPEAKER_02: It needs to be in the user interface, not in a separate library.
• 7:38
  SPEAKER_02: Because those two shouldn't be separated because they're really one entity.
• 7:43
  SPEAKER_02: So that separation, all it did was add complexity.
• 7:47
  SPEAKER_02: It didn't add value.
• 7:50
  SPEAKER_02: So don't separate things that are related.
• 7:53
  SPEAKER_02: Okay?
• 7:54
  SPEAKER_02: Put things together that go together.
• 7:57
  SPEAKER_02: Number four, your goal here is to keep it simple.
• 8:04
  SPEAKER_02: That may sound obvious, but really it's not once you get into the heat of battle.
• 8:08
  SPEAKER_02: Once you start writing code, you start thinking about, okay, I can implement this design pattern, I can implement that design pattern.
• 8:15
  SPEAKER_02: I have 18 more in my back pocket that I know about, so I know I need to put those in there somewhere.
• 8:21
  SPEAKER_02: That's adding complexity.
• 8:23
  SPEAKER_02: That's not the goal.
• 8:24
  SPEAKER_02: The goal isn't to get design pattern bingo.
• 8:28
  SPEAKER_02: Okay?
• 8:29
  SPEAKER_02: You're not looking for how many of these things can I cram into my application.
• 8:34
  SPEAKER_02: The goal of writing code is to keep it simple.
• 8:39
  SPEAKER_02: I said this before, but as a junior developer, typically, you write simple code to solve simple problems.
• 8:48
  SPEAKER_02: As a mid-level developer, you write complex code to solve complex issues.
• 8:55
  SPEAKER_02: And as a senior developer, you write simple code to solve complex issues.
• 9:01
  SPEAKER_02: That's what you want to achieve.
• 9:04
  SPEAKER_02: You want to achieve the ability to write simple code to solve complex problems.
• 9:11
  SPEAKER_02: Create simple applications that solve your goal rather than complex applications because you have to maintain it.
• 9:20
  SPEAKER_02: Or more likely the person coming after you has to maintain it.
• 9:24
  SPEAKER_02: And when it's too complicated, it's just not worth it.
• 9:29
  SPEAKER_02: It causes too many problems.
• 9:31
  SPEAKER_02: And I've had I've paid for applications to them completely built.
• 9:36
  SPEAKER_02: And I look at the code, and you know what?
• 9:39
  SPEAKER_02: I didn't spend enough time working with the developers.
• 9:41
  SPEAKER_02: And so that's super complex to do a simple job.
• 9:45
  SPEAKER_02: I'm gonna throw it out.
• 9:46
  SPEAKER_02: I'm gonna start over.
• 9:48
  SPEAKER_02: Because the goal is to write simple code.
• 9:52
  SPEAKER_02: Write simple code.
• 9:54
  SPEAKER_02: Don't write complex code.
• 9:56
  SPEAKER_02: Don't try to bring in design patterns because you've heard about them or you think they'd solve these problems.
• 10:04
  SPEAKER_02: Wait until you have a problem that is going to be made better, easier, less complex if you add that pattern.
• 10:16
  SPEAKER_02: Okay?
• 10:17
  SPEAKER_02: When you start adding things and realize they become more complex, that's a problem.
• 10:22
  SPEAKER_02: All right.
• 10:23
  SPEAKER_02: And number five, it kind of ties into all the previous.
• 10:26
  SPEAKER_02: Let the situation dictate the structure.
• 10:32
  SPEAKER_02: Don't start with a structure.
• 10:34
  SPEAKER_02: Too often people say, what kind of architecture should I have?
• 10:38
  SPEAKER_02: Should it be domain-driven design?
• 10:40
  SPEAKER_02: Should it be CQRS?
• 10:41
  SPEAKER_02: Should it be ion architecture?
• 10:42
  SPEAKER_02: Should it be the three-layer stop?
• 10:46
  SPEAKER_02: Let the situation define the structure.
• 10:50
  SPEAKER_02: Because today it might be this, tomorrow it might be that for a different application.
• 10:55
  SPEAKER_02: If you try to come in with preconceived notions, with preconceived layouts, then what's going to happen is you're going to introduce a lot of complexity where it's not needed.
• 11:07
  SPEAKER_02: So I know it doesn't give you an exact create these folders, create, you know, put these things here, but that's because it comes back to it depends.
• 11:19
  SPEAKER_02: And if you hear someone say, no, this is the way of doing things, always that's a problem.
• 11:24
  SPEAKER_02: That's not good advice.
• 11:26
  SPEAKER_02: Because that doesn't take into account your situation or your code or what you're trying to accomplish.
• 11:33
  SPEAKER_02: So you need to figure out based upon what works for you.
• 11:37
  SPEAKER_02: And you know what?
• 11:38
  SPEAKER_02: The same application might be built and structured differently in two different companies because they have two different teams in two different ways that seem simplest to them.
• 11:50
  SPEAKER_02: So that's okay.
• 11:53
  SPEAKER_02: Pick what works for you, figure out how to make things as simple as possible, and move forward from there.
• 12:01
  SPEAKER_02: I hope they answered your question.
• 12:02
  SPEAKER_02: Thanks for asking it.
• 12:03
  SPEAKER_02: Thanks for listening.
• 12:04
  SPEAKER_02: And as always, I am Tim Corey.
• 12:07
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 12:10
  SPEAKER_00: Tim is committed to making it easier for you to become a developer.
• 12:13
  SPEAKER_00: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 12:21
  SPEAKER_00: You can also send your questions to questions at IamTimcore.com.
• 12:26
  SPEAKER_00: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 12:33
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.