Taking Command of ASP.NET 5

I had a great time recording a video on Channel 9 that walked through getting started with ASP.NET 5 just using a command line and text editor of choice (I used notepad and Visual Studio Code).  This post is based on that video, breaking it down into steps you can follow.  Although the content shown is based on Windows 10 using a command prompt, you can follow along with Linux or Mac as long as you (likely) know your command line equivalent.  I only use notepad in this post, but if you installed Visual Studio Code (optional below), just replace all occurrences of notepad in the command line with code instead.

Please make sure you have the following installed:

At the command prompt create a ‘solution’ level folder.  I will name mine demo.

C:\md demo

Navigate into the demo folder.

C:\cd demo

Confirm the latest runtime is installed.

C:\demo\dnvm upgrade

You should have a visual confirmation of the latest version. It will indicate runtimes added in your user profile path, though if they were previously installed, nothing was duplicated. View your list of installed runtimes.

C:\demo\dnvm list

Depending on your environment, you will see one or more runtimes installed. An asterisk preceding a line indicated the default runtime. Create a file named nuget.config.


Open the new file in text editor of choice. In this example, I will open with notepad.

C:\demo\notepad nuget.config

In text editor, type the following markup in the nuget.config file and save it:

<?xml version="1.0" encoding="utf-8"?>
    <clear />
    <add key="" value="" />

The content of the above nuget.config provides context for where nuget packages can be found for any projects (subfolders) in this solution (current directory). Make sure you have saved the file. Back at the command line, create a subdirectory of demo named src.

C:\demo\md src

Navigate into the src folder.

C:\demo\cd src

Create a file named project.json


Open project.json in a text editor

C:\demo\src\notepad project.json

In text editor, type the following JSON notation in the project.json file and save it:

  "webroot": "wwwroot",
  "version": "1.0.0-*",

  "dependencies": {
    "Microsoft.AspNet.Server.Kestrel": "1.0.0-beta8",
    "Microsoft.AspNet.Diagnostics": "1.0.0-beta8"

  "commands": {
    "web": "Microsoft.AspNet.Server.Kestrel"

  "frameworks": {
    "dnx451" :  { },
    "dnxcore50" :  { }

  "exclude": [

The content of the above project.json provides project-level information such as where static file content will be located (wwwroot folder) and thus excluded from any compilation. It also indicates what dependencies are required, as well as versioning and supported commands (web).  Make sure you have saved the file.  Back at the command line, run the .NET utility (dnu) to restore packages indicated in the project.json file.

C:\demo\src\dnu restore

After running the above command, you should see information indicating packages are being restored and from what nuget source (it should be the one you defined in the nuget.config file). Back at the command line, create a new file named Startup.cs.


Open Startup.cs in text editor.

C:\demo\src\notepad Startup.cs

In text editor, type the following code in the Startup.cs file and save it:

using Microsoft.AspNet.Builder;

namespace CommandDemo
    public class Startup
        public void Configure(IApplicationBuilder app)

The above code file will display a simple welcome page (generated via Microsoft.AspNet.Diagnostics, a dependency in project.json) when web site is accessed. Make sure you saved the file.  Back at the command line, use the .NET execution tool (dnx) to start the web server via the web command (defined in project.json).

C:\demo\src\dnx web

After running the above command, you will receive information about the web server starting, how to access the server (likely http://localhost:5000), and how to stop the server. Open a web browser and navigate to the URL specified in the console window. You should see something similar to this:


If you see something like the above content, congrats!  You just made an ASP.NET 5 web site completely from scratch using nothing but the command line and a simple text editor.  If you did not see the content above, be sure to check for any spelling/syntax errors in all of the files.  Leave a comment if you have any questions or feedback.

    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).

From Nothing to Empty with ASP.NET 5

Edge of the Web

Learn how to build an ASP.NET 5 site without using Visual Studio 2015. Starting with nothing but the command line and a decent text editor, content created is fairly equal to the Empty starter template in Visual Studio 2015.

Tools mentioned in video are below.

    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).

CSS in the Modern World

CSS3 & StylingThe W3C recently announced a Cascading Style Sheets (CSS) snapshot – a document that “collects together into one definition all the specs that together form the current state of Cascading Style Sheets (CSS) as of 2015. The primary audience is CSS implementers, not CSS authors, as this definition includes modules by specification stability, not Web browser adoption rate.”  This motivated me to consider the relevance of CSS in today’s modern web developer community, and how best to implement today.

Because so much has changed over the years, I thought it would be appropriate to do a developer based ‘snapshot’ of where CSS is now, and how to embrace the future.  My personal experience was not enough to satisfy an answer, so I did much research and interviewed industry experts on their point of view.  With all the data I acquired, I knew I had enough findings to support writing a book!  I decided writing series of online articles on CSS would be much quicker to market, so I am proud to introduce this first post of the Mastering CSS Series

Is CSS relevant today?

For many web developers, the notion of questioning the relevance of CSS may seem odd.  However new trends in web development have put in question the use of CSS.  I strongly consider reading the article by Louis Lazaris, who presents the case that CSS is alive and well.  Although most of his article provides insight into why CSS is still quite alive, he also mentioned the popularity of React, which uses inline styling via JavaScript.  He also references an article regarding the debate around “do we even need CSS anymore?” which does a good job explaining some of the pain points developers have faced when implementing CSS.  I am referencing these articles because they provide context for the challenges CSS developers face, and why some have considered other alternatives.  So does that mean CSS is trending down?

As the opening words of this article clearly show, there is momentum in the field of CSS.  The major browsers out there are still working hard to implement CSS features, and the passionate developer community is working hard to continue making great websites with CSS.  Think of the innumerable blogging sties using WordPress which of course uses CSS to complement theming.  With a strong foundation and active community, CSS is very relevant today.

What about the valid arguments against CSS?  While I will not be addressing them here, I am happy to see the ‘uproar’ and some turning toward alternatives.  Why?  Because it is healthy for the community to challenge how things are done so that there is opportunity for improvement.  It is my humble opinion that the CSS of the future will be molded by the very complaints against it today.

Simple CSS truths

In our modern world, I find it is good to pause and question why we are doing what we do.  In the spirit of questioning my personal continued use of CSS, I wanted to come up with evidence of why I should still care to do so.  Below is a list of statements I concluded (with the help of others) that add weight to why CSS continues to be my dominate choice for styling with web technologies:

  • CSS allows for separation of concerns.  CSS is a complementary language to HTML, enabling style definitions to be maintained separately from the markup.  Cleaner markup is easier to read and maintain, and is typically easier to crawl by search.
  • CSS is fast.  It is fast in many ways.  Faster to to make style changes, faster for HTML pages to load that aren’t riddled with duplicate inline styles, and typically faster to process than JavaScript in cases like transitions and animations.
  • CSS is responsive.  CSS enables the best viewing of content based on viewing dimensions or how it should be rendered if printed, to name just a couple of examples.
  • CSS has a captive audience.  There is no shortage of books, videos, articles, and websites centering on CSS.  And there is a growing list of libraries/tools/frameworks dedicated to make CSS implementation easier and more efficient.
  • CSS is everywhere.  Modern browsers embrace CSS, and a list of features supported by each is maintained at sites such as (see comment below). CSS is also used to style mobile apps found across multiple platforms when packaged using services like ManifoldJS or Cordova.

Regarding the status of CSS across browsers, a more accurate gauge for determining what features are currently supported or in development can be obtained by consulting directly with each specific vendor.  For example, check out the platform status section at for the CSS roadmap regarding Microsoft Edge.image

Using CSS today

There are multiple ways to implement CSS today.  There is no single method that is perfect for all scenarios, since different projects will have varying needs and constraints.  Questions that would contribute toward determining an approach include:  What features of CSS does the project require?  What browsers/platforms does my project need to support?  How many developers will be contributing to project, and what are their skill levels?  Are the fastest response times a high priority?

After considering the questions above, it is now time to look at what approaches are out there.  The combination of possibilities is high, so I will break it down to these two general terms:

  • Manual implementation and maintenance of CSS.  Simply put, the developer is responsible for all aspects of CSS.
  • CSS with the help of extensions/frameworks.  Developer depends on an extension or framework to help write efficient CSS and/or to publish a minified file.  The types of extensions/frameworks are varied, and many of them have dependencies on one or more of the others.

While the second approach is clearly trending in adoption, it doesn’t mean it is always the answer.  For example, a small intranet site with a predictable audience in terms of browsers/devices might appear over-engineered to implement multiple CSS frameworks – especially if the site had a small number of pages.  Would minifying files be critical in such a scenario?  Would it take more time for developers to set up the frameworks and learn them than to just write the site?  A manual implementation of a single CSS page may be all that is needed.

The reality is many sites will be a lesser or stronger degree of the second approach.  For example, a developer savvy with CSS may have excellent skills but relies on tooling for minifying files.  Another example is using a full framework like Bootstrap, and purchasing themes to quickly get a site up and running.  Another example may be the use of W3.CSS for simple responsive styling.  To  the degree any dependency will help (not hurt) the overall project, it should be strongly considered for use.


CSS has a history, an active presence, and a continued future in web development.  While there are challenges to implementing CSS, there are also many reasons why it continued to be the reigning technology for styling the web.  This article focused on the role of CSS in our modern world.  Upcoming articles in the Mastering CSS Series will cover best practices, top tips, and a deeper look into extensions and frameworks!

    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).

Why Tag Helpers in ASP.NET 5?

As ASP.NET 5 gets closer and closer to an official release date (in beta 7 at the time this post was written), the ASP.NET community is getting more curious (skeptical maybe?) about what is next.  While this is not a “Why ASP.NET 5?” post, it is in the spirit of providing evidence toward that objective – one way or another.  I find getting to know a specific feature that is new to a framework usually exposes underlying improvements to the overall story.  With that said, this is the first post in a series that will dive into tag helpers in ASP.NET 5.

First, I want to define what a tag helper is.  A tag helper is server-side code that allows for the customization of HTML markup (from the developers perspective) and manipulation of output rendered to the browser.  So, when an element is recognized in server-side processing as a tag helper, it is executed to generate HTML that will either enhance or even completely replace the original tag helper markup.   

For those who have been developing with ASP.NET MVC for awhile, tag helpers will supersede HTML helpers.  Many blog posts and articles I have read on the topic of tag helpers typically go into a detailed comparison of the advantages of the new improved syntax over HTML helpers.  While such a comparison is helpful to existing ASP.NET MVC developers, it could potentially confuse a new developer to ASP.NET as to the tag helper’s purpose or value.  So while I will offer a brief comparison a little later in this post, my angle will strive to be on the features as autonomously to HTML helpers as possible.

Now back to the main question at hand – why tag helpers in ASP.NET 5?  To put it simply, the purpose of a tag helper is ultimately bound to the pursuit of making code and markup easier to read and manage.

Let’s look at one example how.  This is the brief comparison I referenced earlier regarding HTML helpers.  In the code below, HTML helpers are defined to create an HTML form for submitting registration information:

For anyone brand new to ASP.NET, but strong in web development, the above code could look very confusing.  Questions might impede understanding like: What does that do?  Does it generate HTML?  How can I control it? …  I will not be answering those questions, since my focus is not to explain the HTML helper.  So let’s look at the same example, but with the syntax using tag helpers:

Consider how a polished web developer new to ASP.NET would read the markup above.  There would be no confusion over what the <form> or <div> tags were.  Instead, it would be apparent that some attributes in the elements are unique to ASP.NET, such as asp-controller.  With a little guess work, it could be inferred that a <form> tag will render to the browser with information on how and what to submit to.  It could also be guessed that the <div> tag is a placeholder for validation information.  Although the exact markup will not be the same as the tag helper, it certainly doesn’t look as foreign as HTML helpers.

How can you get started with tag helpers?  If you are using the default template for ASP.NET 5 with sample content in it, you are already using them!  The registration snippet referenced earlier is from that project.  However, if you start with an empty project, you will need to add support for tag helpers.  First, make sure you have referenced the package in the project.json file as seen here:

Next, to use the existing tag helpers, add the following to a view that uses it or at a global level such as in the _ViewImports.cshtml file:

Now you are ready to use the tag helpers provided with ASP.NET 5.  In an upcoming post, I will demonstrate how and why to develop your own custom tag helper!

    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).

CSharp 6 in ASP.NET 5

Many of the new features of C# 6 aim to reduce the amount of code needed for common tasks.  ASP.NET 5 provides a lean, simplified approach to server-side coding for web sites and APIs. So working with ASP.NET 5 and C# 6 should prove the statement “less is more” to be true!

To showcase the new language features of C# 6, I want to do a simple comparison of how ‘it use to be done’ with ‘how it can be done now’.  To start, consider the following class that could be found in the Models folder in an ASP.NET MVC project:

With the new features of C# 6, you can accomplish the same with much less code, as seen here:

The above class is nearly half the lines of the previous definition, yet accomplishes the same exact objective.  Let’s look at how this was accomplished.

Both classes declared three properties, FirstName, LastName, and FullName.  The first and last name properties are read/write and have a business rule of being initialized to a default value, while the remaining property is read-only.  In the ‘before’ approach, this is how the properties were defined:

Now this can be greatly simplified with new features such as auto property initializers and read-only properties with expression bodies as seen here:

After the FullName you will notice the => syntax which indicates the property will contain an expression body.  The expression in this example is a string concatenation of the first name and last name, which is also simplified with the use of string interpolation.  The $”{s1} {s2}” syntax is much easier to read and manage than the String.Format method approach.

Methods can also contain expression bodies, as seen in the GetLastNameFirst method defined here:

Another feature that can help reduce code a little is the use of using static syntax. Consider the final method of the class:

In the code above, instead of typing String.Concat, I could just type Concat. This is possible because of the using static System.String statement.  This allows calls on all static members of the class without typing the class name first.  Depending on how this gets used, this will either simplify or complicate how your code reads, so use with discretion!

The following code is a controller that creates an instance of both classes in order to test the data values:

Compare line 8 with line 12. Notice the nameof keyword? It provides the simple service of returning the name of the variable it references as a string. Very handy for logging and testing!

If you would like to experiment with the language features, check out the interactive C# 6 demo which contains code very similar to what was shown in this post.  If you would like to examine the code in ASP.NET 5, you can view or download it at

    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).

Building Windows Apps with JavaScript Is Even Easier

Building Windows applications using JavaScript on Windows 10 is opening up new opportunities for developers. We cover how you can leverage your current web workflow for publishing code on the server while still having a single application published in the Windows store. This session covers the investments we’ve made for hosted content on the web including updates to the WebView control.
    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).

C# 6 Features in Action!

With Visual Studio 2015 available for all, I wanted to explore new language features in C# 6 that you can try right from this blog post!

Interactive Code Sample

// allows calling static members without class name
using static System.Console;
using static System.String;
using static System.Linq.Enumerable;

public class Person
    // auto property initializer
    public string FirstName { get; set; } = "John";
    public string LastName { get; set; } = "Doe";

    // readonly property initialized with expression body
    // assigned to value returned from string interpolation 
    public string FullName => $"{FirstName} {LastName}";

    // method defined with expression body
    public string GetLastNameFirst() => $"{LastName.ToUpper()}, {FirstName}";

    public void Test(string testName)
        var dash = "-";
        var dashLength = 30 - testName.Length;
        // use {{ and }} for literal "{" and "}"
        // use {{{ and }}} to wrap a value within "{" and "}" 
        // repeating a dash with length not to exceed 30
        // WriteLine | Concat | Repeat == using static :) 
        WriteLine($"{{{testName}}} {Concat(Repeat(dash,dashLength))}");

// test default
var um = new Person();
// nameof returns the string name of the instance

// test initialized
var palermo4 = new Person() 
   { FirstName = "Michael", LastName = "Palermo" };

// interactive!  click go -->
    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).

10 Common Mistakes Web Developers Make

web developer making a mistakeThere seems to be endless choices regarding how to accomplish the same task - to develop a website that works in today's modern web. Web developers have to choose a web hosting platform and underlying data storage, which tools to write HTML, CSS, and JavaScript in, how design will be implemented, and what potential JavaScript libraries/frameworks to include. Once choices are narrowed down, the online world is filled with articles, forums, and samples that provide tips for making a better web experience. Yet no matter which path is taken, all developers are susceptible to mistakes. Although some mistakes will be related to a specific approach, there are challenges shared among all web developers. So through research, experience, and recent observations, I thought I would share a list I compiled of ten common mistakes I see web developers make - and how to avoid them.

The following list is in no particular order.

1)  Writing old school HTML

Mistake: The early days of the internet had much less options for markup than we do today. However, old habits die hard, and many still write their HTML as if we were still in the 20th century. Examples here are using <table> elements for layout , <span> or <div> elements when other semantic-specific tags would be more appropriate, or using tags that are not supported in current HTML standard such as <center> or <font>, or spacing items on a page with a large number of &nbsp; entities.

Impact: Writing last decade's HTML can result in over complicated markup that will behave inconsistently across multiple browsers.

How to avoid: Stop using <table> element for layout of content, and limit usage for it to displaying tabular data. Get acquainted with the current markup options available such as seen at Use HTML to describe what the content is, not how it will be displayed. To display your content correctly, use CSS (

2 )  "It works in my browser…"

Mistake: A developer may be fond of a particular browser or really despise one, and might primarily test web pages with that bias in view. It is also possible that code samples found online may be written without factoring how it would render in other browsers. Also, some browsers have different default values for styles.

Impact: Writing a browser-centric site will likely result in very poor quality when displayed in other browsers.

How to avoid: It would not be practical to test web pages in every browser & version during development. However, having a regular interval of checking how your site will appear in multiple browsers is a good approach. Sites such as show snapshots of how a given page would render over multiple browsers/versions/platforms. Tools such as Visual Studio ( can also invoke multiple browsers to display a single page you are working on. When designing with CSS, consider "resetting" all the defaults as shown at

If your site is using any CSS features created specific for a browser, be cautious as to how you will approach vendor prefixes such as -webkit-, -moz-, or -ms-.  For guidance on industry trends in this regard, it would be worth your time to examine the following references:

While the above references explain a movement away from vendor prefixes and why, this site provides practical suggestions on how to work through this today.

3)  Bad form

Mistake: Prompting a user to provide any information (especially when entered into a text field) and assuming the data will be received as intended.

Impact: Many things can (and likely will) go wrong when user entry is trusted. Pages may fail if required data is not provided, or data received is not compatible with an underlying data scheme. Even more serious is the intentional violation of the site's database, perhaps through Injection attacks (see

How to avoid: The first bit of advice here is to make sure it is clear to the user what type of data you are looking for. These days, asking for an address could result in either a business, home, or even email address! In addition to be specific, take advantage of data validation techniques available in today's HTML as seen at this article No matter how data is validated on the browser side, be sure it is always validated on the server-side as well. Never allow a concatenated T-SQL statement to use data from user entry without confirmation the each field is the type of data it should be.

4)  Bloated responses

Mistake: The page is filled with many high quality graphics and/or pictures, scaled down with use of <img> element height and width attributes. Files linked from the page such as CSS and JavaScript are large. The source HTML markup may also be unnecessarily complex and extensive.

Impact: The time to have a page completely render becomes long enough for some users to give up or even impatiently re-request the whole page again. In some cases, errors will occur if page processing is waiting too long.

How to avoid: Don't adopt the mindset that access to the internet is getting faster and faster - thus allowing for bloated scenarios. Instead, consider everything going back and forth from the browser to your site as a cost. A major offender in page bloat is images.  To minimize the cost of images that slow down page loads, try these three tips:

  1. Ask yourself: "Are all my graphics absolutely necessary?" If not, remove unneeded images.
  2. Minimize the file size of your images with tools such as Shrink O'Matic or RIOT
  3. Preload images. This will not improve the cost on initial download, but can make other pages on site that use the images load much faster. For tips on this, see

Another way to reduce cost is to minify linked CSS and JavaScript files. There are plenty of tools out there to assist in this endeavor such as Minify CSS and Minify JS

Before we leave this topic, strive to be current with HTML (see mistake #1) and use good judgment when using <style> or <script> tags in HTML.

5)  Creating code that *should* work

Mistake: Whether it is JavaScript or code running on the server, a developer has tested and confirmed that it works, thereby concluding it should still work once deployed. The code executes without error trapping, because it worked when it was tested by developer.

Impact: Sites without proper error checking may reveal the errors to the end users in an ugly way. Not only can the user experience be dramatically impacted, the type of error message content could provide clues to a hacker as to how to infiltrate a site.

How to avoid: To err is human, so bring that philosophy to coding. With JavaScript, be sure to implement good techniques to prevent errors as well as catch them. Although this article addresses JavaScript coding for Windows Apps, the majority of the topics apply to web development too, and it is full of good tips! Another aid to help create solid code that can hold up well to future changes in code is unit testing (see

Failures in server-side code should be caught without the user seeing any of the nerdy details. Reveal only what is necessary, and be sure to set up friendly error pages for things like HTTP 404s (see

6)  Writing forking code

Mistake: With the noble notion of supporting all browsers and versions, a developer creates code to respond to each possible scenario. The code becomes a heap of if statements, forking in all sorts of direction.

Impact: As new versions of browsers update, management of code files become bulky and difficult to manage.

How to avoid: Implement feature detection in code versus browser/version detection. Feature detection techniques not only dramatically reduce the amount of code, it is much easier to read and manage. Consider using a library such as Modernizr ( which not only helps with feature detection, it also automatically helps provide fallback support for older browsers not up to speed with HTML5 or CSS3.

7)  Designing unresponsively

Mistake: Site development assumes viewing in the same size monitor as the developer/designer.

Impact: When viewing the site in mobile devices or very large screens, the user experience suffers with either not being able to see important aspects of the page or even preventing navigation to other pages.

How to avoid: Think responsively. Use responsive design (see in your sites. A very popular library ready to serve in this area is Bootstrap (

8)  Making meaningless pages

Mistake: Producing public facing pages with content that might be very useful, but not providing any hints to search engines. Accessibility features are not implemented.

Impact: Pages are not as discoverable through search engines and therefore may receive little or no visits. The page content may be very cryptic to users with impaired vision.

How to avoid: Use SEO (search engine optimizations) and support accessibility in HTML. Regarding SEO, be sure to add <meta> tags to provide meaning to a page with keywords and description. A good write up on that is found at To enable a better accessibility experience, be determined to provide an alt="your image description" attribute in each of your <img> or <area> tags. Of course, there is more to do and further suggestions can be investigated at You can also test a public web page at to see if it is compliant with Section 508 (

9)  Producing sites that are too refreshing

Mistake: Creating a site that requires full refreshes of a page for each interaction.

Impact: Similar to bloated pages (see mistake #4), performance of page loading time is affected. The user experience lacks fluidity, and each interaction could cause a brief (or long) resetting of the page.

How to avoid: One quick way to avoid this is by determining if posting back to the server is truly required. For example, client-side script can be used to provide immediate results when there is no dependency for server-side resources. You can also embrace AJAX techniques (see or go further with a single-page application “SPA” (see approach. Popular JavaScript libraries/frameworks are available to make adoption of these methods much easier, such as,, and

10)  Working too much

Mistake: A developer spends a long time creating web content. Time might be spent doing repetitive tasks, or simply typing a lot.

Impact: Time for initial web site launch or subsequent updates is too lengthy. Value of the developer diminishes when it appears other developers are doing comparable work in less time and with less effort. Manual labor is prone to mistakes, and troubleshooting mistakes takes even more time.

How to avoid: Explore your options. Consider using new tools or new process techniques for every stage of development. For example, how does your current code editor compare to Sublime Text ( or Visual Studio ( Regardless of what code editor you are using, have you recently dived into its features? Perhaps a small investment of your time perusing the documentation could unveil a new way to do something that could save hours & hours of time later. For example, note how an extension to Visual Studio can increase productivity for web developers as seen in this post

Don't miss out on tools available on the web to help! For example, check out the tools at to simplify testing (across multiple platforms and devices) and troubleshooting.

You can also help reduce time and mistakes by automating processes. An example of this is using a tool like Grunt ( that can automate things such as the minifying of files (see mistake #4). Another example is Bower ( which can help manage libraries/frameworks (see mistake #9).

How about the web server itself? With the help of services such as Microsoft Azure Web Apps (, you can quickly create a site for virtually any development scenario that can easily scale with your business!


By identifying common mistakes, web developers can eliminate much frustration that others have already endured. Not only is it important to acknowledge, but when we understand the impact of a mistake and take measures to avoid it, we can create a development process catered to our preferences – and do so with confidence!

    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).
    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).

Windows 10 Background Execution and Multitasking

The Universal Windows Platform introduces new mechanisms to allow applications to run while not in the foreground. As well as Background Tasks and Triggers, UWP adds the ability for applications to extended their execution time in the background. Learn how to use these new features and how new resource policies affect how and when your application runs in the background.
    Copyright © Microsoft Corporation. All rights reserved.
    The code provided in this post is licensed under the Microsoft Public License (Ms-PL).