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

I finally decided to jump on the dev.to 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).

Dev.to 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 dev.to 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? https://www.gitkraken.com/invite/6zb3y67R

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 up-for-grabs.net) 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 https://crosscuttingconcerns.com/The-Second-Annual-C-Advent 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 https://crosscuttingconcerns.com/The-Second-Annual-C-Advent 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”:

[*.{cs,vb}]
indent_style = tab //TABS RULE
indent_size = 4

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

[*.cs]
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:
[*.{cs,vb}]
dotnet_style_require_accessibility_modifiers = always:suggestion

# CSharp code style settings:
[*.cs]
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:
[*.vb]
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:

dotnet_*
csharp_*
visual_basic_*

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:

[*.{cs,vb}]
dotnet_naming_rule.local_functions_should_be_pascal_case.severity = suggestion
dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions
dotnet_naming_rule.local_functions_should_be_pascal_case.style = 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 career edit

Today is bittersweet.

Today was my final day at Heuristics, and I had to bid adieu to my teammates of the last 4.33 years. We did a lot of cool things together, and I’m proud of everything we shipped (well, most of it anyway). I can honestly say that I learned a ton about begin a better software developer, about being on a remote team, shipping a quality application, and a lot more.

So, what’s next?

Well, I’ve accepted a position as a Senior Developer at JPMorgan Chase here in town, where I’ll get to put my skills to use on a .NET Core application, which I’m very excited about!

I don’t start until October 8th, so until then, I’ll be getting my home office rearranged into a “production studio” to support my Twitch channel / YouTube channel (CodeBytesTV) and upcoming podcast (.NET Bytes).


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.


comments database, physical, data model edit

I recently stumbled upon a new tool for modeling database structures - sqlDBM, and I had to share it because its awesome.

I generally always take a “database up” design approach to software development. For me, designing the physical data model really solidifies the forthcoming code.

In the past, I’ve used Toad (or whatever its called), and PowerDesigner (from SAP). Toad never really stuck for me, and PowerDesigner is crazy expensive. I don’t mind paying a few bucks a month for services, or a flat fee for a product - but PowerDesigner is in the thousands. Ain’t nobody got time for that.

With a little searching, the product came right to the top. I hadn’t seen it before (it’s still in Beta, so pretty new), but being web-based, it immediately caught my attention.

I signed up, validated my email address, and off I went. It was that easy.

Now, since sqlDBM is still in beta, I’m not currently paying anything for it - although they currently do have a “donate” option that I will likely use shortly.

I won’t go into the details of “physical database design”, but within the scope of what I’ve used - I’m impressed. I was able to quickly create a model, start adding tables, columns, and constraints - issue a save, and then share it out to other people with an invitation into the application. And, honestly, it looks good, too - even had a “dark” theme (which I totally love). Some of the other features mentioned on the website (that I haven’t yet personally used):

  • Revisions - Every time you save, a new revision is created - allowing you to rollback to a previous version is you mess up :)
  • MySQL Support - I’m using SQL Server, this is another option
  • Subject Areas - Create diagrams in separate “areas” to limit the viewing scope of the model

The level of physical data modeling I do anymore is minimal, but I’ll be keeping sqlDBM in my back pocket anytime the need comes up.

Check it out at https://sqlDBM.com!


comments programming, fiddler edit

Fiddler is a fantastic tool for assisting in debugging HTTP request/responses.

However, god forbid you try to scan the activity list for a specific request when other applications are constantly making outbound HTTP/S calls. Within a matter of seconds, the result view is chock full of crap.

I toyed around with the “custom rules” in Fiddler before, but lost them somewhere along the way - upgrades, new machines, etc.

Today, I decided to finally tackle it again. However, I wanted to add the rule as an option in the menu that is enabled by default, so that as soon as I launch Fiddler, it is automatically filtering the request output.

Start by launching Fiddler, and going to Rules | Customize Rules in the menu bar.

This will launch the Fiddler ScriptEditor.

Inside of the Handlers class, add the following code, which sets up a new menu item under “Rules”, called “Show Localhost Only”, with a default of true:

public static RulesOption("Show Localhost Only")
var m_ShowLocalhostOnly: boolean = true;

Now, scroll down until you find the OnBeforeRequest method. Looks like this:

static function OnBeforeRequest(oSession: Session) {        

Inside of that method, add the following conditional:

if (m_ShowLocalhostOnly && oSession.host.indexOf("localhost.com") == -1) {
	oSession["ui-hide"] = "true";
} 

Locally, when I’m developing, I have hostnames setup for all of my sites using localhost.com as the TLD. If you utilize something a little different, just modify the indexOf method inside of the if block.

Now, when I launch Fiddler, all of my requests are filtered out, by default, except for entries to *.localhost.com (Except for the Fiddler update check, because apparently that happens before the rule gets applied).

And, if I need to look at the other crap being logged, I can just toggle the menu item and turn it off for the duration of that Fiddler session.