Latest / DevQuestions with Tim Corey / 014 Caliburn Micro Is No Longer Being Maintained. Now What?

Transcript

014 Caliburn Micro Is No Longer Being Maintained. Now What? · 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_01: Caliburn Micro is shutting down.
• 0:27
  SPEAKER_01: Now what?
• 0:28
  SPEAKER_01: I've gotten that question a lot recently since this channel uses Caliburn Micro for our MVVM framework in um WPF.
• 0:39
  SPEAKER_01: So we we use Caliburn Micro a lot, but now it's being kind of sunset or it's not being maintained anymore.
• 0:48
  SPEAKER_01: So what are we gonna do?
• 0:50
  SPEAKER_01: There's a bit of panic behind some people when they when they hear that because maybe they relied on that for their project.
• 1:00
  SPEAKER_01: Is it a waste?
• 1:01
  SPEAKER_01: Is it gonna hurt you?
• 1:02
  SPEAKER_01: What's gonna happen?
• 1:04
  SPEAKER_01: There's a lot of confusion around open source projects and what happens when they're not being maintained anymore.
• 1:12
  SPEAKER_01: So in this episode, we're gonna talk through that whole process.
• 1:15
  SPEAKER_01: We'll use Caliburn Micro as a an example, but this applies to anything.
• 1:21
  SPEAKER_01: We have this conversation somewhat with Squirrel.
• 1:25
  SPEAKER_01: I use Squirrel, which is a um an installer kind of like Click Once, but um their tagline is click once, but it works.
• 1:35
  SPEAKER_01: I used that and did in a demonstration, showed off how easy it was to do uh desktop deployment and then updates, and it really works great.
• 1:44
  SPEAKER_01: And then it wasn't very long later that someone posted on the open source project that it's not being maintained anymore.
• 1:53
  SPEAKER_01: I got a lot of questions about that.
• 1:55
  SPEAKER_01: Now, a group has taken over and has started to maintain it again.
• 1:58
  SPEAKER_01: They're still work looking for more contributors, but what do you do when that happens?
• 2:03
  SPEAKER_01: Caliburn Micro doesn't appear to have someone stepping in to fill that gap.
• 2:08
  SPEAKER_01: Unfortunately, it can't be me.
• 2:10
  SPEAKER_01: I am a huge fan of Caliburn Micro, but it's not something I have time to do.
• 2:15
  SPEAKER_01: I did reach out to see if I could help, but not to contribute code necessarily or do maintenance of it.
• 2:24
  SPEAKER_01: Open source projects are a bit different than closed source projects.
• 2:29
  SPEAKER_01: And it's more than just you can see the source code.
• 2:32
  SPEAKER_01: So let's talk through why do we rely on open source projects?
• 2:37
  SPEAKER_01: Well, because they do something that we don't want to have to reinvent or do ourselves.
• 2:44
  SPEAKER_01: Building software is not about recreating every piece.
• 2:49
  SPEAKER_01: We don't rebuild windows and create the menu bars all from scratch, we're even putting figuring out how to create a menu bar.
• 2:58
  SPEAKER_01: We've got a menu bar tool, we just drop it in.
• 3:01
  SPEAKER_01: We're reusing code.
• 3:03
  SPEAKER_01: The.NET framework,.NET Core, these are our frameworks that provide us with a lot of pre-built code.
• 3:13
  SPEAKER_01: When you say console right line, you're not worrying about how that works.
• 3:18
  SPEAKER_01: It's pre-built, it's done for you.
• 3:20
  SPEAKER_01: We use this all the time.
• 3:22
  SPEAKER_01: With open source projects, we're usually filling in the gap to make something a little better.
• 3:29
  SPEAKER_01: For example, logging.
• 3:30
  SPEAKER_01: You can use a third-party logging tool like Seek or Seralog, where you're um you're using Seralog to log your data in a way that's that's efficient, that goes to a number of different locations, that can work with Seek, that can do a whole bunch of other things that you have a lot, spend a lot of time building yourself.
• 3:51
  SPEAKER_01: Let's let somebody else build it once, and then we use it.
• 3:55
  SPEAKER_01: Well, Caliburn Micro is one of those great tools.
• 3:58
  SPEAKER_01: It it's an MVVM framework, a model view, view model framework that allows us to do a lot of the heavy lifting of MVVM behind the scenes.
• 4:09
  SPEAKER_01: It just does it and it just works.
• 4:12
  SPEAKER_01: Well, now it's not not being maintained anymore.
• 4:15
  SPEAKER_01: So, what if I have a project that relied upon it?
• 4:19
  SPEAKER_01: Well, the good news is it just works.
• 4:23
  SPEAKER_01: Caliburn Micro is not turning off.
• 4:26
  SPEAKER_01: It's not like tomorrow you're gonna come in and find that no MVVM code from Caliburn Micro works.
• 4:32
  SPEAKER_01: It will still work the same exact way as it did yesterday.
• 4:37
  SPEAKER_01: The difference is no new changes are coming in.
• 4:42
  SPEAKER_01: Now, with.NET 5 on the horizon, maybe that's a concern because maybe you want to move to.NET 5, but Caliburn Micro hasn't been tested against it.
• 4:55
  SPEAKER_01: Who knows if it will work or not?
• 4:57
  SPEAKER_01: It's just barely working with.NET Core.
• 5:00
  SPEAKER_01: So, how do we feel comfortable moving to this framework?
• 5:05
  SPEAKER_01: Well, maybe let's separate that out for a minute.
• 5:08
  SPEAKER_01: Because if we're talking about stuff that's already working in Caliburn Micro, then we already have a code base, it's already running, we leave it where it's at.
• 5:18
  SPEAKER_01: It still works.
• 5:18
  SPEAKER_01: We can still use it and still modify it and still build upon it and build more forms and views and all the rest, it will still work.
• 5:28
  SPEAKER_01: But if you want to upgrade it to.NET 5, then we have to think through what do we do?
• 5:34
  SPEAKER_01: Well, again, open source is different than closed source.
• 5:38
  SPEAKER_01: In open source, you have a source code.
• 5:42
  SPEAKER_01: Think of this way: if you didn't have Caliburn Micro, but you wanted to build into your project a reusable MVVM framework, because we all know we want to follow dry, don't repeat yourself.
• 5:58
  SPEAKER_01: So instead of repeating ourselves over and over, creating the the setups and the hooks and all the rest for an MVVM design, we say, you know what, let's do it once, we'll do it right, and then just reuse that library.
• 6:12
  SPEAKER_01: That's caliburn micro, that's what it is.
• 6:16
  SPEAKER_01: So that source code that you're using as a as a NuGet package, that's all on GitHub.
• 6:24
  SPEAKER_01: If you want to modify it, if you want to expand upon it, if you want to make it compatible with.NET 5, you can do that as if it were your own.
• 6:34
  SPEAKER_01: You have full access to do so.
• 6:37
  SPEAKER_01: In fact, Nigel Sampson, who's the the person who's right now stepping away from Caliburn Micro, when he came on, that's exactly what he did.
• 6:47
  SPEAKER_01: He wanted to have uh new support, support for more things and for more current things in Caliburn Micro.
• 6:57
  SPEAKER_01: At that point, um the project was kind of in a maintenance mode.
• 7:02
  SPEAKER_01: And so he stepped up and said, I'm gonna start making some changes and making this more compatible with the latest stuff.
• 7:09
  SPEAKER_01: And because of that, he took the project over.
• 7:13
  SPEAKER_01: Now, you could do that, you could maintain it yourself because if you wrote it yourself in the first place, if you say, you know what, nope, I'm not gonna rely on any third-party service, we're only gonna do stuff that that we build, then you're gonna have to build most of Caliburn Micro.
• 7:32
  SPEAKER_01: Now, maybe you don't support Xamarin, so you don't have to do all that Xamarin stuff.
• 7:36
  SPEAKER_01: Okay, fine, but you're still supporting Caliburn Micro, you're still building Caliburn Micro or the equivalent of it.
• 7:44
  SPEAKER_01: So if Caliburn Micro, if you use that instead, and you get ahead on your project because you don't have to build that MVVM framework, and then down the road, like it is right now, Caliburn Micro goes into maintenance mode or into a non-maintained mode at all, then you're okay because you can take that source code and continue on.
• 8:09
  SPEAKER_01: It's as if you had built it up to that point, and now you're just maintaining your code base all the way through.
• 8:16
  SPEAKER_01: So the code is there, you can maintain it.
• 8:19
  SPEAKER_01: Now it may be intimidating.
• 8:22
  SPEAKER_01: And I understand that.
• 8:23
  SPEAKER_01: And I understand that not everybody wants to maintain a large code base like Caliburn Micro is.
• 8:29
  SPEAKER_01: And yes, it's great to use tools that are just maintained forever, but that's not always what we get.
• 8:37
  SPEAKER_01: In fact, it doesn't matter if you're using paid tools or free tools, at some point they stop being maintained.
• 8:44
  SPEAKER_01: At some point, the company moves in a different direction, or the builder moves in a different direction.
• 8:49
  SPEAKER_01: It's gonna happen.
• 8:50
  SPEAKER_01: So you have to be ready to figure out what to do.
• 8:54
  SPEAKER_01: The great thing about open source is you have a source code.
• 8:57
  SPEAKER_01: You can continue it if you so desire.
• 9:01
  SPEAKER_01: Now, if you're starting a new project right now and you are thinking about caliber and micro for your MVVM framework, it's a great time to reevaluate that choice.
• 9:13
  SPEAKER_01: That doesn't mean you say, I'm not going to use Caliburn Micro.
• 9:19
  SPEAKER_01: It may be the best tool for the job, in which case, use it.
• 9:25
  SPEAKER_01: Again, it's not going away.
• 9:27
  SPEAKER_01: It's not turning off, it's not a late switch.
• 9:29
  SPEAKER_01: The code is still there, just like.NET Framework isn't going away.NET framework is gonna be here for a long time, even though it's not being updated, there's no new stuff being added to it.
• 9:48
  SPEAKER_01: It's stable, it's it's working.
• 9:51
  SPEAKER_01: So it'll still be there for years to come.
• 9:54
  SPEAKER_01: In fact, the team has said that.NET Framework will be here until Windows isn't here anymore.
• 9:59
  SPEAKER_01: Now, if that's true or not, we'll see.
• 10:02
  SPEAKER_01: But that still means it's gonna be there for a long time, just like Caliber and Micro, which the source code won't change.
• 10:10
  SPEAKER_01: It'll still be here years from now because it's open source.
• 10:15
  SPEAKER_01: You can take a copy of it called a fork and put it into your own repository just in case someone were to change it later or delete the project.
• 10:25
  SPEAKER_01: You can have a copy of it, and you can maintain that for life if you wanted to.
• 10:31
  SPEAKER_01: But if you're building a new project and you're thinking, you know what, I'm gonna build in.NET Core 3.1 today, but I'm really looking ahead to.NET 5 and really to.NET 6, which is next year.
• 10:43
  SPEAKER_01: So I'm looking forward to upgrading those projects, and I just don't see Caliburn Micro being the right solution because it's not gonna be updated to meet those new platform requirements.
• 10:56
  SPEAKER_01: That's totally fair.
• 10:58
  SPEAKER_01: And you should evaluate your choices based upon your needs.
• 11:03
  SPEAKER_01: So your needs are to be current for today and yet be up to date for tomorrow as well.
• 11:11
  SPEAKER_01: That's a tall order, and not every open source project or closed source project can do that.
• 11:20
  SPEAKER_01: You have to make your best judgment about who's gonna who's gonna bring the application forward.
• 11:28
  SPEAKER_01: And so there is some evaluation to go through.
• 11:31
  SPEAKER_01: And whenever you are looking at bringing in a dependency into your project, you do need to think who's gonna maintain this?
• 11:41
  SPEAKER_01: Is it gonna be maintained?
• 11:42
  SPEAKER_01: Is it gonna be a limiting factor for my application?
• 11:47
  SPEAKER_01: Third party or um dependencies in general are a two-edged sword because on one side they they allow you to move forward faster.
• 12:02
  SPEAKER_01: I don't want to write a logging framework.
• 12:04
  SPEAKER_01: Quite frankly, I don't want to write an MVVM framework.
• 12:07
  SPEAKER_01: I don't want to write a a framework for doing a lot of the things that I do.
• 12:12
  SPEAKER_01: Dapper, I love Dapper because it's great, it's simple, it works, and it's gonna be around for a long time.
• 12:21
  SPEAKER_01: Even if it was turned off, it would still work.
• 12:24
  SPEAKER_01: Okay.
• 12:25
  SPEAKER_01: But that's the one side of dependencies, is they allow you to move your code forward faster.
• 12:32
  SPEAKER_01: You don't have to write the code that they do.
• 12:36
  SPEAKER_01: So a Dapper, I write about four lines of C sharp code and I get data from SQL.
• 12:41
  SPEAKER_01: I write about another four lines of code and I can put data into SQL.
• 12:45
  SPEAKER_01: If I tweak a couple lines, now I can take that same read and write action and do it against SQLite.
• 12:52
  SPEAKER_01: Here's a great little tool that allows me to do something that would take me 15, 20, 30, 50, 100 lines of code, especially with casting the variables from a data table back to a strongly typed model.
• 13:07
  SPEAKER_01: Um, it takes me a lot of lines of code to do what Dapper does and allows me to do in four lines.
• 13:14
  SPEAKER_01: Well, that saves me time.
• 13:16
  SPEAKER_01: That means my application is easier to debug and it moves faster.
• 13:21
  SPEAKER_01: It allows me to get to my business logic, which is the heart and soul of my application.
• 13:29
  SPEAKER_01: What rules do I apply to my data?
• 13:31
  SPEAKER_01: That's really the structure that allows me to create my unique application.
• 13:38
  SPEAKER_01: Well, the more time I spend there, the quicker my application gets to market, the quicker my application grows and expands and changes over time.
• 13:48
  SPEAKER_01: Where the more time I spend on creating logging frameworks and creating ADO connections to databases, the more time I spend there, the less time I spend on my application itself.
• 14:02
  SPEAKER_01: So on the one side, these dependencies are great for moving us forward faster.
• 14:08
  SPEAKER_01: But on the other side, they also slow us down or stop us sometimes.
• 14:14
  SPEAKER_01: When we moved to.NET Core 3.0 from the.NET framework, we went through that upgrade process for the Timco retail manager, and then I created a course on it as well, where it upgraded four different project types to.NET Core.
• 14:30
  SPEAKER_01: Caliburn Micro is actually a limiting factor because it wasn't quite ready yet for.NET Core.
• 14:37
  SPEAKER_01: And because of that, I had to think about can we upgrade?
• 14:42
  SPEAKER_01: Now, fortunately, Nigel had an alpha version that was actually really stable that would work with.NET Core.
• 14:49
  SPEAKER_01: Well, I used that because I had a dependency that I had to make a choice on either use the alpha version or my project doesn't get upgraded.
• 15:00
  SPEAKER_01: That's what dependencies can do that can hold you back if you're not careful.
• 15:05
  SPEAKER_01: So there's a balance here.
• 15:07
  SPEAKER_01: There's a balance in a lot of programming, but this is a really clear example.
• 15:12
  SPEAKER_01: If you go on one side and say, I will not use any third-party dependencies, you're still limited.
• 15:19
  SPEAKER_01: You're going to be limited by a slow development process.
• 15:23
  SPEAKER_01: You're going to be limited by not as secure, not as efficient uh processes that do the same thing as its open source projects do for you.
• 15:32
  SPEAKER_01: I can't write, and I'm pretty sure you can't either.
• 15:35
  SPEAKER_01: I can't write a library that operates as fast as Dapper does and as reliable.
• 15:42
  SPEAKER_01: Well, I spent a lot of time trying and getting close, maybe, but that's not good enough.
• 15:49
  SPEAKER_01: So there's a lot of things to think about when you're talking about dependencies.
• 15:55
  SPEAKER_01: Too few and you're slowed down in development.
• 15:59
  SPEAKER_01: Too many, and you have too high a risk for not being able to upgrade your project to the next level.
• 16:07
  SPEAKER_01: So there's a balance to be hit here.
• 16:10
  SPEAKER_01: So that's kind of my thoughts on open source projects.
• 16:14
  SPEAKER_01: The fact that they're great and they do move you forward.
• 16:17
  SPEAKER_01: And when they go into maintenance mode or when they uh are no longer being maintained, they're shut down, whatever the case may be, even though that happens, they're still useful, they're still valuable.
• 16:32
  SPEAKER_01: But there is something said for evaluating if this is the right choice for a new project.
• 16:39
  SPEAKER_01: Now, specifically, when it comes to caliber and micro, I do want to say that I have been working behind the scenes to pick a new MVVM framework.
• 16:51
  SPEAKER_01: Because I do think that if you create a new project, you might want to think about which framework to use.
• 16:57
  SPEAKER_01: And so I have selected a new MVVM framework.
• 17:01
  SPEAKER_01: You'll see a video on that very shortly on how to work with it, how to get started.
• 17:06
  SPEAKER_01: And we'll talk through that process of picking a new project, a new uh dependency for a project, and how I came about the solution, how I chose which one to move forward on.
• 17:21
  SPEAKER_01: But another part of that is think through what your application depends on.
• 17:29
  SPEAKER_01: Is your application a production application?
• 17:32
  SPEAKER_01: If it is, it should either make you money or save you money.
• 17:36
  SPEAKER_01: That's what applications are designed to do.
• 17:39
  SPEAKER_01: Well, if it makes you money or saves you money, and you depend on a third-party resource like an open source project, don't you think that maybe you should support them as well?
• 17:51
  SPEAKER_01: They're supporting you.
• 17:53
  SPEAKER_01: I think it's only right that you support them.
• 17:56
  SPEAKER_01: In fact, now with the way GitHub is set up, you can actually contribute to open source projects, whether it's a one-time contribution or a uh a regular contribution.
• 18:08
  SPEAKER_01: And in fact, when we when I announce which uh framework we're going to choose for MVVM, one of the things that that I'm gonna do as I am Tim Corey is I am going to support financially that framework because I believe in supporting open source, not just with, hey, I'm using it and giving you more bugs to work through.
• 18:32
  SPEAKER_01: No, I believe in supporting it financially if you're able.
• 18:36
  SPEAKER_01: Because if I depend on it, then you should depend on me as well.
• 18:42
  SPEAKER_01: And so I would encourage you to think that through.
• 18:46
  SPEAKER_01: Think through what projects need my support and how can I best support them.
• 18:52
  SPEAKER_01: Sometimes it's not going to be financially, but maybe it is looking at helping them fix some bugs.
• 18:59
  SPEAKER_01: Or if you can't do that, help them with their documentation.
• 19:02
  SPEAKER_01: Make sure that you provide some kind of benefit to them, even if it's just spreading the word about their project.
• 19:11
  SPEAKER_01: But whatever it is, I would encourage you, if you depend on something, make sure they can depend on you as well.
• 19:18
  SPEAKER_01: Okay, that's my thoughts on the process to go through, the to think through when an open source project shuts down.
• 19:28
  SPEAKER_01: Whether it's I depend on it for a current application, don't panic.
• 19:33
  SPEAKER_01: Or whether I'm thinking about building a new application, it's time to evaluate.
• 19:39
  SPEAKER_01: Either way, make sure that you support your open source.
• 19:43
  SPEAKER_01: Thanks for listening.
• 19:44
  SPEAKER_01: And as always, I am Tim Corey.
• 19:46
  SPEAKER_00: Thank you for joining us for this episode of DevQuestions.
• 19:49
  SPEAKER_00: Tim is committed to making it easier for you to become a developer.
• 19:53
  SPEAKER_00: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 20:00
  SPEAKER_00: You can also send your questions to questions at IamtimCore.com.
• 20:05
  SPEAKER_00: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 20:12
  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.