Latest / DevQuestions with Tim Corey / 289. Common Code to Build and Reuse in Business

Transcript

289. Common Code to Build and Reuse in Business · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: What code should I build into a library for reuse?
• 0:04
  SPEAKER_01: Are there specific tools or libraries I should build to save myself time at work?
• 0:09
  SPEAKER_01: How should I reuse code at work?
• 0:11
  SPEAKER_01: Let's talk about how to reuse code at work as well as what code to consider building into a common library in this episode of DevQuestions.
• 0:28
  SPEAKER_00: Welcome to the DevQuesti podcast with Tim Corey.
• 0:32
  SPEAKER_01: Software development is more than just writing code.
• 0:35
  SPEAKER_01: So let's talk about the rest of it.
• 0:37
  SPEAKER_01: Specifically, let's talk about code reuse at work and how to build a common development library.
• 0:44
  SPEAKER_01: Learning to code and writing code at work are two different things.
• 0:48
  SPEAKER_01: When you're learning to code, you're learning about design patterns and algorithms and perfect architecture and the latest version of everything.
• 0:55
  SPEAKER_01: When you're building code in production, you're typically working on a less than ideal code base that's years out of date, is messy, and is generally a dumpster fire that you're trying to keep from bursting out of containment.
• 1:08
  SPEAKER_01: But there are things you can do to help alleviate some of the issues.
• 1:12
  SPEAKER_01: One of the big things is to develop a series of shared libraries that you can use to reduce the amount of code you have to write and debug.
• 1:21
  SPEAKER_01: Now, on the other hand, one of the things you can do to make that dumpster fire worse is to create the wrong set of code and shared libraries that actually increases the amount of work you have to write and debug.
• 1:34
  SPEAKER_01: So let's talk about how to go about this safely and effectively.
• 1:41
  SPEAKER_01: So number one is use NuGet packages.
• 1:45
  SPEAKER_01: It used to be when we shared code between projects, we'd create a DLL and we just pass that DLL around, or even worse yet, put it in the global assembly cache, which I don't believe is a thing anymore.
• 2:00
  SPEAKER_01: Um, but that's a bad thing, really.
• 2:02
  SPEAKER_01: It's a messy way of sharing code.
• 2:05
  SPEAKER_01: Don't do that.
• 2:06
  SPEAKER_01: Use NuGet packages.
• 2:08
  SPEAKER_01: One of the benefits is that with NuGet packages, you can have different applications using different versions of the same package.
• 2:17
  SPEAKER_01: That way, let's say you have 10 different projects that use your library, your you know, Acme library.
• 2:25
  SPEAKER_01: So maybe all those packages use you know Acme Lib version one.
• 2:31
  SPEAKER_01: And then you make a change to Acme Lib that maybe it's going to add a new feature.
• 2:37
  SPEAKER_01: And then you you upgrade the first in of your 10 projects to use Acme Lib 2.0.
• 2:44
  SPEAKER_01: Well, you can upgrade just that one project if it needs Acme Lib 2.0 and leave the rest alone.
• 2:51
  SPEAKER_01: You don't have to touch and recompile and redeploy and all the rest, those other applications.
• 2:57
  SPEAKER_01: So using versioning is a really big deal.
• 3:00
  SPEAKER_01: It also helps you when you go build your application, say, hey, we did a bug fix in Acme 1.1 that fixed a critical error.
• 3:09
  SPEAKER_01: Does this application use 1.1 or higher?
• 3:15
  SPEAKER_01: You can go look at that and see, oh yes, it uses package version 1.2.
• 3:20
  SPEAKER_01: Or you can say, oh, nope, it uses 1.0, we need to upgrade that package.
• 3:24
  SPEAKER_01: Whereas if using DLLs, you're trying to go to the properties and look and it's messy, and it's there's caching and there's all these other problems surrounding it.
• 3:32
  SPEAKER_01: Make sure you use NuGet packages internally.
• 3:36
  SPEAKER_01: Number two, keep libraries small and focused.
• 3:40
  SPEAKER_01: I have worked as a consultant for a number of years.
• 3:42
  SPEAKER_01: I've dealt with a lot of different companies, and by and large, a lot of them use some type of shared library.
• 3:50
  SPEAKER_01: But I've seen some that's it's one library and it's everything.
• 3:54
  SPEAKER_01: It's a junk drawer.
• 3:56
  SPEAKER_01: It's everything that they ever wanted to do is in that one library.
• 4:01
  SPEAKER_01: The problem is if they find a bug, well, then they in one little piece of that, they have to upgrade the hopefully NuGet package.
• 4:10
  SPEAKER_01: I've dealt with a lot of DLLs, but they open, they upload a new version, but now everything has to update to that new version because it was a bug fix.
• 4:21
  SPEAKER_01: It was a security issue.
• 4:23
  SPEAKER_01: But it was a security issue in one little piece that not every application uses, but we don't know which applications use that, which ones don't.
• 4:30
  SPEAKER_01: So we have to update every application.
• 4:33
  SPEAKER_01: Before you know it, anytime you change that library, you're changing every single application that depends on it.
• 4:40
  SPEAKER_01: So instead of being a separation of concerns and separating out your different libraries, you're really building one big monolith that's badly distributed.
• 4:51
  SPEAKER_01: Don't do that.
• 4:53
  SPEAKER_01: Create small focused libraries.
• 4:56
  SPEAKER_01: Say, this is the Acme library for communication or for this or for that, and have different ones that you bring in.
• 5:05
  SPEAKER_01: That way you know what your application depends on.
• 5:08
  SPEAKER_01: That way you know which applications need to get updated when a bug fix or a security patch goes out for those packages.
• 5:17
  SPEAKER_01: Number three, don't build things you don't need.
• 5:23
  SPEAKER_01: The idea of a shared library excites people and they start dreaming.
• 5:28
  SPEAKER_01: Oh, you know what?
• 5:29
  SPEAKER_01: I could add this to it, I could add that to it.
• 5:31
  SPEAKER_01: Before you know it, they've built this massive library of all these things that they're never going to use.
• 5:38
  SPEAKER_01: Where maybe they're going to use it someday.
• 5:40
  SPEAKER_01: Someday we'll use that.
• 5:41
  SPEAKER_01: And someday you might.
• 5:42
  SPEAKER_01: The problem is that maybe you start using it two years after it's built.
• 5:47
  SPEAKER_01: And all of a sudden you find out that that had a bug for two years.
• 5:51
  SPEAKER_01: You just didn't know it because you didn't use it.
• 5:53
  SPEAKER_01: But now you don't remember how you built it or who built it because that person's already gone from the company.
• 5:57
  SPEAKER_01: That's a problem.
• 5:59
  SPEAKER_01: Don't build things you don't need, don't add complexity.
• 6:03
  SPEAKER_01: Number four is don't put things in a library simply because they might also be used somewhere else.
• 6:11
  SPEAKER_01: I see this a lot.
• 6:12
  SPEAKER_01: We're going to talk about, I'm going to step on some toes later on.
• 6:15
  SPEAKER_01: Um, there's something down here that you probably do.
• 6:17
  SPEAKER_01: Microsoft has probably shown you that you should do that I would recommend you don't do.
• 6:24
  SPEAKER_01: Because just saying, well, we're using it in two places, we need to have it in a library.
• 6:29
  SPEAKER_01: Not a good answer.
• 6:30
  SPEAKER_01: Not a good reason, because that can cause some significant problems that make your applications worse.
• 6:37
  SPEAKER_01: So don't put things in libraries just because you're going to use it in two places or three places.
• 6:43
  SPEAKER_01: You need to think through is this right for a library?
• 6:47
  SPEAKER_01: And the answer isn't just yes, because we use it somewhere else.
• 6:52
  SPEAKER_01: So now let's talk about what to build.
• 6:55
  SPEAKER_01: To do that, I'm going to give you three examples of things that I've put into shared libraries.
• 7:01
  SPEAKER_01: I want you to look for the common thread.
• 7:03
  SPEAKER_01: Number one, I have built a data access library that I use a lot.
• 7:09
  SPEAKER_01: So I use Dapper for my data access almost exclusively.
• 7:12
  SPEAKER_01: I think that it provides a much better solution for data access than NT Framework or other ORMs.
• 7:20
  SPEAKER_01: Not because it's more efficient, although it can be, it usually is, not because it is simpler code, although it can be in some cases, but because of the fact that it allows me to put my SQL in SQL and allows SQL to do what it does best while I do what I do best in C sharp, the C sharp stuff that C sharp does best in C sharp.
• 7:48
  SPEAKER_01: So I keep both separated and make sure that each does what it does best.
• 7:53
  SPEAKER_01: So I use Dapr.
• 7:55
  SPEAKER_01: Well, when you do Dapr, it takes about five to eight lines of code to set up and initialize a connection to read data from SQL and somewhere on the same for writing data to SQL.
• 8:09
  SPEAKER_01: Well, I have a couple of methods that make that into one-liners, where you give one line of code and say, hey, I want to read from this store procedure and I want to put it into this model.
• 8:22
  SPEAKER_01: Done.
• 8:23
  SPEAKER_01: One line.
• 8:24
  SPEAKER_01: Well, that's something that I reuse in a lot of different places.
• 8:27
  SPEAKER_01: So I put that into a shared library.
• 8:30
  SPEAKER_01: That's number one.
• 8:31
  SPEAKER_01: Number two is when I do communication.
• 8:35
  SPEAKER_01: So sending out emails or sending out texts.
• 8:38
  SPEAKER_01: Usually, let's use email as an example.
• 8:41
  SPEAKER_01: I have a method that has uh, you know, I use SMTP, that's SMTP library from Microsoft, usually, I believe.
• 8:48
  SPEAKER_01: Um, it will be I have to have the the header or the um the two and the CC and the BCC and the subject line, the body, and if you have text body versus HTML body, and you have a bunch of other things.
• 9:01
  SPEAKER_01: And there's a lot of setup with that, make sure you have all those parts in place and error checking and all the rest.
• 9:07
  SPEAKER_01: I wrap all that up so that again, it's one line where I say, here's my model of the data for an email.
• 9:17
  SPEAKER_01: I skip the model and say, send that email.
• 9:21
  SPEAKER_01: Done.
• 9:21
  SPEAKER_01: Okay.
• 9:22
  SPEAKER_01: So my library handles the taking the model and saying, okay, we're going to fill in all this information this way, make sure we have all the things checked, and we're going to validate that model, et cetera.
• 9:35
  SPEAKER_01: And they're going to go through the process of actually sending that email.
• 9:38
  SPEAKER_01: So a communication library.
• 9:40
  SPEAKER_01: Number three is a standard logging configuration.
• 9:45
  SPEAKER_01: So I do logging in a similar way for most of my projects, if not all of them, where I have a certain setup where I say, okay, these are the things I want to do.
• 9:54
  SPEAKER_01: And I do it in code as opposed to app settings for the most part.
• 9:58
  SPEAKER_01: Now there's some things like, what's your logging level?
• 10:00
  SPEAKER_01: That goes into app settings.
• 10:02
  SPEAKER_01: But there's other things like we're going to use a SQL logger, we're going to have have these settings, et cetera, that you can do in code.
• 10:09
  SPEAKER_01: I prefer to do it in code.
• 10:10
  SPEAKER_01: So I'll put that into a library and we'll have a standard logging configuration.
• 10:16
  SPEAKER_01: Because while some settings for logging, like again, logging level, might be different per application, the overall configuration of the loggers are going to be the same.
• 10:29
  SPEAKER_01: So I'll put that into a NuGet package.
• 10:32
  SPEAKER_01: Okay, so those are three examples of the shared libraries that I have built.
• 10:39
  SPEAKER_01: So what's the common thread?
• 10:41
  SPEAKER_01: What do these things have in common?
• 10:43
  SPEAKER_01: I'm taking something I do everywhere or in a lot of places and making it even simpler for my use case.
• 10:51
  SPEAKER_01: So NuGet packages, let's say for Dapper, it's a pretty simple thing to do to have a connection to SQL from your configuration and take that and have a using statement that says, okay, um using this connection to SQL and then say, okay, let's read the data, let's put it into the model, let's turn that model into a list and send that list back.
• 11:15
  SPEAKER_01: That's a pretty simple thing to do, but that's still quite uh that's still quite a few steps where I take it and say, this is how I use that Dapper library.
• 11:25
  SPEAKER_01: And I turn it into one step.
• 11:27
  SPEAKER_01: So I'm not doing all the work in the library.
• 11:31
  SPEAKER_01: I'm just eliminating the simple or the common setup work.
• 11:35
  SPEAKER_01: I'm trying to make it as simple as possible for me to call those resources or use those resources.
• 11:42
  SPEAKER_01: So those are the things I do when I look at building out libraries.
• 11:47
  SPEAKER_01: That's how I build them out.
• 11:49
  SPEAKER_01: I build them out to make my life as simple as possible by making sure that the common things I'm doing over and over that are going to be the same, I'm going to put into a library.
• 12:01
  SPEAKER_01: And I'll just call that with a little bit of configuration that is going to be different between every project.
• 12:08
  SPEAKER_01: Now, here's what to avoid.
• 12:10
  SPEAKER_01: And this is where, again, I'm going to step on some toes.
• 12:13
  SPEAKER_01: The first thing, and the thing that's going to be the most controversial, I would recommend do you avoid putting models in libraries.
• 12:23
  SPEAKER_01: I can already hear the, no, no, no, that's wrong.
• 12:26
  SPEAKER_01: You need to put models in libraries.
• 12:30
  SPEAKER_01: Yes, I know that's what you think.
• 12:32
  SPEAKER_01: But here's the deal: the model that you use to access your SQL database should not be the exact same as the model you use to display that data on your UI.
• 12:45
  SPEAKER_01: Almost certainly, and even if it is at first, it won't be forever.
• 12:51
  SPEAKER_01: Why?
• 12:52
  SPEAKER_01: Well, because you're going to put validation logic on your UI model, because it's actually a model for inputting data as well as displaying data.
• 13:01
  SPEAKER_01: Whereas your data access model, your DTO, that's not going to have data validation because it's coming from the database.
• 13:10
  SPEAKER_01: And there's other things like that.
• 13:11
  SPEAKER_01: And then people get caught up in the idea of okay, I've got a table that has ID, first name, last name, and email address.
• 13:18
  SPEAKER_01: So I need to have a model that's ID, first name, last name, and email address.
• 13:23
  SPEAKER_01: That may be true for accessing that data, but it might not be true for displaying that data.
• 13:29
  SPEAKER_01: And it might not even be true for accessing the data.
• 13:32
  SPEAKER_01: Imagine for a minute, I'm going to create a list for a dropdown.
• 13:38
  SPEAKER_01: And I want to show the user a list of potential people to select from.
• 13:44
  SPEAKER_01: And so I'm going to pull from that person table.
• 13:48
  SPEAKER_01: Well, the dropdown is going to need the ID in order to look that person up.
• 13:52
  SPEAKER_01: Okay.
• 13:52
  SPEAKER_01: And that's going to be the name of the person, probably, maybe last name, comma, first name.
• 13:56
  SPEAKER_01: Cool.
• 13:57
  SPEAKER_01: Does it need the email address?
• 13:59
  SPEAKER_01: No.
• 14:00
  SPEAKER_01: So guess what?
• 14:01
  SPEAKER_01: I'm going to either, if I use that model as it is, I'll be bringing down extra information from the server, potentially secured information that shouldn't be displayed.
• 14:11
  SPEAKER_01: Extra information from the server, I'm going to pull it from the database, transmit it across the wire to the client.
• 14:16
  SPEAKER_01: The client's going to have to hold that in memory for no reason.
• 14:20
  SPEAKER_01: And I say, well, but I'm saving time by not having to have three models.
• 14:25
  SPEAKER_01: You're saving a little bit of design time in order to have a worse experience every time that page is called.
• 14:33
  SPEAKER_01: That's not an optimization, that's a de-optimization.
• 14:37
  SPEAKER_01: That's making things worse.
• 14:39
  SPEAKER_01: Now, there are times when you might put a model in your library.
• 14:45
  SPEAKER_01: For instance, that example I used of sending email.
• 14:49
  SPEAKER_01: That would have a model in there because this is the standard I'm expecting for sending an email.
• 14:56
  SPEAKER_01: It's going to have the two, the CC, the BCC, the subject line, the body, et cetera.
• 15:03
  SPEAKER_01: But I would not, in most cases, put your models into shared libraries.
• 15:10
  SPEAKER_01: I don't like shared projects for those things.
• 15:14
  SPEAKER_01: Because again, you might have a case where you say, well, I want to modify this for the front end, but if I do that, then it's going to affect the back end too.
• 15:22
  SPEAKER_01: Now you have this one big model if you don't have separation of concerns.
• 15:26
  SPEAKER_01: And now you're saying, uh-oh, well, maybe I can modify, have a different model.
• 15:31
  SPEAKER_01: And before you know it, you cause all these kinds of problems, trying to do lowest common denominator, where you're transmitting too much information across the wire, you're capturing too much information, you're passing on models that are half empty.
• 15:45
  SPEAKER_01: It just creates a mess because you're trying to somehow save cycles.
• 15:51
  SPEAKER_01: It does not hurt to have two different models that have the same or similar properties.
• 15:59
  SPEAKER_01: You're not going to cause your application to be too big or something like that.
• 16:04
  SPEAKER_01: This may actually save your application in the long run.
• 16:06
  SPEAKER_01: So I would avoid putting models into your libraries.
• 16:11
  SPEAKER_01: Again, that's a general principle, not an absolute.
• 16:16
  SPEAKER_01: Next up, I would avoid a lot of business logic.
• 16:19
  SPEAKER_01: Typically, business logic is specific to an application or specific to a certain situation.
• 16:26
  SPEAKER_01: So if you put business logic into a shared library, that might cause problems because you might have to update that library all the time.
• 16:34
  SPEAKER_01: And again, you might have to tweak it for one project, not another project.
• 16:39
  SPEAKER_01: And so now you have two different versions of that same logic, but now you're trying to maintain that in one package or something weird like that.
• 16:46
  SPEAKER_01: I would avoid that.
• 16:47
  SPEAKER_01: I don't think that that typically rises to the reuse across the board situation.
• 16:54
  SPEAKER_01: And finally, most UI components.
• 16:57
  SPEAKER_01: Most UI components probably should not be in a shared library.
• 17:01
  SPEAKER_01: I know it's tempting.
• 17:02
  SPEAKER_01: You say, well, you know what?
• 17:03
  SPEAKER_01: We're going to create this login form.
• 17:05
  SPEAKER_01: We're going to use this login form everywhere.
• 17:07
  SPEAKER_01: Let's put that in a shared component.
• 17:10
  SPEAKER_01: Maybe.
• 17:12
  SPEAKER_01: But here's the problem.
• 17:13
  SPEAKER_01: You're going to have one place where it's not going to fit real well, where you're like, ooh, I kind of want to do something else.
• 17:20
  SPEAKER_01: Or, you know what, we don't have the same amount of space we do everywhere else.
• 17:24
  SPEAKER_01: You have to make this a little bit smaller.
• 17:26
  SPEAKER_01: Now what you're trying to do is change a component for one spot that's not changed the other spots.
• 17:30
  SPEAKER_01: And then you start creating that, like modifying that component to maybe be a little bit more flexible so it handles that one situation versus all the others.
• 17:39
  SPEAKER_01: Before you know it, you have a situation where your shared component is just a whole bunch of configuration you're passing in.
• 17:46
  SPEAKER_01: And you really should have just created that component more than one time and maybe put a copy somewhere that you just copy and paste from.
• 17:54
  SPEAKER_01: Copy and paste is not the end of the world.
• 17:56
  SPEAKER_01: There are times when it makes sense as opposed to a shared library that handcuffs you between projects.
• 18:03
  SPEAKER_01: So those are some places to avoid creating shared content in a shared library.
• 18:09
  SPEAKER_01: Shared libraries can be powerful tools to make your development faster.
• 18:14
  SPEAKER_01: However, don't get so over-eager to centralize things that you actually make life harder for yourself in the process.
• 18:21
  SPEAKER_01: All right.
• 18:22
  SPEAKER_01: Thanks for listening.
• 18:23
  SPEAKER_01: And as always, I am Tim Corey.
• 18:25
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 18:28
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to Iamtimcorey.com and enroll in a course.