Jim Buck

<a href="https://visualstudio.microsoft.com/vs/">Visual Studio 2019</a> officially launched today, with the theme of &quot;Productive, Modern, Innovative&quot;. Among the many changes to project creation, editor experience, and debugger features, one brand new feature shines brighter than the rest: <a href="https://visualstudio.microsoft.com/services/live-share/">Visual Studio Live Share</a>.
<h3>What is It?</h3>
Visual Studio Live Share is a realtime collaboration tool that allows for multiple developers to work &quot;side-by-side&quot; over the network. Think of it as a mix between Google Docs and an SSH session. Live Share allows a presenter to allow up to 30 people to view, edit, and debug their local project.
Not to be confused with a screen share, Live Share actually sends contextual data about the code and cursor positions that get rendered by your local IDE. This means Live Share will work great on low-bandwidth networks and across OS's, resolutions, and accessibility settings.
It can even share debug information, allowing for greater collaboration when stepping through code. Finally, shell access can be shared with users that allow them to run any command as if they were logged into that machine.
While this seems like a lot of power for users to have over your machine, you can restrict users to be readonly if you so choose.
Live Share is supported via extensions for VS2017, VS2019, and VS Code, with VS Code allowing you to share cross-platform between PC, Linux, and Mac.
<h3>When would I use it?</h3>
I foresee three main use cases for Live Share, each ranging from beginner to expert levels.
<ol>
<li>**Educational **- A teacher or mentor can help a student write an algorithm or demonstrate different data structures. You can even use shell access to help teach <code>git</code> commands to both young and old.</li>
<li>**Presentational **- A speaker demonstrating the latest library or tool can improve the quality of their presentation by allowing readonly viewers to enjoy the code on their own machines, without the risk of &quot;getting lost&quot; or &quot;out of sync&quot; with the presentation.</li>
<li>**Investigational **- A group of developers, testers, and/or designers and efficiently debug a complex module to determine the root cause. Once the problem code is found, the group can easily discuss options and implement them in realtime, effectively a code review before the commit is even made.</li>
</ol>
<h3>Where can I find more information?</h3>
The following video provides an excellent overview of the features, specifically cross platform collaborative debugging. You can also check out the detailed <a href="https://docs.microsoft.com/en-us/visualstudio/liveshare/">online documentation</a>, which includes great information on getting started, how connectivity works and common uses cases.
Jon Chu - Collaboration made easy with Visual Studio Live Share
<h3>My Thoughts</h3>
I am extremely excited to try this feature out in daily use. The key factor to its success will be ease of use and performance (specifically around shared debugging). But between enterprise network restrictions, extension version mismatch, and the perf drops that hit with large multi-tier projects, I'm expecting the initial experience to have it's hiccups. Regardless, this is a feature I think will be fantastic for code reviews and brownbag presentations. Just make sure you trust the users you share with!

What's New: Visual Studio Live Share

I might have missed it by one day, but I wanted to close out 2020 with a quick summary and share my plans for the future. That being said, please enjoy my very first YouTube video!
<div class="image-set">
	<figure>
 <iframe width="1280" height="720" src="https://www.youtube-nocookie.com/embed/oBtX4sBrI40" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
 <figcaption>Pardon the jankyness, future videos will be more polished!</figcaption>
 </figure>
</div>

2020 Recap

Whether you are on a big team or a small team, complexity is one of the most common problems among developers. Even projects with just one developer can easily get out of hand when it comes to architecture. Thankfully there are easy measures you can take to prevent your project from falling into a pit of complexity.
<h2>Background</h2>
Now obviously the best approach is proper planning. Taking time to think through requirements, potential issues, and how to set everything up can save you tons of time later down the road. Unfortunately even the best plans can still get muddy when you add more developers, increase scope, or move up deadlines. I think some of the worst mistakes aren't the concious &quot;hacks&quot; or intentional tech debt, but rather the bad decisions we don't even know about. Thankfully that's where tools can save the day!
Static analysis tools read through your codebase and find potentially problematic areas of code. The most common problems are usually around unhandled exceptions, memory leaks, complex code blocks, and more. If you can integrate these tools into your daily workflow, or even better your DevOps pipeline, you will find the quality of your codebase will improve.
My clients have often asked about which static analysis tools to use, but rarely want to take the time to try out the options. One such tool that I've seen come up time and time again is <a href="http://jimb.uk/ndepend">NDepend</a>. Of the tools I've read about, NDepend seems to be the most developer focused tool with a great set of features for maintaining complex projects. So over the next few months I will be making NDepend a daily driver to get to know it a little better.
I would like to send a sincere thanks to Patrick from the NDepend team for giving me a pro license to play around with. As always I only share my genuine thoughts and opinions about anything I review, good and bad. But something tells me this is gonna be pretty good, especially since they just added <a href="http://jimb.uk/ndepend_dotnet5">full support for .NET 5 and Blazor</a>!
<h2>Top Features</h2>
Let's take a look the features I'm most excited to get my hands on:
<h3>Code Rules</h3>
This is really the core functionality of &quot;Static Code Analysis&quot;, find the problems/bad practices in your projects. I'm super interested to see what <a href="http://jimb.uk/ndepend">NDepend</a> can find in my current projects and what it might find in some popular open source projects. The best part is that code rules are written using C# Linq queries, so editing existing rules or creating custom ones looks to be very straightforward.
<div class="image-set">
 <figure>
 <img src="/uploads/ndepend-code-rule-edit-example.png" alt="Screenshot of the editing a code rule in NDepend using Linq."/>
 <figcaption>Rules are just Linq statements! (with very detailed intellisense)</figcaption>
 </figure>
</div>
<h3>Tech Debt Estimate</h3>
If it works as advertised, the ability for <a href="http://jimb.uk/ndepend">NDepend</a> to estimate how much time it will take to fix a code smell will be a game changer for planning sessions. It also estimates how much time will be saved over the next year just by fixing it. And again, these calculations are all done in C# Linq queries, so they can be tweaked and customized to your liking.
<div class="image-set">
 <figure>
 <img src="/uploads/ndepend-tech-debt-example.png" alt="Screenshot of NDepend's tech debt estimates inside of Visual Studio."/>
 <figcaption>Annual Intrest is the number of days it will cost you if you don't fix it.</figcaption>
 </figure>
</div>
<h3>DevOps Integration</h3>
All of the features sound great, but there is nothing more satisfying than automating all of these checks and tracking them over time. It looks like <a href="http://jimb.uk/ndepend">NDepend</a> can integrate with quite a few DevOps platforms, but I will be focusing on Azure DevOps since that't what we use for almost all of our projects. And no PM can resist more dashboard widgets and quality gates!
<div class="image-set">
 <figure>
 <img src="/uploads/ndepend-devops-dashboard-example.png" alt="Screenshot of the NDepend dashboard inside Azure DevOps."/>
 <figcaption>Dashboard widgets for all of the metrics/trends!</figcaption>
 </figure>
</div>
<h3>Performance</h3>
Based on the &quot;real world proof&quot;, NDepend is lightening fast and uses minimal memory. Even on a laptop with an i9, 500GB SSD, and 64GB RAM I have trouble running some tools (I'm looking at your <a href="http://jimb.uk/resharper">Resharper</a>) at full throttle. If <a href="http://jimb.uk/ndepend">NDepend</a> can analyze my entire codebase with virtually zero impact on Visual Studio then I will be very happy camper!
<h2>Wrap Up</h2>
I've been wanting to test NDepend for months now and I can't wait to see how it scores my projects. I'm optimistic that it will be a valuable tool, but I also hope it can teach me better ways to write code. Because at the end of the day writing better code, pausing to plan, and working together is a guarenteed combo for building better software.
<hr>
Have you used NDepend, or any other static analyzer? <a href="http://jimb.uk/twitter">Send me a tweet</a> and let me know about it!!

Eyeglasses sitting on a laptop with the screen in focus.

Getting Started with NDepend

With 2020 in full swing I figured an official update was quite overdue. It's been a busy few months for me personally, which is why there hasn't been any new articles. I assure you though, I have a few exciting things in the pipeline!
<h2>Recap</h2>
So here's a quick recap of the last few months:
<ul>
<li>September (on my 30th birthday) we found out we are expecting our second child!</li>
<li>November my wife and I bought a new house in our hometown in Pennsylvania so we could be closer to friends and family. The house is in decent shape but needed new carpet, deep cleaning, and lots of paint.</li>
<li>December kept me busy painting all of the bedrooms (thank you to Netflix for keeping me sane).</li>
<li>January we were surprised to discover our second child is a boy! I was also accepted in the <a href="https://dotnetfoundation.org/">.NET Foundation</a>, became a <a href="https://www.scrumalliance.org/get-certified/scrum-master-track/certified-scrummaster">Certified Scrum Master</a>, and took over a significant account in my day job. Oh and I made approximately 12+ trips back and forth to move essentials and comforts to our new house (thank you to multiple podcasts for keeping me sane).</li>
<li>February we moved our furniture up from the old house and started the process of listing our house.</li>
</ul>
TL;DR - We've got a new house, a son on the way, a house that we need to sell, more day work, and acceptance into the .NET Foundation! Phew, what a way to close out 2019!
<h2>Plans for 2020</h2>
As I said, I have a few things in the pipeline for 2020. First and foremost our son is due at the end of May! I have been working on Part II of my <a href="https://jimbuck.io/asp-net-core-req-pipe-0/">ASP.NET Core Request Pipeline series</a>, as well as some articles around static code analysis and other tooling. I'd also like to dive into Blazor a bit more (how does building peer-to-peer desktop apps sound?). And we've got some time, but <a href="https://devblogs.microsoft.com/dotnet/introducing-net-5/">.NET 5</a> is (currently) set to release in November, so I will absolutely be covering all details of the release and specifically how to upgrade existing projects.
I have another project that is still secret for now, but I am extremely excited about getting started on it. It will be a ton of work, and will evolve over time, but I think it will fulfill a very important need in the greater .NET Community.
What do you want to learn about in 2020? <a href="https://twitter.com/jimbuckio">Send me a tweet</a> and tell me your goals for 2020. I'd love to help you on your developer journey!

2020 Blog Update

With the recent official release of .NET Core 3, I thought I'd take a stab at a fun little experiment. I love using Electron to create web-powered desktop apps. And I wanted to learn more about Blazor, the newest addition to the <a href="http://ASP.NET">ASP.NET</a> family. In this post I will show you exactly how to get started with Blazor and Electron in under 15 minutes!
UPDATE: This post is featured in <a href="https://csharpdigest.net/digests/284">C# Digest #284</a> and I will be giving a <a href="https://www.meetup.com/BaltoMSDN/events/266231295/">talk about Desktop Apps with Blazor in Baltimore on November 20th</a>!
<hr>
<h2>Prerequisites</h2>
<ul>
<li><a href="https://dotnet.microsoft.com/download/dotnet-core/3.0">.NET Core 3.0 SDK</a></li>
<li><a href="https://nodejs.org">Node.js with npm</a></li>
</ul>
Be sure to install both the .NET Core SDK and Node.js (you can check versions using <code>dotnet --version</code> and <code>node --version</code>). We need .NET Core 3.0 because we're going to scaffold out the Blazor application using <code>dotnet new</code>. We also need .NET Core 3.0 for <a href="https://github.com/ElectronNET/Electron.NET">Electron.NET</a>, the library that allows for Electron &amp; .NET integration. Node.js is used to download, configure, and integrate with the actual Electron instance.
<h2>Setup</h2>
Setup requires a few simple steps. While most steps are simply commands, there are 2 files that require manual edits. And once your project is setup, there's just one command to start it up!
<h3>Commands</h3>
<pre class="hljs"><code>mkdir blazor-electron-demo
cd blazor-electron-demo
dotnet new blazorserver --no-https
dotnet add package ElectronNET.API
dotnet new tool-manifest
dotnet tool install ElectronNET.CLI
dotnet electronize init
</code></pre>
That's quite the block of commands, but they are all pretty simple and don't require any user interaction. Let's breakdown what each command is doing:
<table class="blazor-setup-command-breakdown">
 <tbody>
 	<tr>
 <td><pre><code>mkdir blazor-electron-demo 
cd blazor-electron-demo</code></pre></td>
 <td>Creates a folder for our project and sets it as the current working directory. Be sure to change this to your preferred project name!</td>
 </tr>
 <tr>
 <td><pre><code>dotnet new blazorserver --no-https</code></pre></td>
 <td>Scaffolds out a new server-side Blazor app, without support for HTTPs.</td>
 </tr>
 <tr>
 <td><pre><code>dotnet add package ElectronNET.API</code></pre></td>
 <td>Installs the NuGet package that adds Electron support to ASP.NET apps.</td>
 </tr>
 <tr>
 <td><pre><code>dotnet new tool-manifest</code></pre></td>
 <td>Adds support for locally installed `dotnet` tools.</td>
 </tr>
 <tr>
 <td><pre><code>dotnet tool install ElectronNET.CLI</code></pre></td>
 <td>Installs the required `electronize` tool locally to the project.</td>
 </tr>
 <tr>
 <td><pre><code>dotnet electronize init</code></pre></td>
 <td>Sets up Electron.NET manifest and updates launch profiles.</td>
 </tr>
 </tbody>
</table>
Sets up <a href="http://Electron.NET">Electron.NET</a> manifest and updates launch profiles.
All commands should be executed in order and one at a time. Once they all complete, you are just two file changes away from running the application!
<h3>File Changes</h3>
In order for the <a href="http://ASP.NET">ASP.NET</a> application (Blazor app, in this case) to integrate with Electron, we need to make changes to <code>Program.cs</code> and <code>Startup.cs</code>.
<h4>Inside <code>Program.cs</code>:</h4>
<pre class="hljs"><code>using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ElectronNET.API; // ADD THIS!

namespace blazor_electron_demo
{
 public class Program
 {
 public static void Main(string[] args)
 {
 CreateHostBuilder(args).Build().Run();
 }

 public static IHostBuilder CreateHostBuilder(string[] args) =&gt;
 Host.CreateDefaultBuilder(args)
 .ConfigureWebHostDefaults(webBuilder =&gt;
 {
 webBuilder.UseStartup&lt;Startup&gt;()
 .UseElectron(args); // ADD THIS!
 });
 }
}
</code></pre>
<h4>Inside <code>Startup.cs</code>:</h4>
<pre class="hljs"><code>using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using blazor_electron_demo.Data;
using ElectronNET.API; // ADD THIS!

namespace blazor_electron_demo
{
 public class Startup
 {
 public Startup(IConfiguration configuration)
 {
 Configuration = configuration;
 }

 public IConfiguration Configuration { get; }

 public void ConfigureServices(IServiceCollection services)
 {
 services.AddRazorPages();
 services.AddServerSideBlazor();
 services.AddSingleton&lt;WeatherForecastService&gt;();
 }

 public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
 {
 if (env.IsDevelopment()) {
 app.UseDeveloperExceptionPage();
 } else {
 app.UseExceptionHandler(&quot;/Error&quot;);
 }

 app.UseStaticFiles();
 app.UseRouting();
 app.UseEndpoints(endpoints =&gt;
 {
 endpoints.MapBlazorHub();
 endpoints.MapFallbackToPage(&quot;/_Host&quot;);
 });

 // ADD THIS!
 Task.Run(async () =&gt; await Electron.WindowManager.CreateWindowAsync());
 }
 }
}
</code></pre>
With these two files updated we are now ready to run our app inside of Electron!
<h2>Usage</h2>
<h3>Run</h3>
Our app can be ran in two separate ways. Either with via the command line or through Visual Studio's &quot;Run&quot; dialog (thanks to the launch profile added during the setup using <code>dotnet electronize init</code>).
<pre><code>dotnet electronize start
</code></pre>
<div class="image-set">
 <figure>
 <img src="/uploads/running-app.png" alt="Screenshot of a Blazor app running in a standalone desktop window."/>
 <figcaption>Blazor running in a desktop app!</figcaption>
 </figure>
</div>
<h3>Debug</h3>
Once running, you can attach the debugger from Visual Studio's <code>Debug &gt; Attach to Process...</code> and filtering by the project name. Breakpoints will work exactly as expected when running a .NET app. You can even debug the code inside the Razor files! The only downside is when you need to make a change you'll have to stop the app, edit the changes, and restart it. We'll talk more about that a little later.
<h3>Publish</h3>
Thanks to <a href="http://Electron.NET">Electron.NET</a>, we can publish our application to a platform-specific installer in one command!
<pre><code>dotnet electronize build /target win
# OR
dotnet electronize build /target osx
# OR
dotnet electronize build /target linux
</code></pre>
<blockquote>
Windows Note: I did experience an exception about <code>The given key 'target' was not present in the dictionary.</code> while running the command from a <code>mingw64</code> prompt. Try the command again using a native <code>cmd</code> or <code>powershell</code> prompt.
</blockquote>
This command will create a new installer under the <code>./bin/desktop</code> folder. Inside you will find the installer for your platform!
<h2>Sample Code</h2>
I've created a <a href="https://github.com/jimbuck/blazor-electron-demo">GitHub repo demonstrating all of the changes we just made</a>. Use it as a resource if you are having trouble, or <a href="https://twitter.com/jimbuckio">reach out to me on Twitter</a>!
<h2>Caveats</h2>
While this union of two technologies is fun, it does have its drawbacks. Ranging from developer workflow issues to API mismatch, these issues may be annoying but they are by no means a deal-breaker to using Blazor and Electron.
<h3>Developer Workflow</h3>
The most severe issue is the slow iterative development process. At this time the developer workflow involves starting the app, manually attaching the debugger, testing the app, then stopping the app to make changes and finally restart the cycle. Without the ability to hot reload after changes this makes development significantly more difficult. The maintainers of <a href="http://Electron.NET">Electron.NET</a> recommend developing the app in the browser for the majority of tasks, and only switch to electron for periodic testing.
<h3>Electron API/Interop</h3>
<a href="http://Electron.NET">Electron.NET</a> is young but comprehensive. Creating a functional bridge from C# &amp; .NET to JavaScript &amp; Node.js/Electron is no small feat. But there is a high chance that you will find a method or event that is not implemented. Remember that <a href="http://Electron.NET">Electron.NET</a> is a free library created by people in their spare time. Every single feature may not be present, but that's where open source shines. If you found a hole in the API or a feature that needs some work, then fork the project and try finding the fix yourself. Most of the time building software is a collaborative effort, and it can be very rewarding to help solve the issues rather than just waiting for them to be fixed.
<h2>Summary</h2>
We created a brand new Blazor project, added support for Electron thanks to <a href="http://Electron.NET">Electron.NET</a>, and created an installer ready for release! While some caveats do exist when building with a dev stack this cutting edge, there is absolutely nothing stopping you from building incredible desktop applications using Blazor. And with help from developers like you, <a href="http://Electron.NET">Electron.NET</a> will continue to improve!
Special shout out to Rob Horner and John Sedlak for his help editing this article! Thanks Rob and John!
<hr>
As always, if you liked the article let me know on <a href="https://twitter.com/jimbuckio">Twitter</a>! If you had any issues or didn't understand something, let me know that too! I truly appreciate the feedback!

Graphic showing the Blazor logo, plus sign, and Electron logo.

Building Desktop Apps with Blazor

<blockquote>
This is Part 1 of a 3 part series on the <a href="http://ASP.NET">ASP.NET</a> Core Request Pipeline. Check back here for links to the follow-up articles!
</blockquote>
<ol>
<li><a href="/asp-net-core-req-pipe-0">Preface</a></li>
<li>Part I - Receiving Requests</li>
<li>Part II - Coming Soon</li>
<li>Part III - Coming Soon</li>
</ol>
UPDATE: This post was featured in <a href="https://www.youtube.com/watch?v=hZyjKGgmWWA&amp;list=PL1rZQsJPBU2St9-Mz1Kaa7rofciyrwWVx&amp;index=16&amp;t=308">.NET Community Standup on July 23, 2019</a> (<a href="https://www.theurlist.com/aspnet-standup-2019-07-23">Community Links</a>)!
<hr>
For many developers the area between a browser request and a controller action is a land of magic and mystery. Any why shouldn't it be? In MVC/WebAPI and <a href="http://ASP.NET">ASP.NET</a> Core convention is king when it comes to routing and controllers. As long your naming scheme follows convention, you can safely expect requests to magically hit your code.
But what happens when you don't follow convention? Or when you need to support a more complex configuration that is not provided by out-of-the-box project templates? Don't be afraid, the request pipeline doesn't have to be a black box. And having a solid understanding of the request pipeline can take you from zero to hero by the end of the sprint.
In this article I break down of each type of server and detail their differences. After that I outline common scenarios and which implementation is best suited for the job.
<hr>
<h2>Server Implementations</h2>
When it comes to web apps, something must be listening on a port (typically 80 or 443) to receive the request. Listening for and maintaining connections to requests are the primary responsibilities of a web server. When it comes to <a href="http://ASP.NET">ASP.NET</a> Core, there are a few implementations and hosting models that each have their own benefits.
<h3>Standalone with Kestrel</h3>
<div class="image-set">
 <figure>
 <img src="/uploads/kestrel-standalone-1.png" alt="Diagram showing architecture of standalone kestrel."/>
 <figcaption>Standalone Kestrel<figcaption>
 </figure>
</div>
Kestrel is the light-weight, cross-platform web server built specifically for <a href="http://ASP.NET">ASP.NET</a> Core. It's <a href="https://github.com/aspnet/AspNetCore/tree/master/src/Servers/Kestrel">open source</a>, can easily <a href="https://msit.powerbi.com/view?r=eyJrIjoiYTZjMTk3YjEtMzQ3Yi00NTI5LTg5ZDItNmUyMGRlOTkwMGRlIiwidCI6IjcyZjk4OGJmLTg2ZjEtNDFhZi05MWFiLTJkN2NkMDExZGI0NyIsImMiOjV9">exceed 1M+ practical requests per second</a>, and is the default when starting a new project for <a href="http://ASP.NET">ASP.NET</a> Core 3. Kestrel will listen on the specified hosts/ports and runs right within your web app.
Once connections are made, the requests are handled directly by the request pipeline. It's a great option to use for new projects since there are no additional dependencies and, even better, it works on Windows, Mac, AND Linux! I highly recommend using Kestrel during development and for open source projects.
<h3>Out-of-Process with IIS and Kestrel</h3>
<div class="image-set">
 <figure>
 <img src="/uploads/iis-out-of-process-2.png" alt="Diagram showing architecture of out-of-process IIS with Kestrel."/>
 <figcaption>Out-of-Process IIS with Kestrel</figcaption>
 </figure>
</div>
When building enterprise server applications that run on Windows, you almost always will rely on the de facto web server: <a href="https://www.iis.net/">IIS</a>. Originally released for <a href="https://support.microsoft.com/en-us/help/224609/how-to-obtain-versions-of-internet-information-server-iis#section-2">Windows NT</a> and <a href="https://en.wikipedia.org/wiki/Internet_Information_Services#History">rewritten for Windows Server 2008</a>, it's currently on version 10 and provides stability, security, and management tools for production applications. **To say that IIS has been battle tested is a massive understatement. **And any enterprise developer/IT professional has probably relied on IIS at some point in there career.
IIS Out-of-Process hosting uses IIS as a reverse proxy that forwards requests to your <a href="http://ASP.NET">ASP.NET</a> Core app running on Kestrel (thanks to <a href="https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/aspnet-core-module">the ASP.NET Core Module</a>). The primary benefit to this setup is the ability to host and configure a mix of .NET Framework and .NET Core apps. This simplifies configuration for things like SSL, caching, and authentication since they can be shared across applications.
Other reverse proxies can also be used (<a href="https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/linux-apache">Apache for Windows/Linux</a>, and <a href="https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/linux-nginx">Nginx for Linux</a>). While they do provide support for other platforms, IIS provides dedicated support which will result in the best experience.
<h3>In-Process with IIS</h3>
<div class="image-set">
 <figure>
 <img src="/uploads/iis-in-process.png" alt="Diagram showing architecture of in-process IIS."/>
 <figcaption>In-Process IIS</figcaption>
 </figure>
</div>
Starting with <a href="http://ASP.NET">ASP.NET</a> Core 2.2 if you app targets .NET Core (not the full .NET Framework) then you can take advantage of in-process hosting. This means that the IIS worker process (<code>w3wp.exe</code>) actually loads up the CoreCLR and your <a href="http://ASP.NET">ASP.NET</a> Core app in the same process. This enables **faster time to first byte **by allowing requests to be passed directly into the pipeline!
This is improved performance does come at a cost. Only one application can be used per IIS Application Pool and there is no support for .NET Framework. But the benefit is 2x-3x improved requests per second.
<h3>HTTP.sys</h3>
<div class="image-set">
 <figure>
 <img src="/uploads/httpsys.png" alt="Diagram showing architecture of HTTP.sys."/>
 <figcaption>HTTP.sys</figcaption>
 </figure>
</div>
<a href="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/servers/httpsys">HTTP.sys</a> is a Windows-only web server focused on security and additional features (compared to Kestrel). Prior to <a href="http://ASP.NET">ASP.NET</a> Core 2.0, Kestrel was not secure enough to expose directly to the public internet. HTTP.sys allowed apps to be accessible on the public web without the need for IIS. Additionally it provides a few features not available to Kestrel, such as Windows Authentication.
<h3>Custom OWIN-based Server</h3>
<div class="image-set">
 <figure>
 <img src="/uploads/custom-owin.png" alt="Diagram showing architecture of custom OWIN server."/>
 <figcaption>Custom OWIN Server</figcaption>
 </figure>
</div>
Custom servers can be used in the off chance that a feature is not supported in Kestrel/IIS or HTTP.sys. Conforming to the Open Web Interface for .NET (OWIN), these servers implement a set of interfaces used to manage and interact with <a href="http://ASP.NET">ASP.NET</a> Core apps. <a href="https://docs.microsoft.com/en-us/aspnet/core/fundamentals/owin#using-aspnet-core-hosting-on-an-owin-based-server">You can learn about the <code>IServer</code> interface and how to implement it here.</a>
<h3>tl;dr</h3>
Server ImplementationNotesIn-process with IISMaximum Performance, but for Windows only.Kestrel (standalone)Lightweight and cross-platform.Out of process IIS with KestrelHost alongside existing .NET Framework apps.HTTP.sysAdvanced features, Windows only.Custom OWIN ServerComplete control, highest complexity.Summary of Server Implementations
<h2>Which Implementation is right for me?</h2>
The following scenarios are just a few possible cases to consider. Your specific project might have special circumstances or specific requirements from your organization.
<h3>Open Source Project</h3>
Kestrel (standalone) is probably your best bet. The two main benefits for open source projects is cross-platform support and super simple workflow (no messing with IIS Express). While cross-platform is not a requirement for open source projects, there is nothing more annoying than finding a good project that doesn't have support for your platform. Now a simple developer workflow is something that we should all strive for, but not always obtainable. Regardless using standalone Kestrel is without a doubt the best option for new open source projects.
<h3>Enterprise Project with Legacy Apps</h3>
In most enterprise scenarios, legacy applications must be considered when building new applications. Some companies/administrators have strict rules on how sites get hosted. IIS can easily host new and legacy apps together, but you have to consider 2 things.
<ol>
<li>If performance (speed and memory usage) are important, then In-Process with IIS is the way to go. By letting IIS load and execute the <a href="http://ASP.NET">ASP.NET</a> Core application, reverse proxy HTTP calls are avoided and request data is shared in memory. This results is faster response times and reduced memory consumption.</li>
<li>If sharing AppPools is important, then use Out-Of-Process with IIS. IIS will act like a reverse proxy, which allows you to share AppPools between legacy apps and new apps. Your <a href="http://ASP.NET">ASP.NET</a> Core app will have a Kestrel server running, but will be completely managed by IIS. While this does slow down the request speed, it does provided benefits around shared security, availability, etc.</li>
</ol>
<h3>Greenfield Project</h3>
For brand new projects, Kestrel (standalone) is your best place to start. Kestrel provides a lightweight server for easy development, allowing your team to spend more time focusing on building the app. If you are developing for Windows-only and using IIS, then consider deploying with IIS In-Process. In addition to an easier configuration, you will find less memory usage and faster response time.
<h3>High Performance Project</h3>
If you need to squeeze every ounce of performance out of your tech stack, then believe it or not but Kestrel (standalone) is probably your best bet. The <a href="http://ASP.NET">ASP.NET</a> team has put in a tremendous amount of effort to make Kestrel a top tier web server when it comes to requests per second. The key to keeping your server performant is through the use of custom middleware instead of the &quot;general use&quot; implementations used by most projects. Kestrel, when stripped down to simple text-based requests, can handle about 6 MILLION requests per second. With some smart authentication and body parsing optimized for your domain, you would be surprised at how fast Kestrel can fly.
<h3>Not Sure?</h3>
Without a doubt the first server to try is Kestrel (standalone). With complete security implementation (<a href="http://ASP.NET">ASP.NET</a> Core 2.0 and beyond) and a highly dedicated team pushing its performance to the max, most projects will be perfectly happy relying on Kestrel. The best part is that you can use standalone Kestrel during development and deploy with IIS In-Process or Out-of-Process with just a few configuration changes.
<h2>Conclusion</h2>
All projects, big or small, benefit when starting off on the right foot. Plan ahead and learn about the options you have available when it comes to project architecture. The most difficult projects don't always have the most complex logic; they have the least amount of high-level planning.
Keep an eye out for Part 2 of this series on the <a href="http://ASP.NET">ASP.NET</a> Core Request Pipeline. It will dive into the details of pipeline configuration and MVC middleware!
Questions? Comments? Disagreements? Hit me up on <a href="https://twitter.com/jimbuckio">Twitter</a>!

A photo of clean metallic pipes running into a building.

Demystifying the ASP.NET Core Request Pipeline: Part 1 - Receiving Requests

<blockquote>
This is Part 0 of a 3 part series on the <a href="http://ASP.NET">ASP.NET</a> Core Request Pipeline. Check back here for links to the follow-up articles!
</blockquote>
<ol>
<li>Preface</li>
<li><a href="/aspnet-core-req-pipe-1">Part I - Receiving Requests</a></li>
<li>Part II - Coming Soon</li>
<li>Part III - Coming Soon</li>
</ol>
<hr>
Every day we use products and services that we could consider a &quot;black box&quot;. Look at cell phones for example. Most people (myself included) have absolutely no grasp of exactly how two people can be connected when thousands of miles apart. <a href="https://www.hanselman.com/blog/ImJustACavemanTheHanselmanCorollaryToTheClarkeWheelerLaws.aspx">Scott Hanselman eloquently phrases it</a> as &quot;each new layer of abstraction becomes indistinguishable from magic&quot;. Life would be pretty rough if we could only use things we had a complete technical understanding of.
But there are times when learning about that &quot;magic&quot; can provide a ton of value. It could be as simple as having a better understand when problems hit, which could save you time and frustration. Or it could help steer your logic away from potentially problematic scenarios, improving performance and avoiding security nightmares.
When working with <a href="http://ASP.NET">ASP.NET</a> it's very easy to get started and just breeze over the architecture details. In this series I am going to dive into the <a href="http://ASP.NET">ASP.NET</a> Core Request Pipeline from start to finish. I will cover everything from hosting models and pipeline fundamentals to building your own custom middleware. While I will focus on <a href="http://ASP.NET">ASP.NET</a> Core 2.2 and beyond, the same general tips should also apply to any OWIN based app, even in <a href="http://ASP.NET">ASP.NET</a> MVC5.
I hope you enjoy the series and get to learn something new! If you have any comments or questions hit me on <a href="https://twitter.com/jimbuckio">Twitter</a>! Follow me to get notified about the next part!

A photo of stainless steel brewery tanks and pipes.

Demystifying the ASP.NET Core Request Pipeline: Preface

One of the most beautiful aspects to software development is having the opportunity to contribute to Open Source Software. For a long time I wanted to contribute to a library or framework that I used every day.
The only problem was that every time I had the motivation to try, I easily got intimidated by what seemed like a high-pressure situation (spoiler alert: it doesn't have to be). By starting small and staying focused, making your first PR for a widely used project can be both fun and beneficial for the community.
<blockquote class="twitter-tweet" data-theme="light">Talked to <a href="https://twitter.com/jimbuckio?ref_src=twsrc%5Etfw">@jimbuckio</a> Monday night about how to get started contributing to <a href="https://twitter.com/dotnet?ref_src=twsrc%5Etfw">@dotnet</a> open source by contributing small fixes to <a href="https://twitter.com/docsmsft?ref_src=twsrc%5Etfw">@docsmsft</a>. He stopped by the .NET Open Source booth to tell me his first pull request had just been merged. <a href="https://twitter.com/hashtag/MSBuild?src=hash&amp;ref_src=twsrc%5Etfw">#MSBuild</a> <a href="https://t.co/yEcuNODdUd">pic.twitter.com/yEcuNODdUd</a>&mdash; Jon Galloway (@jongalloway) <a href="https://twitter.com/jongalloway/status/1126203620511248384?ref_src=twsrc%5Etfw">May 8, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
So after chatting with Jon Galloway of the .NET Foundation, I sat down and fixed an issue that I had discovered in the <a href="http://ASP.NET">ASP.NET</a> Core documentation. I created my pull request and the next morning I woke up to it already merged in! It's not always that easy, but follow these simple steps and you'll be a well-respected contributor in no time.
<h2>Step 1: Find an Issue</h2>
Although it may seem obvious, the most important step is finding a issue. And not just any issue, a good issue. What makes an issue good? Just find something that seems wrong and ask yourself these questions:
<ol>
<li>Is there a clear and obvious reason for the change? If a change fixes a breaking bug, then it is a fix worth pursuing. If there is indisputable evidence that a section of documentation is wrong, then a fix is worth pursuing. The key is making sure that the motivation for the change is shared among users and maintainers alike. If you want to make a change to the API because you think it will be better, then maybe you should start by creating an issue to first get some input from the maintainers before spending more time on it.</li>
<li>**Can you fix it in a clean and concise way? **To some people refactoring/rewriting can be a cathartic exercise. But just because you feel better after a rewrite doesn't mean it was a good idea. Keeping the changes minimal and specific will help in two ways. The first is that it will keep your changes easy to read, which will help speed up the review process. The second is by minimizing the chance for new bugs or issues. No amount of cleanup is worth it if new bugs are introduced.</li>
<li>**Is there already a fix out there? **Before diving too deep into a solution, make sure that someone else didn't already take a shot at it. If they did, double check the status. It might be pending, abandoned, or simply obsolete at this point. Open source moves fast, so investigate first to avoid wasting time.</li>
</ol>
<h2>Step 2: Fork &amp; Fix</h2>
Believe it or not, the easiest part of your first open source contribution should be forking and fixing. GitHub makes forking super easy, just navigate to the repository and click the &quot;Fork&quot; button!
<div class="image-set bordered">
 <figure>
 <img src="/uploads/github-repo-interactions.png" alt="GitHub's Repository Interaction Options showing Watch, Star, and Fork options." />
 <figcaption>GitHub's Repository Interaction Options</figcaption>
 </figure>
</div>
Once you have your own fork of the repo you can clone it to your development environment for editing. You technically have the option to edit it online from GitHub, but as I cover in the next step it's best to clone the repo so you can ensure the changes pass tests and coding standards.
Finally, when applying fixes try to limit changes to those required for the fix. Small changes means fast reviews, which probably increases the chances of getting it merged. If you feel like the changes are beginning to snowball, reach out to the project maintainers for some guidance.
<h2>Step 3: Test &amp; Pull Request</h2>
The world would be a better place if everyone tested their code. And to me, it's absolutely CRAZY that people make changes and commit it without verifying that it works! Continuous Integration has been a blessing by allowing teams to move fast while maintaining stable branches. But that doesn't mean we should rely on CI alone. It's crucial to test your changes as rigorously as possible before making your PR. It helps to ensure that the changes you made were correct, and helps to avoid wasting the valuable time of a maintainer.
Once you've successfully tested your changes your good to <a href="https://help.github.com/en/articles/creating-a-pull-request">create your PR</a>! Be sure to provide a clear and concise title so maintainers can easily triage the PR. In the description be sure to include details about the motivation for the change, how the issue was solved, and any other supporting details that would help a maintainer review the changes.
When creating a PR, sometimes repositories will have a Contributor License Agreement (CLA). This is just an agreement that means the community can use your changes. It typically takes less than 5 minutes and only has to be done once, so don't be intimidated by it.
<h2>Step 4: Be Patient, Listen, and Stick with it</h2>
With some luck and hard work, your PR will get merged in once the maintainers take a look. They could also provide some requests for more changes or simply ask some questions.
<blockquote>
An important part of Open Source Software is being able to work together and receive criticism. Respect is paramount in a community.
</blockquote>
Take the time to understand their feedback and work with them to arrive at the best outcome. If it results in a merged PR, then that's great! But if they are still not happy with the changes, don't let that get you down. Stick with it and use it as an opportunity to learn and grow.
Finally, if they close it (or worse, never respond to it) then do not worry! Anyone who contributes to Open Source Software will get a closed PR at some point in their career. My recommendation is to start back at Step 1 and find a good issue to fix. GitHub projects usually have issues with a tag like <code>good first issue</code> or <code>help wanted</code> that are great for new contributors.
<h2>Conclusion</h2>
Contributing to Open Source Software is an exercise that all developers should try at some point. There are so many fantastic tools and frameworks out there that we use for free every day. But they are not free for the maintainers and their families. Give back to those who work so hard and help make your community a better place.
If you have any questions please <a href="https://twitter.com/jimbuckio">hit me up on twitter</a>! I'm happy to help anyone with their first (or 100th) PR!

A photo of the asphalt with "You Got This" written in chalk.

Contributing to OSS: Getting Started

I'm at Build in Seattle and will be live-blogging all day! This blog post will automagically update every minute or so. I'll be sharing the latest news on Azure, <a href="http://ASP.NET">ASP.NET</a>, and TypeScript! After the event I will share my overall thoughts and dive deeper on select topics. And follow me on <a href="https://twitter.com/jimbuckio">Twitter</a> and <a href="https://www.instagram.com/jimbuckio/">Instagram</a> to stay in touch!
<h2>Keynote</h2>
<h3>Imagine Cup Finals</h3>
3 teams of students have each created some very impressive products.
<ol>
<li>Winner: The third team created a brand new technique for measuring blood glucose levels using images of the retina from a smart phone. (zero-impact, cheap, and easily accessible; this is a big one).</li>
<li>Runner Up: The first team demonstrated an air filtration mask for pollution-ridden environments. The coolest part is that they have custom plates for kids.</li>
<li>3rd Place: The second team created a mobile app that uses Azure Computer Vision and other ML/AI services to locate and guide you to things around you (perfect for vision-impaired).</li>
</ol>
<h3>KeyNote</h3>
Satya Nadella:
<ul>
<li>
The future is embedding compute in the edge, building a new world.
</li>
<li>
As developers we have a call to trust, honest, and ethics that must be our responsibility.
</li>
<li>
Announcing a new open source project for securing election software using homomorphic encryption.
</li>
<li>
4 Areas of the conference
</li>
<li>
Azure and Edge Computing
</li>
<li>
Dynamics 365 &amp; Power Platform
</li>
<li>
Business Automation???
</li>
<li>
Gaming
</li>
<li>
Meet the needs of developers and fit every service/platform.
</li>
<li>
Bring computing to the edge and hybrid.
</li>
<li>
Focus on how Azure DevOps, tooling, etc. works between cloud and edge.
</li>
<li>
Examples of Walgreens and AB InBev (among others) using Azure and IoT to improve customer experience.
</li>
<li>
Deep dive into the latest from Starbucks:
</li>
<li>
DeepBrew. Smart menu recommendations using IoT ordering devices (takes into account region/cultural preferences, seasonal favorites, and purchase history).
</li>
<li>
An additional system for StarBucks allows them to monitor and track all brewing operations at their flagship Seattle location.
</li>
<li>
Using Azure blockchain to provide transparent details on where your coffee beans were grown, traded, etc.
</li>
<li>
Azure Cognitive Services: Empowering companies, developers, end users.
</li>
<li>
Azure Speech Services, has the ability to transcibe text AND learn local jargon, even within your O365 organization. Learns your terms, abbreviations, names.
</li>
<li>
Uses mutliple microphones to create a cloud-based microphone array. Can even recognize your voice footprint to identify who is speaking.
</li>
<li>
Bot Framework:
</li>
<li>
3,000 new apps created each week
</li>
<li>
Create a conversational bot from the contents of a PDF!
</li>
<li>
Empower every business to create thier conversational canvas.
</li>
<li>
JET built a customer service agent using Bot Framework.
</li>
<li>
Coka-Cola using Bots internally across the organization.
</li>
<li>
HoloLens 2
</li>
<li>
The quintessential edge of Azure.
</li>
<li>
Spatial Anchor
</li>
<li>
Improved Augmented Reality -&gt; Mixed Reality.
</li>
<li>
Makes VR more physical.
</li>
<li>
Autonomous Systems
</li>
<li>
Machine learning &amp; self-learning
</li>
<li>
Dynamics 365 &amp; Power Platform
</li>
<li>
Embedding Power Platform into your apps and services integrates with Dynamics 365
</li>
<li>
Open Data Initiative
</li>
<li>
Working with Adobe and SAP.
</li>
<li>
Unilever utilizing for sustainability, used to market and educate the benfits of sustainability.
</li>
<li>
Microsoft 365:
</li>
<li>
Provides productivity in life and drives business interaction
</li>
<li>
Putting people at the center and thinking about how they access thier devices (people first, not device first).
</li>
<li>
Runs on Microsoft Graph, Teams, Edge, etc.
</li>
<li>
Enable Graph integration on internal data, allows for massive improvements to search, analytics, and predictions.
</li>
<li>
Cortana is available in Teams
</li>
<li>
All Bot Framework bots can be used across devices (Siri, Alexa, etc).
</li>
<li>
We need an open-assistant (one wake word, one agent, shared data &amp; services).
</li>
<li>
Multi-turn (back &amp; forth exchanges), multi-domain (calendar, emails, contacts, directions, business info), and multi-agent.
</li>
<li>
Video demonstrating how a converstaional AI with Cortana can empower you daily routine.
</li>
<li>
Windows and Office Developer Ecosystem
</li>
<li>
Using inking to intelligently teach math
</li>
<li>
Bloomberg using Excel to
</li>
<li>
Edge Browser
</li>
<li>
Now built on Chromium.
</li>
<li>
Bringing ARM64 support.
</li>
<li>
Contributing back so that all browsers can improve.
</li>
<li>
Will be cross-platform: Win10, Win7, Mac, iOS, Android
</li>
<li>
Privacy &amp; Security, providing transparency and choice.
</li>
<li>
New Announcements (Divya):
</li>
<li>
Provide seamless enterprise experience:
</li>
<li>
IT Customizable home page, show contextual &quot;recents&quot; (docs, appointments, search results)
</li>
<li>
Edge will support IE with &quot;IE Mode&quot;, no need to switch browsers.
</li>
<li>
Provide privacy/security.
</li>
<li>
Create simple tools to see who can see your data
</li>
<li>
Tracking Prevention allows for great control, even blocking malicious trackers.
</li>
<li>
Increase productivity
</li>
<li>
Collections: group links and content, easily share, and integrate into Office apps, auto-records citations, auto-categorize into Excel.
</li>
<li>
Fluid Framework (Mike &amp; Chika)
</li>
<li>
Hyper fast co-authoring &amp; bots that work with you.
</li>
<li>
Auto translate as you type, using bots as
</li>
<li>
Bots can provide proofing, security audits, etc.
</li>
<li>
Fluid Components
</li>
<li>
Allows data to be manipulated across apps and devices (table data in a Word doc and Teams page).
</li>
<li>
Teams (Satya)
</li>
<li>
Microsoft 365 is not just for &quot;knowledge workers&quot;, but also &quot;first-line&quot; workers.
</li>
<li>
Nascar trainging team, retail specialists, hospital workers.
</li>
<li>
Announcements (Raanah):
</li>
<li>
Use mobile devices to capture data and events
</li>
<li>
Shifts Module allows for servicen techs to work better together.
</li>
<li>
Video Conferences
</li>
<li>
Dynamic backgrounds (hide your house)
</li>
<li>
Whiteboard centering and transparent people (no more blocking the whiteboard/sreen).
</li>
<li>
HoloLens + MS Graph + Spatial
</li>
<li>
Uses hand &amp; finger tracking to grab and throw files, images, data.
</li>
<li>
Connect in the same room even across the world.
</li>
<li>
Can join without HoloLens, using mobile phone for Mixed Reality or laptop for virtual view.
</li>
<li>
Gaming in Microsoft
</li>
<li>
donkey.bas is on GitHub
</li>
<li>
Xbox Live, GamePass, Mixer
</li>
<li>
Azure for game dev (Rare, Ubisoft)
</li>
<li>
Xbox Live
</li>
<li>
63M users
</li>
<li>
Now available on iOS and Android, GameLoft starting the integration
</li>
<li>
PlayFab
</li>
<li>
LiveOps: Measure, manipulate, and modify game data to improve gamer expereince.
</li>
<li>
Microsoft Game Stack
</li>
<li>
Azure, AI, MS 365, and more, all for gaming.
</li>
<li>
Mystery Minecraft teaser - tune in May 17th on <a href="http://minecraft.net">minecraft.net</a>
</li>
<li>
The &quot;commercial&quot; contained a mixed reality effect allowing you to view your Minecraft creations in the real world using a smartphone or tablet.
</li>
</ul>
Over all it was quite the keynote, as you can see from the flurry of notes that I took. It's quite clear that the focus this year is using AI to improve business and connecting users through Teams and remote services. Look for more articles on <a href="http://ASP.NET">ASP.NET</a> and the latest for Azure.

A photo of the entrance of the Washington State Convention Center decorated for Microsoft Build 2019.

Build 2019 - Keynote

Recently I've been working a lot with multiple multi-app servers and their SSL certificates. Once you get more than two or three environments up and running it can get a little tricky finding and wrangling certificates from each instance. Thankfully I've found a few super tips that have been a big time saver when it comes to solving issues with certs when your working in less than ideal system setups.
<h3>Tip 1: Find and Destroy</h3>
I find there are certain times when the dev certs on my PC are just out of hand. The first step to cleaning them up is by removing the old ones. The <a href="https://docs.microsoft.com/en-us/dotnet/framework/wcf/feature-details/how-to-view-certificates-with-the-mmc-snap-in">certificates snap-in</a> for the Microsoft Management Console is a decent tool if you want to look at a specific cert. Simply select the folder on the left and you can easily find the certs you need. But when you're looking for one or more possible certs, then try the following Powershell snippet:
<pre class="hljs"><code>ls Cert:\ -Recurse | where { $_.Issuer -like &quot;*Jim Buck*&quot; }
</code></pre>
This snippet will recursively search all installed certificates but only display those that match the criteria (in this case the <code>Issuer</code> must contain <code>Jim Buck</code>. You can filter on any of the following fields:
<ol>
<li><code>Subject</code> - text (might be generic or the same as issuer)</li>
<li><code>Issuer</code> - text (typically quite reliable to filter on)</li>
<li><code>Thumbprint</code> - hash (unique per certificate)</li>
<li><code>FriendlyName</code> - string (sometimes empty)</li>
<li><code>NotBefore</code> - Datetime</li>
<li><code>NotAfter</code> - Datetime</li>
<li><code>Extensions</code> - List of <code>Oid</code> objects (they have <code>FriendlyName</code> and <code>Value</code> properties).</li>
</ol>
Early in the development process you might be adding quite a few certs to your store. Run the same command but pipe it to the <code>rm</code> command and you can easily remove all of the pesky old certificates:
<pre class="hljs"><code>ls Cert:\ -Recurse | where { $_.Issuer -like &quot;*Jim Buck*&quot; } | rm
</code></pre>
I don't recommend clearing out certs too often though. Ideally you only have to do it before installing the &quot;good&quot; certs. Once you have a nice clean cert store adding new certs that are known to be good should be just fine to have installed.
<h3>Tip 2: Trust the CA Root certificate</h3>
Our application relies on an in-house data service. During the install of this service, it generates a CA Root certificate and an end-user certificate for the server's <a href="https://en.wikipedia.org/wiki/Fully_qualified_domain_name">FQDN</a> (signed by the generated CA Root). We can't modify the install logic of the service, so we have to make due with the certs it produces. The best approach is to simply download the CA Root cert from each instance and install it in the Trusted Root of our Local Machine.
<div class="image-set">
 <figure>
 <img src="/uploads/cert-install-guide-01.png" alt="Screenshot of the Select Store Location page of the Certificate Import Wizard" />
 <figcaption>Selecting "Local Machine" allows any users on the machine to benefit from the cert.</figcaption>
 </figure>
 <figure>
 <img src="/uploads/cert-install-guide-02.png" alt="Screenshot of the Select Certificate Store page of the Certificate Import Wizard" />
 <figcaption>Trusted Root means any certs signed by this cert should be trusted, no warning messages required.</figcaption>
 </figure>
</div>
I typically select &quot;Local Machine&quot; (just in case) and manually select &quot;Trusted Root Certification Authorities&quot;.
Don't be fooled, certs of the same name (but different thumbprint) can be installed side-by-side. Just remember to restart your browser/client apps so they pick up the new certificates.
<h3>Tip 3:  Use a shared CA Root certificate</h3>
By far the best approach is to simply make your certificate generation use a shared CA Root. This would allow a project or even a whole department to use one common root cert that signs all server-specific development/test certs. No more downloading of certs to trust, no more hacks to ignore cert errors. No more rummaging through each environment trying to update all references of which cert to use. Just one shared cert that keeps developers, testers, managers, and product owners safe and secure.
I am currently finalizing a script to help create (dev-only) CA Root and SSL certs. Once I can test it a bit more and get the usage as simple as possible I will write a special article all about it.

SSL Certificates in Development

Just like your first day in a new school, I figured the best place to start is with a formal introduction! My name is Jim Buck and I am Project Manager for <a href="https://www.rdacorp.com/">RDA Corporation</a>. This blog is my new platform to share things that made my life better, and I hope it can help you too!
As for a little bit of background, I began taking formal programming classes in high school in Central Pennsylvania. I received my B.S. in Computer Science from Towson University with a focus in Software Engineering. Six days after graduating I started my first job at RDA as a Software Developer and I've been there ever since! Most of my experience revolves around <a href="http://ASP.NET">ASP.NET</a> and client-side development, but I've also built many live enterprise applications using WPF and Xamarin. I currently live in Mechanicsburg, PA with my wonderful wife and two sons!
When I'm not crushing sprints and surfing kanban boards I like to work on open source software. Usually built with Typescript and NodeJS, my projects are all hosted on <a href="https://github.com/JimmyBoh">GitHub</a> and free to use. I believe that open source software is glimmering hope that there is good in the world and it is something that should be celebrated.
I wouldn't be where I am today without the help of my family and all the colleagues that have taught me something along the way. I truly hope you find my ramblings helpful and fun to read, and I look forward to even more learning with my readers.

Introductions

Web technologies are evolving at an exciting pace these days. HTML5 and CSS3 provide the tools to make the web fluid and engaging, allowing developers to create rich web apps with ease. However, despite the advancements on client-side development, server-side development has evolved at a much slower pace. A developer can create their web app, but velocity slows when server interaction requires tedious refactoring to work with new client technologies.
To bridge that gap between client and server development, a lightweight platform called Node.js was created in 2009. Believe it or not, Node.js is written in javascript and runs on V8, the javascript engine for Google’s Chrome web browser. Although it may seem ridiculous to use a javascript-based server platform, Node.js was designed for event-driven development. Thanks to the power of V8 and the flexibility of javascript’s event framework, Node.js is a lightweight, non-blocking platform ideal for creating network applications.
<h4>Why Node.js?</h4>
Just as javascript is flexible and built for the web, Node.js provides developers with the same freedom on the server-side that they enjoy on the client-side. By programming in javascript on the server-side, there is no need to convert or alter data for the web standards. In the same regard, there is also no need to change coding styles when switching from client to server development, which results in faster development cycles.
Node.js also provides a plugin framework: the Node Packaged Modules (NPM). NPM provides developers with a quick and easy method for downloading and installing modules for their applications. From MVC frameworks to multi-processor clusters, thousands of modules exist to solve any problem you may face.
Finally, Node.js provides the powerful benefits that come with simple scalability. Thanks to the event-driven nature of Javascript, the lightweight overhead of V8 and the existence of powerful modules, Node.js can very quickly be distributed among processes or servers. Whether creating a load-balancing cluster or separating your apps between servers, Node.js allows a system to be distributed with minimal effort by the developers.
Node.js is a powerful platform for network applications, from web servers to web services. While it is still a young platform in web development, many corporations such as eBay, LinkedIn, and Wal-Mart have already used it in production systems. In fact, Windows Azure cloud platform began supporting Node.js in  June 2012, making it easier than ever to take advantage of Node.js.
<h4>Why Node.js on Azure?</h4>
Windows Azure supports a number of ways to get started with Node.js on the cloud. The quickest and easiest is to use Node.js to create an Azure website. In less than two minutes, I was able to create a new website on Azure and publish the default site for Express, the premier MVC framework for Node.js. Azure works seamlessly with Visual Studio and WebMatrix 2, allowing you to easily develop and publish your Azure projects. Each development tool provides site templates, Node.js intellisense, and access to NPM. Projects can be published using TFS or Git, allowing for full source control and collaboration.
Another approach to using Node.js on Azure is as a Cloud Service, which functions similar to an Azure website but provides greater flexibility and increased scalability. Cloud services are easily set up via the Azure PowerShell that installs with the Azure SDK. From a personal CDN to a RESTful API server, Cloud Services allow you to enhance your web and enterprise applications.
Windows Azure support of Node.js makes it possible for developers to create powerful back-end servers for web and mobile applications. The scalability of Azure and Node.js make for a perfect duo, allowing developers to easily scale applications without any changes to the code. That ease of scalability combined with the broad tools and resources provided by Microsoft makes Node.js an extremely attractive approach to building any network application.