comments dotnet, mvp edit

On November 1, 2019, I received an email stating that I had been awarded Microsoft MVP in Developer Technologies for my community contributions.

I was actually in a conference call with some work folks when I received the email, and I may have - MAY - have got a little excited and interjected that I had received it. Okay, not “may”, definitely “did”.

I was nominated back in June (or July?) of 2019, so I knew I was “in the system”. I regularly had to go and log contributions into the website for things that I had done. And, that’s when it hit me. I hadn’t just got nominated for current contributions. You see, I had to log, approximately, the last year’s worth. I realized while doing that, that I had been doing some of those things for a while. And, while I most likely said to myself at some point, “let’s go for MVP”, I had been working towards it for quite some time without necessarily realizing it.

Why is that?

Because I was doing what I loved doing. It just so happens that a lot of what I love doing, overlaps into MVP territory.

You see, I had started submitting PRs against documentation to various repositories (though, honestly, mostly Microsoft docs because thats usually where I spend most of my time). I started open sourcing my own creations (you can find them on my github profile). Some of those creations were developed on my live stream (which I also started during that time frame). Of course, one of the unfortunate things about streaming on Twitch is that the videos will “disappear” after a short time period, so I also ending up starting a YouTube channel where I push all of the recordingsI made conscious decisions to volunteer in the community, because, well, I love the community. Then, I started a podcast - because one has to these days, but also because I think its fun (we just released our 11th episode!).

What I’m saying is, I was going for MVP and didn’t even realize it until much later because I was making the contributions to help others and have fun. I hope that’s why you’ll get it, too.

If you have questions, please feel free to reach out - comment here, twitter, email, etc., whatever works best for you.

comments gitkraken, powershell edit

It’s no surprise how much I love GitKraken (the single best Git GUI in existence), right?

At the same time, I still love the command-line (my preferred console at this point being PowerShell Core).

I kept finding myself at the command-line, doing something in my local repository, and wanting to launch GitKraken without touching the mouse.

Since I’m on Windows, and the GitKraken installer adds a right-click context menu option, when right-clicking in a folder, of, “Open with GitKraken”: right-click context menu option

I knew the command-line parameters to do it existed - I just needed to find them. Launch regedit and do a search for gitkraken, revealed the command I was looking for inside of:


All I needed to do now was port that to a PowerShell alias of gitkraken (of course, you could change the alias however you see fit - gk, etc.).

Here is the code I ended up with, added to my PowerShell Profile. Notice that I wrapped the GitKraken command in a Function, and then aliased that as I had trouble just trying to tie the GitKraken command into the alias directly (probably just my lack of PowerShell skills)

Function Launch-GitKraken {
  Start-Process -FilePath "$home\AppData\Local\gitkraken\update.exe" -ArgumentList "--processStart=gitkraken.exe","--process-start-args=`"-p `"$(Get-Location)`"`""

Set-Alias -Name "gitkraken" -Value Launch-GitKraken -Force

Adding the code block above into your PowerShell profile - (traditional OR core - both have been tested and work).

Also, if you use VSCode, and have your terminal set to PowerShell, you can also launch it from there, since that also picks up your profile configuration - and here is an animated gif of that in action: (inception!)

POSH Kraken in Action

If you want to give GitKraken a try, do me a favor and sign up for trial using my referral code :)

comments autofac, oss, ioc, net edit

As developers, we want – nay, we NEED – to have options when it comes to Open-Source Software (OSS).

Is that library too opinionated for your project? That’s okay, choose another. Is that library not opinionated enough? That’s okay, choose another.

When I saw Scott Hanselman’s retweet of the @AutofacIoC call for help:

It. Just. Felt. Right.

How am I going to help? That’s still somewhat up in the air. I joined into the main project (and several extension projects), but I’m still in “learning” mode and trying to get my bearings on everything these folks have been building for quite some time. At the very least, I’ll probably be tweeting about it, blogging about it, and maybe even live streaming some of the work I do.

Stay tuned - going to be a fun ride!😊

comments dev-to, devto, cross-post, seo edit

I finally decided to jump on the bandwagon, and I don’t say that lightly. I generally despise third-party blogging platforms and that usually turns out to be a good decision (i.e., Medium). is different though, at least so far. They seem very transparent about the platform they’re building, where funding is coming from, etc. The feature that roped me in, however, was being able to import my RSS feed from this site, and make each imported post reference the original post here, as the canonical url.

For me, it’s about trying to get my posts in front of more people, because I don’t actually mind “managing my own blog”. For reference, when I say “managing my own blog”, I’m using:

  • Jekyll (ruby-based static website generator)
  • GitHub (hosting the code, and allowing it to be OSS - yes, you can submit a PR to one of my posts 😊)
  • Netlify (domain host).

The best part? It’s all 100% free (besides buying/renewing the domain name). And, to be completely honest, I enjoy this setup. I can write a post in markdown and push the code to GitHub. Once there, Netlify is “notified” of the code change, pulls the latest from my GitHub repository, builds, and then deploys it. Importing the posts to my profile is automatic, I just have to manually “publish” them once there.

All in all, it’s a beautiful thing.

Let me know if you’re interested in setting something like this up on your own and need some help, I love blogging and believe we need to do more of it (myself included)!

comments gitkraken, git, ambassador, bitbucket, github, azure-devops edit

I’ve been promoting the GitKraken Git Client for a little while on social media, because it’s such a beautiful, cross-platform, and just overall fantastic GUI Git client made by the folks over at Axosoft.

Recently, I learned that Axosoft started a GitKraken Ambassador program. The idea being that you help promote the product, and they provide “swag” (shirts, stickers, etc.) to give away - plus, they give you (as an Ambassador) a free one year license for GitKraken (and, no, I didn’t know about that part when applying :)).

Since I was already happily promoting the product, I applied, and earlier this evening learned that I was accepted!

What does this mean? Well, I’ll still be promoting the product, but I’ll probably make it a little more obvious (referral links, using it on live streams and videos, working it into conference talks, etc.). I’ll also be spending some time checking out (and promoting) GitKraken Glo Boards(a “Trello” competitor that integrates directly into the GitKraken Git Client)

If you’d like to try out GitKraken, maybe download it and give it a shot?

If you do, please let me know what you think!

comments dotnet, net, csharp, visualstudio edit

Just a quick post today about the launch of our new podcast, “.NET Bytes”. And, by “our”, I mean me and Matt Groves (of Cross-Cutting-Concerns fame)

The idea behind this podcast is to be an aggregate source of news about .NET / C# / Visual Studio / etc., but to your headset instead of your eyes. We’re also planning to highlight a project (probably from and potentially others.

Our release schedule right now is every two weeks (drop on Monday mornings at 7am), but if things pick up and we need to switch to weekly, we will. Or, we’ll do a special release when necessary, if something big happens.

We’re going to do our best to keep each episode to around 20-30 minutes - so lots of information, in a short time frame.

The podcast has been submitted to Apple, Google, and Spotify, but may not be live at the time of this writing.

Please let us know what you think, you can leave comments on individual episodes through our website), or tweet us at @dotnetbytes

And, please, tell your friends?

comments dotnet, csharp, visualstudio, yearinreview, csadvent edit

My second contribution to this year’s CSAdvent (and one of the final two posts!), hosted by my buddy Matt Groves. Visit to see the full calendar of posts!

The past year has been wonderful for the C# / .NET / Visual Studio developer community, so let’s take a quick look back at some of the great things that have come from Microsoft (and at how they progressed throughout the year)!

January 2018

January 2018 was mostly about “previews”, as we got our hands on:

  • Visual Studio 2017 version 15.6 preview 2
  • Visual Studio for Mac version 7.4 preview
  • Preview 1 of ASP.NET MVC 5.2.4, Web API 5.2.4, and Web Pages 3.2.4

Outside of preview versions, we also got:

  • .NET Framework 4.7.1

February 2018

February had a few road map releases (that were subsequently followed up with preview releases), such as :

  • .NET Core 2.1
  • EF Core 2.1
  • ASP.NET Core 2.1

February also saw the full release of ASP.NET MVC 5.2.4, Web API 5.2.4, and Web Pages 3.2.4, as well as some preview releases:

  • ASP.NET Core 2.1.0 preview 1
  • Visual Studio 2017 version 15.6 preview 4 (Did we skip 15.6 preview 3?)
  • .NET Framework 4.7.2 “Early Access Build 3052”
  • .NET Core 2.1 preview 1

In the “a little more exciting” category, we got our first taste of Blazor as an experimental project that promised C# and Razor running in the browser!

March 2018

In March, we got the full release of Visual Studio 2017 version 15.6 and Visual Studio for Mac 7.4, followed quickly with the first AND second preview of Visual Studio 2017 version 15.7 and the first preview of Visual Studio for Mac 7.5!

Also, with the release of VS 2017 15.6, we saw an update to the F# language and tools!

And, more previews!

  • .NET Framework 4.7.2 “Early Access Build 3056”
  • Preview 1 of ASP.NET MVC 5.2.58, Web API 5.2.5, and Web Pages 3.2.5
  • First “Public” preview of Blazor!

April 2018

Visual Studio 2017 version 15.7 preview 3 dropped, as well as a Visual Studio 2017 road map (a little late to the party, I’d say).

Other previews started dropping as well, such as:

  • ASP.NET Core 2.1.0 preview 2
  • .NET Core 2.1.0 preview 2
  • EF Core 2.1.0 preview 2
  • Blazor 0.2.0

Finally, a full release of the .NET Framework 4.7.2, as well as an announcement for a new “Library Manager” for managing client-side content for web applications.

May 2018

May saw an exciting slew of releases:

  • Azure Storage Explorer
  • ASP.NET MVC 5.2.5, Web API 5.2.5, and Web Pages 3.2.5
  • Visual Studio IntelliCode
  • Visual Studio for Mac version 7.5
  • RC 1 of .NET Core 2.1
  • RC 1 of EF Core 2.1
  • RC 1 of ASP.NET 2.1
  • Blazor 0.3.0 “Experimental”
  • ML.NET
  • Visual Studio 2017 version 15.7
  • F# Language and Tools update for Visual Studio 2017 version 15.7
  • C# 7.3

Before May was over (but only barely!), we got even more -

  • .NET Core 2.1
  • EF Core 2.1
  • ASP.NET Core 2.1
  • Visual Studio 2017 version 15.8 preview 2

May also gave us the announcement for .NET Core 3 with WinForms and WPF support!

June 2018

Right out of the gate (well, almost), we got ML.NET 0.2, .NET Framework 4.8 Early Access build 3621, Blazor 0.4.0 “experimental”.

Towards the end of the month, we saw Visual Studio 2017 version 15.8 preview 3, as well as the first announcement (that I can find) of Visual Studio 2019.

The first end-of-life (EOL, for short) statement of the year occurred in June, as well, with the announcement that .NET Core 2.0 EOL on October 1 2018.

July 2018

Not a lot going on in July, but we did get a few things:

  • ML.NET 0.3
  • Blazor 0.5.0 “experimental”
  • .NET Framework 4.7.2
  • .NET Framework 4.8 Early Access build 3622
  • F# 4.5 Preview

August 2018

August makes up a big for July with some big hitters:

  • Visual Studio 2017 version 15.8
  • Library Manager (part of Visual Studio 2017 15.8)
  • Visual Studio for Mac version 7.6
  • Library Manager CLI
  • ASP.NET Core 2.2.0 preview 1
  • ML.NET 0.4
  • F# 4.5

September 2018

Lots of previews for September!

  • Visual Studio 2017 version 15.9 preview 2
  • ASP.NET Core 2.2.0 preview 2
  • EF Core 2.2.0 preview 2
  • .NET Core 2.2.0 preview 2
  • ML.NET 0.5.0
  • .NET Framework 4.8 Early Access build 3646

October 2018

October saw a number of preview releases, much like September:

  • ML.NET 0.6.0
  • ASP.NET Core 2.2.0 preview 3
  • .NET Core 2.2.0 preview 3
  • EF Core 2.2.0 preview 3
  • Blazor 0.6.0 “experimental”
  • Visual Studio 2017 version 15.9 preview 3
  • .NET Framework 4.8 Early Access build 3673

We received the first announcement of Visual Studio 2019 for Mac, as well as a Visual Studio for Mac road map!

November 2018

The number of previews is slowing down as we head into the holiday season (and as a couple of things get a full release):

  • Razor support in VSCode in preview
  • Blazor 0.7.0 “experimental”
  • .NET Standard 2.1
  • ML.NET 0.7.0
  • .NET Framework 4.8 Early Access build 3694

Finally, we received Visual Studio 2017 version 15.9, and Visual Studio for Mac version 7.7!

December 2018

Once the folks at Microsoft got over their Turkey comas, we got some early holiday gifts:

  • ML.NET 0.8.0
  • .NET Core 2.2
  • ASP.NET Core 2.2
  • EF Core 2.2

We also got some nice previews during the month as well, such as:

  • Visual Studio 2019 preview 1
  • .NET Core 3 preview 1
  • C# 8.0 (Note: not “all” features are available yet)
  • .NET Framework 4.8 Early Access build 3707

Well, folks, that’s a wrap on 2018. We received tons of updates from Microsoft all across the board - from new experimental frameworks (Blazor) to quick iterations of the “Core Suite” (.NET, EF, and ASP.NET) and Visual Studio.

As we head into the new year, we have some exciting things to look forward to as well, such as the release of Visual Studio 2019 (though expect a few more previews first), .NET Core 3, C# 8.0, and .NET Framework 4.8 (which may be the last one for a while).

I hope you’ve enjoyed this trip down memory lane with me as we looked back on 2018 as well, as the 2018 C# Advent posts.

Have a wonderful holiday season (however you choose to celebrate it)!

And, remember, be kind to one another.

comments .net, c#, visual-studio, csadvent edit

My contribution to this year’s CSAdvent, hosted by my buddy Matt Groves, is all about trying to surface your coding and naming standards right in Visual Studio. Visit to see the full calendar of posts!

Starting in Visual Studio 2017, we have the option of using an “.editorconfig” file to define tons of editor standards - from basic things, such as “Tabs versus Spaces”:

indent_style = tab //TABS RULE
indent_size = 4

to more advanced items like, “prefer curly braces to surround code blocks” (with an associated severity)

csharp_prefer_braces = true:none //"PREFER" them, but don't highlight the code in the editor

Backing up a bit, the .editorconfig file/format is an open standard that Microsoft has adopted as a first class citizen in Visual Studio. The open standard doesn’t define specific coding styles/standards (like we see above with csharp_prefer_braces), so those only apply to plugins or tools that know about them (i.e., Visual Studio - and I would expect, eventually, VSCode as well)

The greatest part about this, to me, is the ability to define various standards and what severity to surface them, all without third-party tooling (such as ReSharper).

I am able to define this rules in a plain-text file, and simply check it into my repository.

There are tons of rules you can apply, such as csharp_prefer_braces, to specifying the exact order you prefer your modifiers in:

# CSharp and Visual Basic code style settings:
dotnet_style_require_accessibility_modifiers = always:suggestion

# CSharp code style settings:
csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:suggestion

# Visual Basic code style settings:
visual_basic_preferred_modifier_order = Partial,Default,Private,Protected,Public,Friend,NotOverridable,Overridable,MustOverride,Overloads,Overrides,MustInherit,NotInheritable,Static,Shared,Shadows,ReadOnly,WriteOnly,Dim,Const,WithEvents,Widening,Narrowing,Custom,Async:suggestion

And, as you can see, VB.NET is also supported. The rule name itself indicates the targeting:


You might be thinking, “That’s great, Calvin, but how does that make them any more discoverable?”. Wonderful question. The “discoverability”, lies in the severity ratings that most (not all) of the rules can accept:

Severity Description
none Does not show anything to the user when the rule is violated. Rules with this severity never appear in the Quick Actions or Refactoring menus.
silent/refactoring Does not showing anything to the user when the rule is violated, however, these rules will show up in the Quick Actions or Refactoring menus.
suggestion When this style rule is violated, show as gray dots under the first two characters.
warning When this style rule is violated, show it to the user as a compiler warning
error When this style rules is violated, show it to the user as a compiler error

As you can see, picking the proper severity will help surface these rules to your developers, right inside the IDE.

I have started leaning towards the warning severity, as the suggestion style is difficult to see (in my opinion).

We’ve only discussed stylistic standards up to this point, but what about your good ‘ole fashion naming standards? We need that private variable to start with an underscore, no exceptions! Well, you can do that, too!

Granted, naming standards get a little more involved, so let’s look at an example.

Here is an example that defines that all Local Functions are named using PascalCase:

dotnet_naming_rule.local_functions_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions = local_function_style

dotnet_naming_symbols.local_functions.applicable_kinds = local_function

dotnet_naming_style.local_function_style.capitalization = pascal_case

This block defines a variety of things, but ultimately says that any “local_function” (applicable kinds) is “suggested” (severity) to be in “pascal_case” (capitalization).

These types of rules are a little more difficult to wrap your head around, so I suggest looking over the Visual Studio documentation to get a better understanding.

If you have any questions or comments, feel free to leave them below, and I’ll try to help in any way I can!

comments dictionary, sdd, boxing edit

For our first dictionary entry, we’re going to take a look at the term, “Boxing”.

Boxing can be described as the process of converting a value type (integer, decimal, char, etc.) to the object type, or to any interface type that the value type implements.

The act of “boxing” is implicit (it is possible to box explicitly as well, but not required), whereas the act of “unboxing” is explicit.

Take a look at the following example code that boxes the unboxedInt into the object boxedInt:

int unboxedInt = Int32.Max;

object boxedInt = unboxedInt;

Boxing is a fairly expensive process, as a new object, boxedInt, is created on the stack, which then references a copy of the unboxedInt value on the heap (which allows for garbage collection).

comments dictionary, sdd edit

Recently, I read a question that I simply didn’t know the answer to:

What is Boxing?

I “knew” to some degree that it was related to conversion - but that was it.

Thinking through that a little more, realizing that I’ve been a developer for over 15 years - over 10 professionally, and I didn’t know that answer. It bugged me. It got me thinking about other terms in software development that, maybe I’ve heard, but don’t really know the answer to either.

Hence this new blog series that I’m coining as “The Software Developers’ Dictionary”. Simply put, I plan on blogging about these terms I run across (boxing, covariance, contravariance, etc.), defining them in plain English with some type of sample code (probably C#, cause that’s what I do). And, to be honest, I’m doing this for me (although I would hope it helps at least ONE other person out there :) ). I know these terms are searchable on Google, Wikipedia, etc., but I feel like the exercise of writing it out with sample code will solidify it for me.

I’m not going to go in any specific order (alphabetical, etc.), because I just don’t know what terms I even plan to define here yet (outside of a small handful).

Eventually, depending on how many of these I do, I’ll pull all the individual posts into a table of contents, for easier navigation.

Stay tuned for the first entry coming later this week on, “Boxing”.

Oh, and, dear reader, if you have suggestions, please comment below and let me know.