Latest / DevQuestions with Tim Corey / 327. How Do I Evaluate a Third-Party Tool or Library in the Age of AI?

Transcript

327. How Do I Evaluate a Third-Party Tool or Library in the Age of AI? · DevQuestions with Tim Corey

• 0:04
  SPEAKER_00: It seems like everyone is vibe coding apps and tools these days.
• 0:07
  SPEAKER_00: With code being so easy to write with AI, it's easier than ever to turn an idea into a product.
• 0:13
  SPEAKER_00: Unfortunately, building that product was almost never the hardest part.
• 0:17
  SPEAKER_00: Building a secure performant product is much harder.
• 0:20
  SPEAKER_00: And then supporting it long term is even harder still.
• 0:24
  SPEAKER_00: These are the areas where a lot of apps and libraries are already failing.
• 0:29
  SPEAKER_00: So how do you know what tools and libraries to depend on when you're building your own app?
• 0:34
  SPEAKER_00: Should you build everything yourself, or should you only depend on tools from reputable sources?
• 0:40
  SPEAKER_00: Let's talk about it in today's episode of DevQuestions.
• 0:51
  SPEAKER_00: Software development is more than just writing code.
• 0:54
  SPEAKER_00: So let's talk about the rest of it.
• 0:56
  SPEAKER_00: Specifically, let's talk about how to evaluate third-party tools and libraries in the age of AI.
• 1:03
  SPEAKER_00: Now, I don't know about you, but I get nervous anytime I see an app that was clearly vibe-coded.
• 1:08
  SPEAKER_00: I have seen too many instances of apps that seemed to work only to discover later that they leaked all their sensitive data or that they'd failed the worst moment and were just abandoned.
• 1:19
  SPEAKER_00: If you are building an app, you probably are going to depend on third-party resources like emailers, PDF tools, data access libraries, and more.
• 1:29
  SPEAKER_00: So, how do you know what's a good app to depend on and what's not a good app to depend on?
• 1:36
  SPEAKER_00: So let's talk about what not to look at or not to depend on when validating a third-party library app.
• 1:47
  SPEAKER_00: Number one, open source.
• 1:49
  SPEAKER_00: Just because something is open source doesn't make it good.
• 1:54
  SPEAKER_00: The kind of misconception is, well, if it's ever a problem, I can just fork it and build my own.
• 1:59
  SPEAKER_00: Really?
• 2:00
  SPEAKER_00: Really?
• 2:01
  SPEAKER_00: Have you ever tried that?
• 2:02
  SPEAKER_00: Have you ever actually done the work of saying, hey, let's test out what would happen if this library suddenly stops supporting the latest version of.NET?
• 2:12
  SPEAKER_00: Could we upgrade it to the latest version of.NET?
• 2:14
  SPEAKER_00: Have you tried?
• 2:16
  SPEAKER_00: Because more than likely, it's not nearly as easy as you think it is.
• 2:20
  SPEAKER_00: And even if you say, well, we're going to use AI and just have AI do it, it that's even harder because now you have an app that AI is not going to fully read through that third-party system.
• 2:32
  SPEAKER_00: And so it's going to make some guesses and it's going to create more and more spaghetti code until you ring it in and you won't because you don't know the code itself.
• 2:40
  SPEAKER_00: And so it just creates a bigger ball of mess to deal with.
• 2:44
  SPEAKER_00: So just because something is open source doesn't mean it's a good system to depend on.
• 2:50
  SPEAKER_00: Now, being open source can be a valuable thing and it can be a point in its favor, but don't look at something and say, oh, well, it's open source, that must be good.
• 3:01
  SPEAKER_00: So don't look at open source as the qualifier for something to be good.
• 3:05
  SPEAKER_00: There's other things to look at.
• 3:06
  SPEAKER_00: Number two, don't look at just because it's a product from a big company.
• 3:11
  SPEAKER_00: There is a whole Twitter account dedicated to apps killed by Google, because Google is notorious.
• 3:19
  SPEAKER_00: In fact, I've told my team, I said, we will not rely on products from Google because they're just notorious for shutting down good working products.
• 3:31
  SPEAKER_00: So not going to trust it.
• 3:33
  SPEAKER_00: Even Microsoft and Microsoft is better, but they still have a number of dead products in their wake.
• 3:42
  SPEAKER_00: And you might say, well, no, there's bad as everybody else.
• 3:45
  SPEAKER_00: To be fair, WinForms.
• 3:47
  SPEAKER_00: WinForms has been supported since.NET 1 back in 2001, 2002 timeframe.
• 3:54
  SPEAKER_00: That's 24 years.
• 3:56
  SPEAKER_00: We've had.NET WinForms, and that's been supported that entire time.
• 4:01
  SPEAKER_00: So they do have a long track record of supporting certain things.
• 4:05
  SPEAKER_00: Not everything.
• 4:07
  SPEAKER_00: It needed to die, but it did die.
• 4:09
  SPEAKER_00: Okay.
• 4:10
  SPEAKER_00: And then there is the WCF, and there's, you know, Silverlight always gets thrown in there, but that's not really their problem.
• 4:17
  SPEAKER_00: But at the same time, yeah, it's an app that died because a different big company killed it.
• 4:23
  SPEAKER_00: So just because it comes from a big company doesn't mean it's going to be around forever.
• 4:28
  SPEAKER_00: It might last a year or two, or it might last for 20 years.
• 4:31
  SPEAKER_00: You just don't know.
• 4:33
  SPEAKER_00: And saying, well, they have mountains of money to support it.
• 4:36
  SPEAKER_00: Yeah, do they though?
• 4:38
  SPEAKER_00: Because every time I turn around, it seems like these big tech companies are laying people off and cutting divisions.
• 4:44
  SPEAKER_00: So while it may seem like they have lots of money, typically that lots of money goes towards shareholders, not towards your particular library that you want supported.
• 4:56
  SPEAKER_00: So just be careful saying, well, it's a big company.
• 5:00
  SPEAKER_00: Doesn't mean anything.
• 5:01
  SPEAKER_00: Number three, just because it has a lot of stars on GitHub doesn't mean pretty much anything.
• 5:08
  SPEAKER_00: Stars don't pay the bills, they don't indicate quality.
• 5:12
  SPEAKER_00: They don't in any way give you an indication that this is a good library, except for the fact that a number of people have said, yeah, I want to watch this, or yeah, I think this is an interesting project.
• 5:24
  SPEAKER_00: Now, when a lot of people say that, it could be good.
• 5:28
  SPEAKER_00: But I see a number of projects that are bad projects, but they've got great marketing.
• 5:35
  SPEAKER_00: And all of a sudden they have lots of stars on GitHub.
• 5:37
  SPEAKER_00: So just be careful.
• 5:39
  SPEAKER_00: There is a data point, but it's not a deciding factor.
• 5:44
  SPEAKER_00: Just like open source, it's a data point.
• 5:47
  SPEAKER_00: It should not be a deciding factor.
• 5:49
  SPEAKER_00: So what should you evaluate when it comes to a third-party library or tool?
• 5:56
  SPEAKER_00: Well, number one, does it have a monetization strategy?
• 6:01
  SPEAKER_00: This is something that people just don't understand.
• 6:05
  SPEAKER_00: If a tool, if a library, if something you depend on does not have a way to make money, it does not matter how enthusiastic the team is.
• 6:17
  SPEAKER_00: It is in danger.
• 6:18
  SPEAKER_00: I'm not saying it's going to go away.
• 6:20
  SPEAKER_00: It may last for life.
• 6:22
  SPEAKER_00: You don't have to pay for Linux.
• 6:24
  SPEAKER_00: It's been around forever.
• 6:26
  SPEAKER_00: Now, yes, there's pay Linux versions or distros, but Linux.
• 6:29
  SPEAKER_00: You can that Linux has been around for a long time.
• 6:32
  SPEAKER_00: It's free.
• 6:33
  SPEAKER_00: Git, I would expect Git to be free forever.
• 6:36
  SPEAKER_00: Like there's a number of things that we depend on that, yes, they've been free forever.
• 6:40
  SPEAKER_00: But that doesn't mean it's something that you should ignore.
• 6:45
  SPEAKER_00: It is a big red flag when something does not have a monetization strategy.
• 6:52
  SPEAKER_00: At some point, the people developing it are probably going to get tired.
• 6:57
  SPEAKER_00: And at that point, the enthusiasm is gone.
• 7:00
  SPEAKER_00: Maybe their employer used to pay for this.
• 7:02
  SPEAKER_00: I know a number of packages right now that are starting to figure out monetization now.
• 7:06
  SPEAKER_00: It's kind of too late, but they're trying, because the fact that their work used to pay for it.
• 7:11
  SPEAKER_00: It used to pay for their time.
• 7:13
  SPEAKER_00: It used to pay for their work on the project.
• 7:16
  SPEAKER_00: Now it doesn't.
• 7:17
  SPEAKER_00: So what now?
• 7:19
  SPEAKER_00: Like now all of a sudden there's no money coming in and there's a lot of people saying, I have problems.
• 7:24
  SPEAKER_00: Please fix my problems.
• 7:26
  SPEAKER_00: So having a good monetization strategy is really important.
• 7:31
  SPEAKER_00: It makes me feel good when I can look at something and say, I understand how they make money.
• 7:38
  SPEAKER_00: Because here's the deal.
• 7:39
  SPEAKER_00: Yes, I don't like being nickel and dimed, I don't like having a subscription for everything I do.
• 7:43
  SPEAKER_00: I don't like having to pay hundreds and thousands of dollars just to maintain my life.
• 7:48
  SPEAKER_00: But at the same time, if an app depends on you continuing to pay, in general, they're going to do things that keep you paying.
• 8:01
  SPEAKER_00: Now, yes, there's a lot of companies, there's a lot of venture capital, other, you know, uh resources that come in and say, hey, you know what, we're going to squeeze the money out of people.
• 8:13
  SPEAKER_00: I get that.
• 8:14
  SPEAKER_00: But when you're looking at a library and they have a way to make money, they want you to continue using their library.
• 8:23
  SPEAKER_00: So they're going to do things that maintain that library, hopefully.
• 8:27
  SPEAKER_00: Now they'll also probably try and lock you in, all the rest.
• 8:31
  SPEAKER_00: There is a balance, but having a good monetization strategy means they're incentivized to keep going.
• 8:38
  SPEAKER_00: That's pretty important to me because when they're incentivized, they are thinking less about trying to figure out how to make ends meet and more about how to keep you going, which means better systems, means more features, it means being faster, whatever it means in order to make you keep going with their library.
• 9:01
  SPEAKER_00: Number two, does the creator have a track record of support?
• 9:06
  SPEAKER_00: So when you're looking at who is creating it, look at their track record.
• 9:11
  SPEAKER_00: Have they killed a whole bunch of products?
• 9:13
  SPEAKER_00: This is why when I look at Google's products and they call it a new product, I'm like, nope, not going to depend on it.
• 9:19
  SPEAKER_00: I haven't used Google's AI.
• 9:20
  SPEAKER_00: And the reason why?
• 9:22
  SPEAKER_00: I don't want to depend on anything Google creates, because I have been burned too many times.
• 9:28
  SPEAKER_00: I just don't trust them.
• 9:30
  SPEAKER_00: So even though they might have a great app or a great library or a great system, I go, I don't trust that.
• 9:37
  SPEAKER_00: Whereas other things I've used for years, I go, you know what?
• 9:41
  SPEAKER_00: Yeah, I kind of trust them because they've been around forever or because I know that they have supported other things.
• 9:46
  SPEAKER_00: And this is just one more thing.
• 9:49
  SPEAKER_00: Look at who they are.
• 9:50
  SPEAKER_00: Look at their track record.
• 9:51
  SPEAKER_00: And if possible, look for things that have a track record of success, of support, of customers that have been taken care of over time.
• 10:01
  SPEAKER_00: And then you can look at their products and go, okay, I'm more likely to consider that.
• 10:07
  SPEAKER_00: Number three, the question you probably should ask right the bat, but do you really need this dependency?
• 10:14
  SPEAKER_00: That's a question that too often people get caught up in, oh, I need this, I need this, I need this.
• 10:19
  SPEAKER_00: They never think, do I need this?
• 10:22
  SPEAKER_00: Or is this just a convenience thing?
• 10:25
  SPEAKER_00: And there are, I'm a big proponent of actually using third-party libraries.
• 10:30
  SPEAKER_00: I'm a big proponent of using tools that make your life better.
• 10:35
  SPEAKER_00: For example, almost practically without fail, if I'm going to access a SQL type database, I'm bringing in Dapper.
• 10:43
  SPEAKER_00: It's just almost a given at this point because it's a lightweight tool, it's been supported for a long time, it has a monetization strategy.
• 10:52
  SPEAKER_00: It's a great tool that I can depend on.
• 10:54
  SPEAKER_00: And it makes my life easier.
• 10:56
  SPEAKER_00: And I don't have to rebuild that every time.
• 10:59
  SPEAKER_00: So I'm not going to reinvent the wheel.
• 11:01
  SPEAKER_00: Even though it's open source, I could probably go and grab the code for it and you know just recompile it myself.
• 11:06
  SPEAKER_00: Not going to do that.
• 11:07
  SPEAKER_00: Okay.
• 11:08
  SPEAKER_00: So there are tools like that that I use.
• 11:10
  SPEAKER_00: And I'm a big proponent of using tools that are best for different systems.
• 11:14
  SPEAKER_00: I'm going to talk to Redis.
• 11:15
  SPEAKER_00: I'm going to use the Stack Overflow Redis tool or Stack Exchange Redis tool.
• 11:20
  SPEAKER_00: Because it's a proven tool and it's it's optimized and it's they've done all the work that I just don't want to do.
• 11:28
  SPEAKER_00: And be very careful not to confuse something works with something that's good.
• 11:40
  SPEAKER_00: Both of those are great examples of they're good, not just they work.
• 11:45
  SPEAKER_00: Because you know, Dapper, for example, it's practically as fast as raw ADO.NET code.
• 11:53
  SPEAKER_00: Okay.
• 11:54
  SPEAKER_00: But yet it's it's so much more performant for me as a developer when it comes to I just get my models out the way I want.
• 12:00
  SPEAKER_00: I send models in, I get models out.
• 12:02
  SPEAKER_00: That's so much more efficient than dealing with data tables and all the rest.
• 12:07
  SPEAKER_00: So that efficiency, though, is really important because I could probably recreate what DAPR does, but it wouldn't be as efficient.
• 12:14
  SPEAKER_00: So now I have slower code, but it's more efficient for me as a developer.
• 12:19
  SPEAKER_00: And I have to maintain that code too.
• 12:21
  SPEAKER_00: Like, be careful you weigh these things.
• 12:24
  SPEAKER_00: However, there are times where I've seen people bring on a whole new dependency because of one little thing.
• 12:30
  SPEAKER_00: Don't do that if you can help it.
• 12:32
  SPEAKER_00: Try and trim that down.
• 12:34
  SPEAKER_00: Instead of bringing in three different dependencies from three different sources, see if you can bring in from one that supports all three things.
• 12:41
  SPEAKER_00: Like try and figure out do I need this?
• 12:44
  SPEAKER_00: Do I even need to create this dependency?
• 12:46
  SPEAKER_00: And if I do, what's the simplest way of doing it?
• 12:49
  SPEAKER_00: Dependencies are something that can really hold you back as an application, as a development team.
• 12:54
  SPEAKER_00: So be very careful what you use.
• 12:56
  SPEAKER_00: But at the same time, the other side is true too.
• 13:00
  SPEAKER_00: It can hold you back if you're trying to rebuild everything yourself.
• 13:04
  SPEAKER_00: And don't just say that AI can do it.
• 13:07
  SPEAKER_00: AI can build working things, it is not build efficient things, it is not build things that are secure by default.
• 13:15
  SPEAKER_00: You've got to put the work in to make them efficient.
• 13:18
  SPEAKER_00: You've got to put the work in to make them secure.
• 13:20
  SPEAKER_00: You got to put the work in to make it write good code that's clean and simple and easy to read and understand, easy to maintain.
• 13:27
  SPEAKER_00: Otherwise, what you get is a lot of code that's harder to maintain.
• 13:32
  SPEAKER_00: And you just create more and more spaghetti that at some point it's gonna come crashing down.
• 13:36
  SPEAKER_00: So be careful.
• 13:37
  SPEAKER_00: There's a balance.
• 13:38
  SPEAKER_00: Taking on dependencies, it's always a risk.
• 13:40
  SPEAKER_00: You have to weigh the risk of taking one on against the risk of not taking one on or of taking a different one.
• 13:49
  SPEAKER_00: No matter what you do, there's a risk.
• 13:52
  SPEAKER_00: So you have to figure out which risk is most palatable.
• 13:57
  SPEAKER_00: The better you get at honestly evaluating risk, the better your app will be.
• 14:02
  SPEAKER_00: No matter what you do, you're gonna take on risk.
• 14:04
  SPEAKER_00: So make sure you take on the right risk.
• 14:07
  SPEAKER_00: Thanks for listening.
• 14:08
  SPEAKER_00: And as always, I am Tim Corey.