We're now closing in on nearly three years since the announcement that Microsoft's .NET platform was going open source. I was pretty excited about that announcement because I imagined that the bits would come to be in the open and subject to feedback from the whole world. This has indeed been the case, but it's been something of a mixed blessing as .NET Core became a real thing.
I view the world through two lenses: work and POP Forums, my open source forum project. At work, there hasn't been any time where we've embraced .NET Core for a number of reasons. Either I was working on projects that were on long living code bases that couldn't be easily ported, or there was too much apprehension about the state of tooling and framework maturity to commit to it. That's unusual, because in the previous world of "closed" .NET, we'd usually move to the new hotness in a month or two, almost without fail.
POP Forums has been something else. I started to move to ASP.NET Core in September of 2015, during the preview phase, and I wanted to go all-Core, without relying on any of the "legacy" framework. It was pretty rough. Out of the box, I had to find something not in the framework to handle the sending of email via SMTP, and eventually settled on MailKit. I also needed something to resize profile images, since I previously relied on WPF classes. I eventually settled on ImageSharp, but after a few years, great as it is, they haven't done a general release yet. (Side note: If I did math good and understood image manipulation, this would be the first project I'd contribute to.) SignalR, used for the real-time updating of stuff, hasn't really made the journey with the rest of ASP.NET Core, but they're scheduling a release to come before the end of the year.
Then there was the constant churn of bigger picture things, like the project files. They changed those almost continuously. The CLI tooling mostly worked most of the time, but the visual tools did not. The Resharper test runner is broken again against Xunit tests. VSTS has never been able to keep up, so my CI builds are broken more often than they're working. Despite being in v2.0 now for .NET Core, the ecosystem really isn't very stable yet. The long and short of it is that I used to do forum releases almost simultaneously with framework releases, but my last release, for the legacy framework, came in February 2015. I haven't been at a point where I felt comfortable making a release just with feature parity. Every update to ASP.NET Core breaks stuff, and I spend a ton of time just updating references and fixing stuff.
All of that said, I do feel like we've turned a corner. It's not that it wasn't possible to ship stuff running on the platform (my simple blog has been on it for awhile), it's just been hard if you had a lot of moving parts, or you had dependencies you couldn't get. SignalR will be a solved problem soon, and it looks like the ImageSharp team is ready to a bona fide beta. With those two things in place, I'll be ready to finally get out a feature parity release to the old ASP.NET MVC (the version of which I no longer recall). I did some load testing on it last year, and whoa, it's not easily crushed.
Being open source, when something seems like a bit of a mystery, you can poke around the covers and find out how things work. Sure, sometimes I just wish there was better documentation, or I happened to read the announcements about an architectural change, but some things are pretty simple to dig into. You also get the kind of interaction with the developers that you didn't get when the code was mostly written in a bubble. (Though in early versions of MVC, I did have that interaction because I worked in the bubble.) I stumbled across a bug in 2.0 that is already on the list for getting fixed in 2.0.1, and you can see all of that happen right in front of you.
Oh, while not something I care that much about, it's admittedly pretty cool that I could build and run the forums on a Mac using JetBrains' Rider. That's pretty crazy.
It's been frustrating at times, but going open source with .NET has demonstrated that the stakes are very different for something that is quite literally at the core (pun intended) of everything that everyone using it wants to achieve. The two people that use the forum (OK, it's more than that) can generally roll with whatever I do, and fork it for their purposes, but .NET Core is subject to huge scrutiny. On one hand, you want to move quickly and be iterative, but significant changes cause a lot of pain. On the other hand, this was an enormous opportunity to break with more than 15 years of legacy, so the volatility is probably worth it in the long run.
For me, I look forward to eventually modernizing the forum app (the client side is stuck in 2012), and a year from now perhaps we can migrate the product at work to Core.