My adventure to .NET Core and how the latest preview made me happy again

Nick Pirollo
Jun 30, 2017 · 4 min read

When I first started programming as a teenager, I never really got past the world of scripting languages and hacking things together to make something in the shape of a game come together, and I pretty much stayed there through college. Like most people hanging in that area of the internet, I was nurtured to have a strangely large distaste for anything Microsoft related.

Was it really ever that bad working with their technologies? I never actually bothered to explore (feel free to let me know), but when I was developing at Vistaprint, I started to grow fond of a lot of Microsoft’s technologies — including C# and the .NET runtime. (Windows still has its shortcomings, but what can you do). That growing fondness aside, I was always struggling to fully get behind .NET in personal projects and found myself trying to get on to the latest and greatest language every time one popped up, only to have it die on the vine or really just be smoke and mirrors under the hood. Whether it was cost sensitivity, the speed with which I could develop, or something else, I always ended up back at square one using PHP.


Getting to the Core

In 2015, when Gradifi was getting started and I was transitioning away from the PHP world I created for myself at Scholly, we dug into the shiny promises of .NET Core: It was open source (trendy!), cross platform, much faster, “modern” and lightweight. With all that, we would still get the track record of Microsoft’s previous platform while running on Windows Server, which was a plus for us on the FinTech side — battle tested, enterprise support, reliable(-ish) and secure if you knew what you were doing, and there was a huge wealth of knowledge available (i.e. StackOverflow answers were a-plenty).

I played around with it myself for a while, we talked about it, and arrived at the consensus that it would be awesome to have a startup on the forefront of the next best thing in Microsoft land (something we’d have had a longer battle with inside a large organization), and Joe got started building out the first proof of concept of a .NET Core app. At the time, I continued about my life helping to support Scholly, oblivious to the fact I just made the same mistake I had made historically when jumping into a shiny new language — the latest isn’t always immediately the greatest to try to use.

Image for post
Image for post
Doh.

Core was explored a bit more and delivered on a bunch of its promises, but at the end of the day it was short on a ton of useful APIs that were in the latest .NET. On top of that, the first version increment completely flip flopped large chunks of the existing ones — rendering most of the base work useless. I mainly blame the fact that we explored a technology that was advertised as not fully ready, thinking of it in terms of the “old” Microsoft when beta meant they tested if for a year internally already, and not the new open source supporting Microsoft. With that, the adventure into Core died out just like my previous explorations in early tech, and “normal” .NET won yet again.


Two years later…

Over the course of the last few years something strange happened: I became a cult follower of C#. When it came time to build MVPs or hack something together on the quick, the Microsoft stack became my go-to for getting things done — unless a project had specific needs otherwise. Thinking on it, it is mostly because of comfort on my part, but otherwise I’ve found the hiring landscape much easier for people to find accessible talent, easier to vet where they stand on my radar, and Microsoft has really cut the cost of running their system in the cloud. Regardless, I hopped back on the .NET Core bus recently, and was pretty disappointed in the lack of progress externally, But once I dug in, there had been a ton done under the hood, and there was a 2.0 release planned that was what I had been waiting for — a pretty feature complete, platform independent, highly compatible set of APIs for the new runtime.

Once .NET Core 2.0 Preview 1 was released, I immediately began to play. I have to say, it delivered on everything I thought the original .NET Core / vNext would be and more. The ease of moving over to it from older versions, the .NET Standard evolution in compatibility between new and old, and the pretty noticeable pattern improvements over the cruft that had built around the old ones— not to mention the performance it can eek out.

One of the nicer parts of the latest preview — beyond the largely expanded amount of APIs available — is the newest SpaServices package Microsoft has put out. It makes scaffolding a base project using the latest technologies for both back and front end development super seamless. It’s literally on the level of “dotnet new react-redux” and you’re ready to go with yarn, webpack and the scaffolding for react-redux dropped in, including a basic development and production setup. Magic.

All said, .NET Core will be my go-to for any upcoming projects I put together and I highly recommend people who have historically been skeptical on Microsoft tech to check it out — even on your Mac.


Thanks for following along. If you enjoyed, click the heart below. Follow me on Instagram or, if you want to yell at me about my love of .NET Core, reach out on nickpirollo.com!

Welcome to a place where words matter. On Medium, smart voices and original ideas take center stage - with no ads in sight. Watch

Follow all the topics you care about, and we’ll deliver the best stories for you to your homepage and inbox. Explore

Get unlimited access to the best stories on Medium — and support writers while you’re at it. Just $5/month. Upgrade

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store