In this October edition of the ILODS, we delve into a variety of topics as usual. There are several articles as always related to developer productivity and life in general as a developer, a few discussions of upcoming changes to popular Javascript-based frameworks like jQuery and Angular and much more.

The House Always Wins

This entertaining piece in Wired introduces John Kane, a video poker junkie that discovered a software exploit in a machine that provided him with a loophole to beat the system. But instead of grabbing a few thousand here and there, he decided to test his exploits out in Vegas. Needless to say, his luck quickly ran out.

I Hate Puzzles. Am I Still a Programmer?

In this article, Zef Hemel discusses a topic that just about every developer has heard of, Puzzles. He covers the often puzzle-filled recruitment processes of many of the world’s top development companies and their reliance on this style of questioning.

Do Not Disturb

Developer productivity is something that every company will always strive to improve upon. Uri Bram recommends the best approach to handling this, is to simply leave the developers alone and let them work. Uri discusses all of the daily occurrences that can interrupt the productivity of a software developer and how these same events affect the amount of work that gets done.

jQuery 3.0 : The Next Generations

It seems like only yesterday that jQuery finally hit that 2.0 milestone and here they are yet again announcing the big three-o. In this blog post, Dave Methvin details some of the plans for the jQuery 3.0 API and many of the goals that this new release will aim to reach including performance, compatibility and being future-oriented.

Angular 2.0

This summary by Coman Hamilton briefly introduces many of the new planned features for the latest release of the ever-popular Angular JS framework. In the latest iteration, there are an abundance of “drastically different” changes from the existing versions and many developers will likely need to do quite a bit of “re-learning” when the new version hits the public. But don’t worry, you’ll have plenty of time as the release isn’t slated until “before the end of 2015”.

It’s a Bird! It’s a Plane! Or is it a Park?

Machine learning can generally produce some really cool stuff and this post from the folks at Flickr is no exception. The team came across a popular xkcd comic and decided “Hey, Let’s do that!”. The team leveraged the extensive computer vision areas of the site to create a fun application that can tell you if any picture you provide is either of a national park, or a bird, or in some cases, a bird in a national park. If this kind of thing is your kind of thing, you can read a bit more about it in this white-paper.

This is Why People Leave Your Company.

This month’s final piece is another work-slash-life one aimed at company management and leaders and why they can sometimes fail to hold onto valuable assets (i.e. you). The article goes into depth regarding many of the most common reasons at why employees jump ship (and why they stick around). It’s a great article for managers to read over to get an idea of how to retain their employees and what those same employees (i.e. you if you aren’t in management) can do as well.

If you have ever worked on a project that involves interactions between 32-bit and 64-bit applications and referencing their DLLs, you may have encountered this guy before :

BadImageFormatException: An attempt was made to load a program with an incorrect format. (Exception from HRESULT: 0x8007000B)

This nasty BadImageFormatException generally stems from referencing legacy libraries (or any libraries containing unmanaged code) that were not really designed to run on 64-bit machines. If your all of the code within your 32-bit libraries is managed, then you should be just fine and you shouldn’t see much of this guy at all. This post will cover two methods for hopefully resolving this issue using configuration features available in both Visual Studio and within IIS.

Troubleshooting this Issue

When running into this, I’m sure that your first instinct will be to toggle through the various settings within your Project / Solution regarding it’s Build target. You’ll probably switch back and forth from x86 (32-bit) to x64 (64-bit) and attempt to re-build and run your application countless times :

When encountering this issue, you’ll undoubtedly toggle between x64, x86 and the Any CPU options. Success may vary by user.

Then you’ll likely say “well the Any CPU setting should work” and you’ll try that, only to again be met with the same error that you encountered previously. This isn’t always the case, as I have found that one of these settings may occasionally work, but success may vary by user and application.

Resorting to IIS

If tinkering with the available settings and targets within the Build tab of your Solutions properties didn’t help, you might need to pull out the bigger guns and try to handle this at the Application Pool level in IIS. Try opening up the IIS Manager that your application is targeting and go through the following steps :

1.) Open up your Available Applications pools within IIS :

2.) Right-click on the Application Pool that houses your troubled Application and choose the “Advanced Properties” option :

3.) Set the “Enable 32-Bit Applications” option to “True”

4.) Finally, restart / recycle your Application Pool for these changes to go into effect :

I’ve found that this should fix the issue a majority of the time, however there are performance considerations that you might want to review over prior to making this change. The primary one being memory availability / access to a much larger possible memory space. If you are using this approach, you might want to consider reading through this related Stack Overflow discussion on using this setting within IIS to get an idea of a few other possible side-effects.

More Information

If you want to learn a bit more about how 32-bit and 64-bit processes interact with one another within the CLR, I would encourage you to give Scott Hanselman’s post on this same issue a read. Scott describes the article as “obscure”, but again, if it is something that you are interested in, it’s certainly worth a read and goes into quite a bit of depth.

I strongly encourage anyone out there even remotely interested in vNext to check it out. It’s extremely informative and provides a bit of a behind-the-scenes look at how the technology is being developed and might answer many questions that you have about how vNext will change .NET in the future.

I thought I would take some time to address a question that has frequently appeared in a few forum questions over the past month or so and that is “How do I use the TinyMCE Editor within ASP.NET MVC?”. Since I’ve answered this quite a few times, I thought I would take a few minutes to share the process with the rest of the net so prevent this from popping up in the future.

Let’s address a few of the extremely common questions.

Can I use TinyMCE with ASP.NET MVC? Or Web Forms?

Of course you can. TinyMCE is simply a pure Javascript rich text editor that has no reliance on MVC, Web Forms or any other server-side related technology. All you need to use it is some simple HTML markup and the appropriate TinyMCE Javascript and content files (which are included within the download).

How or where can I download TinyMCE?

The easiest approach would be to download the latest TinyMCE package via NuGet through the following steps :

• Right-click on your Project.
• Choose Manage NuGet Packages from the Context menu.
• Select the Online tab on the left within the dialog box.
• Search for “TinyMCE” in the upper right-hand corner.
• Install the TinyMCE package to your project.

If you aren’t using ASP.NET or simply do not have access to NuGet, you can always visit the TinyMCE site and download the latest version of the editor from there.

A Simple Walkthough for Getting Started with TinyMCE

Let’s create a simple new MVC 5 Application through Visual Studio. For simplicity’s sake, I’ll just be using an Empty Project with the appropriate MVC references added :

Create a new Empty Project with the appropriate MVC references.

Next, you’ll need some way to access the TinyMCE files. Two of the most common approaches (downloading the NuGet package or directly downloading from TinyMCE) are detailed above, this example will use the NuGet approach, but both of them should be similar.

Use the NuGet Package Manager to easily install the TinyMCE Package

You should now see several new files within a newly created “~/scripts/tinymce” folder. This folder contains everything that you need to use and configure the TinyMCE editor.

In order to actually use the editor, you’ll need to create a Controller with a single action that points to a View. For all intents and purposes, we will call this one “TinyMCEController” and it will have a an action called “Index” and another Index action that is decorated with an [HttpPost] attribute (and will accept a class that we will define below) :

public class TinyMCEController : Controller
{
        // An action to display your TinyMCE editor
        public ActionResult Index()
        {
            return View();
        }

        // An action that will accept your Html Content
        [HttpPost]
        public ActionResult Index(ExampleClass model)
        {
            return View();
        }
}

Next, let’s actually flesh out this very simple class that will just have a single, but very important property and an even more important attribute decorating it :

// An example class to store your values
public class ExampleClass
{
        // This attributes allows your HTML Content to be sent up
        [AllowHtml]
        public string HtmlContent { get; set; } 

        public ExampleClass()
        {

        }
}

The [AllowHtml] attribute is going to by-pass ASP.NET serialization protection (which can aid in preventing nasty XSS or any other types of garbage input that might fly on it). Without this attribute, you would need to disable RequestValidation for the specified action which is a bit overkill in this scenario as you just need to check for HTML.

The next step will be to add a View that targets your Index action. Right-click on your Index Controller Action and choose the available Add View… option that appears in the context menu. In this example, we won’t be using a Layout page or a Template, so you can leave those options :

You’ll just need to create a very basic View without any templating or Layouts. Usage may vary.

After generating your View, you’ll need to add a few references in to target and configure your TinyMCE scripts. You’ll also need a very simple <form> element to post your content from the TinyMCE editor as detailed below :

<!-- This View uses your Model -->
@model TinyMCE.Controllers.ExampleClass
<!DOCTYPE html>
<html>
<head>
    <meta name="viewport" content="width=device-width" />
    <title>TinyMCE Example</title>
    <!-- TinyMCE Script Reference -->
    <script src="~/scripts/tinymce/tinymce.min.js"></script>
    <!-- Script to wire up your TinyMCE editor -->
    <script type="text/javascript">
        // Initialize your tinyMCE Editor with your preferred options
        tinyMCE.init({
            // General options
            mode: "textareas",
            theme: "modern",
            // Theme options
            theme_advanced_buttons1: "save,newdocument,|,bold,italic,underline,strikethrough,|,justifyleft,justifycenter,justifyright,justifyfull,|,styleselect,formatselect,fontselect,fontsizeselect",
            theme_advanced_buttons2: "cut,copy,paste,pastetext,pasteword,|,search,replace,|,bullist,numlist,|,outdent,indent,blockquote,|,undo,redo,|,link,unlink,anchor,image,cleanup,help,code,|,insertdate,inserttime,preview,|,forecolor,backcolor",
            theme_advanced_buttons3: "tablecontrols,|,hr,removeformat,visualaid,|,sub,sup,|,charmap,emotions,iespell,media,advhr,|,print,|,ltr,rtl,|,fullscreen",
            theme_advanced_buttons4: "insertlayer,moveforward,movebackward,absolute,|,styleprops,spellchecker,|,cite,abbr,acronym,del,ins,attribs,|,visualchars,nonbreaking,template,blockquote,pagebreak,|,insertfile,insertimage",
            theme_advanced_toolbar_location: "top",
            theme_advanced_toolbar_align: "left",
            theme_advanced_statusbar_location: "bottom",
            theme_advanced_resizing: true,

            // Example content CSS (should be your site CSS)
            content_css: "css/example.css",
        });
    </script>
</head>
<body>
    <!-- This will automatically post to your Index method (that is decorated with a HttpPost attribute) -->
    @using (Html.BeginForm()) 
    {
        @Html.AntiForgeryToken()
        <div>
            <!-- This will contain your HtmlContent and use the TinyMCE editor-->
            @Html.TextAreaFor(model => model.HtmlContent)
           
            <input type="submit" value="Create" />
        </div>
    }
</body>
</html>

Obviously, the configuration code that is used above within the <script> tag might look a bit overwhelming. You can visit the TinyMCE Examples page which demonstrates a few varying levels and features depending on your needs.

After adding your View in, you should be able to run your application and see the following :

Once you hit the Create button within the View, your content will be posted with its associated markup to your Controller and you should be able to see it without any issues :

Alternatives and Other Editors

Although this walk-through explicitly targeted the TinyMCE editor, it is my no means limited to just it. The same basic steps should work with any of the popular client-side Rich Text Editors such as Redactor, CKEditor, HTML Editor and more. You’ll just need to include the proper references and content files and ensure that you are targeting the proper element when using the configuration code.

It should be noted that there are a variety of other NuGet packages out there for using TinyMCE as well if this felt like too much of a hassle. The TinyMCE.MVC relies on an HTML Helper to build and wire up your editors for specific areas and can be useful if you don’t like messing with Javascript at all. It’s just a matter of preference.

Pardon the brevity of this month’s ILODS release, it’s been a month of deadlines, crazy news and all sorts of other things. Anyways, I hope that you find some of these links entertaining, useful or some balance of both and I’ll try to make October’s list a bit more complete than this one.

Lessons from a Lifetime of Being a Programmer

In this article, Andrew Wulf reflects on many of the things that he has learned throughout his career, most of which you would never be taught without experiencing first-hand. Depending on how long you have been writing software, some of these may be familiar and others you might not encounter for a while. Hopefully this can serve as a reasonable “beware the ides of March” so you can keep a look out.

Algorithms, Get Ya’ Algorithms Here!

Learneroo has managed to pack a huge amount of algorithmic-based knowledge into an easy to follow series of snippets and challenges to make learning them easier. The challenges gradually get progressively more complex as do the topics (from basic data structures to matrices, weighted graphs and pathing algorithms).

10 Articles Every Programmer Must Read

This excellent compilation of articles from the folks at JavaRevisited provides an overview of various topics and basically explains “What you need to know about _____ if you are a programmer”. Topics include Memory, Time, Unicode, URLs, SEO, Web Development, Networking, Strings, Security and more!

Getting Schooled by the Developers of the Future

In this Information Week article, it discusses the recent rise in some European nations of adopting and teaching coding practices throughout primary and secondary schooling and actually even creating entire “Coding Schools” to help mold the minds of the world’s future developers.

Debugging courses should be mandatory

This this article, Stanislav Nedelchev provides an overview of the importance of debugging and why it should be taught properly as a course. As developers, we use various approaches to debugging in our daily lives and if developers were introduced to these things early in their careers (or even in school / college), they might find it easier to resolve problems on their own without aimlessly “googling” around the net.

In my continual effort to catch up on this seemingly endless back-log of blog posts, this monthly installment of the ILODS is quite a bit late. This month covers a few different topics primarily focusing with a few database-oriented topics as well as the usual sprinkling of personal / professional related articles.

3 Highly Effective Habits of Remote Developers

“Work from Home” and  “100% Remote” are often found in the titles of job descriptions that many software developers dream about, but it isn’t easy. You might think that waking up and spending hours coding sans pants might be as easy as it sounds, but it’s difficult to do well. This article by Walter Chen discusses a few key changes that you might consider making if you are going to be working remotely and you want to do it effectively!

The Future is Now : Hyperlapse is Here!

Are you a film-maker? Do you have tons of unnecessary footage that might be cool if usefully compiled into a shorter compilation? Do you like practical Computer Science related research? Well, if you answers “Yes” or “No” to any of the previous questions, then I would recommend checking out this recent article on Microsoft Research’s Hyperlapse algorithm and watching it in action.

Document Databases Meet Azure

If document databases like NoSQL are your thing and you are big into the cloud, you might enjoy the announcement of Microsoft’s DocumentDB. A A fully-managed, scalable, NoSQL document database service.

Don’t Call Yourself a Programmer

In this much needed article by Patrick McKenzie, he discusses the importance of what you call yourself in your career and how it might affect you in the long run. “Programmer”, “Coder”, “Software Developer” are generally all clumped together as the same thing, but Patrick demonstrates that what you call yourself can matter. This is just one of the many insights this article provides and I encourage any one that writes code to read.

What ORMs Have Taught Me : Just Learn SQL.

This article by Geoff Wozniak discusses his thoughts on the recent rise in ORM (Object Relational Mapper) usage in the past few years and some of the detriments that come along with it. While writing pure SQL may go against these trends, he argues that it is still better than letting an ORM do all of the work (incorrectly) for you.

Compute Magazine and Appreciating the Internet

This Ars Technica piece turns back the clock to 1985 and what you might have to do to find a code snippet. Before the days of Stack Overflow, github and all of the other sites with code that we know and love, there was paper. That’s right, if you wanted to know how to code “Balloon Crazy” for the Atari, you needed to swing by your local newstand and pick up a copy of Compute Magazine, which ever so kindly included the game in BASIC, which was a heck of a lot better than when it included the machine code implementations.

Appreciate the internet.

During a bit of site testing, I encountered a rather strange bug when viewing a site that was developed using the incredible Twitter Bootstrap. The Responsive collapsing navigation menu didn’t appear to work at all and all of the menu items that were present were all jumbled around. It not only looked bad, but it severely hindered the usability of the site at all.

After some research, I came across the following snippet that appeared to resolve the issue. Simply paste this into the <head> section of your application and it should hopefully resolve your Bootstrap issues on Windows Phone devices :

<!-- Bootstrap Fix for Windows Phone -->
<script type='text/javascript'>
        (function() {
            if ("-ms-user-select" in document.documentElement.style && navigator.userAgent.match(/IEMobile\/10\.0/)){
                var msViewportStyle = document.createElement("style");
                msViewportStyle.appendChild(document.createTextNode("@-ms-viewport{width:auto!important}"));
                document.getElementsByTagName("head")[0].appendChild(msViewportStyle);
            }
        })();
</script>

It’s been a rather busy month, so without further ado, here is this months ILODS.

Bootstrap on a 386

If you ever encounter a client that simply hasn’t migrated to anything newer than a 386, but needs you to write a new web application for them, then you are in luck! Mark Otto and Jacob designed BOOTSTRA.386, a 386-themed Bootstrap theme that will be sure to bring back memories.

How to Destroy Developer Productivity

An excellent article from George Stocker regarding all of the everyday activities that can absolutely crush developer productivity. From developer arguments to open floor plans, George rattles off his experiences with what has and hasn’t worked for him in being more productive.

30 Days with Bootstrapping ASP.NET MVC

Fellow ASP.NET MVC James Chambers provides a very well written series on integrating the Twitter Bootstrap (not the previously mentioned BOOTSTRA.386) into ASP.NET MVC Applications. This 30-part series covers just about everything that you could think of and hits a number of common use-cases that developers may encounter when using Bootstrap. Highly recommended for any ASP.NET MVC Developers.

The Unspoken Truth about Managing Geeks

If you are reading this blog post, the likelyhood is rather high that you could be classified as a “geek” or one of the many synonyms there are out there and there is absolutely nothing wrong with that. In this 2009 article from Computer World, Jeff Ello addresses many of the concerns that are faced when actually managing “geeks”. It’s not only a great article to read if you are in management and it likely wouldn’t hurt to read it if you are one of the “geeks” being managed either.

vNext, vNext, Read all about it!

ASP.NET vNext has slowly been creeping into the Microsoft Development realm recently and although it is still in it’s earlier phases, it’s never too late to Get Started learning it. This ASP.NET tutorial series introduces vNext and walks through how to not only Get Started with vNext, but it provides a step-by-step tutorial for several different projects (and platforms).

A Compilation of Architecture and Patterns in ASP.NET

The patterns are strong with this one. In this post, .NET Developer Andras Nemes compiles an absolutely monstrous list of .NET implementations of just about every major design pattern that you could think of (and many that I am sure you couldn’t). It doesn’t only feature code snippets of their implementations, but also sample projects.

If you have ever worked in an environment that may not have been the most reliable or you are simply a worry-wart when it comes to possible data loss, then this might be for you.

When discussing a recurring issue with another developer, he complained that his older computer frequently crashed which resulted in him losing data quite often. He didn’t seem to be aware of a feature within Visual Studio called AutoRecover that would help him ensure that his data wasn’t always “gone forever”. While it typically works on it’s own, this post will discuss AutoRecover, configuring it and locating all of the temporary files it creates if you need to find them.

What is AutoRecover?

AutoRecover is an option within Visual Studio that will allow you to define a particular interval in which to save information about all of the files that may be changing or have changed within your application. It’s perfect for scenarios where you might have a machine that is on the verge of death, intermittent power issues, data-loss anxiety and just about anything else that might have you spouting off expletives when your screen goes black (or blue).

How do I use it?

You can access the AutoRecover option in Visual Studio through the following steps :

1. Select Tools from the Toolbar in Visual Studio.
2. Choose Options…
3. Select AutoRecover beneath the Environment tab on the right.

You’ll then be presented with the AutoRecover dialog box :

You’ll just need to adjust these values depending on your needs and how erratic your machine can be.

Accessing AutoRecover Files

Accessing the files themselves is quite easy as well. By default, Visual Studio will store all of these files within a “Backup Files” directory which is typically located at the following location :

~/Documents/{Your Version of Visual Studio}/Backup Files/{Your Project Name}

Within this folder, you will see a collection of files that are both original and those that have been previously recovered as seen below :

Visual Studio will typically prompt you to open these files if your system experienced an unexpected shut down when opening an affected solution or project, but this should provide an easy way to access these files if things do go horribly wrong.

Although there is often some debate regarding its pronunciation, I believe that most of us can agree that NuGet is pretty great.

In the past few years, NuGet has become one of the easily and most commonly used tools within a .NET Developers bag of tricks and rightfully so. Long gone are the days of searching for a DLL file in some shady site and hoping that it doesn’t brick your application. Now you can find just about every possible reference you would want to include within your application in just a few clicks (and letting it sort out all of the dependencies).

Most developers have likely interacted through NuGet within Visual Studio, however this post is going to introduce another way to interact, explore and even publish your own NuGet packages called the NuGet Package Explorer.

What is the NuGet Package Explorer?

The NuGet Package Explorer is a open-source product of NuGet developer Luan Nguyen and was developed as an extremely user-friendly GUI application for easily creating and exploring NuGet packages. After installing the ClickOnce application, you can simply double-click on a NuGet Package file (.nupkg) to access all of its content or you can load packages directly from the official NuGet feed.

How to use it?

First, you’ll need to visit the NuGet Package Explorer page on CodePlex, where the tool is currently available and download it. After a short download, you can launch the ClickOnce application and be presented with the following screen :

These are your primary options when it comes to creating or exploring the contents of any available NuGet packages (in addition to simply clicking on any NuGet Package files as mentioned earlier). The easiest approach to get started would probably be to open up a package from the feed, which will present you with a searchable dialog with all of the most popular NuGet packages :

After clicking on a package, you can choose the particular version you wanted to explore :

You also have the option of manually opening up any packages that you might have locally installed, but simply grabbing them from the feed is usually going to be the way to go.

Exploring a Package

Once you select a package that you want to explore a bit more, you can just double-click on it to present the details about that package :

An example of exploring the EntityFramework NuGet Package.

While exploring a package, you’ll see many of the summaries, details and descriptions that you might be accustomed to seeing when managing your NuGet packages through Visual Studio along with a bit more.

You’ll see an area called Package Contents, which display all of the files that are contained within the package and it can help give you an idea of the different versions of the framework that it targets, any transformations that will be applied to configuration files and any additional utilities or executables that might be run when the package is installed :

This is where you can really actually explore the packages by digging into the contents a bit more. By simply double-clicking on a file within the contents, you will be shown a preview (if available) of the contents :

This can be done for just about any kind of file that would normally support previews and it can be extremely useful if you wanted to see exactly what is going down inside some of these packages.

Creating a NuGet Package

The Package Explorer isn’t limited to just exploring existing packages. It provides a very easy-to-use interface to allow you to create your own packages and upload them to NuGet to share with others.

With a simple click of the File > New option menu or by using the CTRL+N shortcut :

You’ll be transported to a new package screen to begin building your own NuGet Package. You can click the Edit Metadata icon ( ) to began actually editing information about your package :

You can find a complete reference of all of the available fields listed above and exactly what they are used for by visiting the Nuspec Reference page here.

After defining all of your metadata, supported assemblies and dependencies, you will then be ready to add your files and content to your packages. You can do this by just clicking a file within the File Explorer and dragging it into the Package Contents area on the left :

All of the DLL files that are entered will be placed into the lib directory and all other basic content will be placed into an aptly named content directory as seen below :

Additionally, if you need to add other folders (or any other “special” types of folders), you can do so by using the Content menu :

You can continue to add all of the additional files and folders for your package in this same manner until your package is complete.

Publishing to NuGet

Publishing to NuGet is fairly simple after you have build your package.

The first thing that you’ll need to do is Register and Sign In to the NuGet Gallery, which takes a matter of seconds. This will provide you with an API key that you will need to use in order to publish packages to NuGet :

After you have your API Key, you’ll just need to use the Publish option (File > Publish) within the NuGet Package Explorer :

Just enter in your API Key in the Publish dialog and hit Publish and you are done!

This month’s installment of the ILODS is really all over the place.

There are articles and posts detailing some of the larger happenings from two major conferences that went down in the month of June, a bevy of interview-related resources, pretty algorithms, technology education, developer exploitation and package exploration. Oh my!

In case you missed dotnetConf 2014

The great thing about dotnetConf is that it has all of the great Sessions that are present at a major conference, but you don’t even have to leave your desk or office space to attend it. Thanks to the folks at Channel 9, you can access all of the Sessions from the conference with ease and even skip through any jokes that you aren’t particularly fond of. It’s a great resource to get up to date on the latest happenings within the .NET arena like vNext, updates to C#, Azure, SignalR and more!

A Smorgasbord of Interview Questions, Tips and Resources

Software Development interviews can be frightening, hectic and much like a box of chocolates, you never know what you are gonna’ get. If you are currently looking for a change of scenery or you just want to generally brush up on some of the common questions that you might encounter, then this may just be the resource for you. A large team of developers along with several recruiters got together to build this collection of questions, tips and notes related to Software Development interviews.

Visualizing Algorithms

If you are brushing up on your interviewing skills as mentioned in the previous item, you’ll likely want to re-familiarize yourself with various commonly encountered algorithms. While this site won’t necessarily assist you in learning the algorithms, it will show you that they can sometimes look really awesome. Mike Bostock, a Stanford PhD candidate, created this collection of various visualizations of different algorithms, which can be pretty entertaining and helpful to those that are more visual learners. If you liked this particular post, I would encourage you to explore more of Mike’s site as it is filled to the brim with different types of data visualization examples.

Chat Wars

This essay by David Auerbach, a former Microsoft employee discusses the “Chat Wars” between Microsoft and AOL that occurred for several years in the late 1990s. It’s a great read and will give outsiders a bit of perspective about many of the popular chat options of the times (ICQ, AIM, MSN and Yahoo) and the power struggles that went on behind the scenes to keep the battle going on for years to come.

Chuck Norris, HTML and Crap

This highly entertaining Stack Overflow question discusses a rather bizarre behavior when values like ‘chucknorris’ , ‘crap’, ‘MrT’ and others are assigned as background color values within HTML.

Swift

At WWDC earlier this month, Apple unveiled a new programming language called Swift. Swift is being touted as a new general purpose language that is “quick, much faster than Objective-C” and it supports closures, generics, type inference, name spaces, multiple return types and more. The language itself is capable of being run along size other Objective-C or C code within the same application, which enables you to start using it right away!

The Second City puts Computer Science First

Chicago is planning on breaking the mold regarding how Computer Science and technology is introduced to students. The city plans to start integrating Computer Science into the core curriculum within its public schools over the next three years in hopes of improving computer literacy, encouraging pursuits in the S.T.E.M fields and building a stronger and more technology focused workforce.

How to Exploit a Developer

This brief article discusses one of the many popular “hackathons” or “app development competitions” that you might have seen around, but when you delve a bit deeper into it, it looks like the grand prize is simply being exploited.

NuGet Package Explorer

If you are a fan of NuGet, you might want to give the Nuget Package Explorer a try. It’s a simple ClickOnce application that allows you to easily create and explore available NuGet packages with a single click and much more. It’s an extremely useful tool that is entirely free and available on CodePlex. I’ll try to post a walk-through for using it in the coming months, as I believe that it is a really great tool worth using.

Time is money, especially when that time is spent handling things like calculating hours worked and filling out time-sheets.

Recently, a user on the forums posed a question about how to go about calculating the number of hours worked between two specified dates. The request required that it must be handled through Javascript and that it must be as “exact as possible” down to the minute. So I wrote up the following very sub-optimal solution and thought I would post it here on the off-chance that anyone encounters the same issue.

Let’s take a look at what information we need :

• Define the work hours during the day (ie 9AM-5PM)
• Define a starting and ending date to calculate between.
• Determine if weekends are counted.

Using this information I threw together the following (and I have annotated to help specify what is going on) :

// Simple function that accepts two parameters and calculates the number of hours worked within that range
function workingHoursBetweenDates(startDate, endDate) {
    // Store minutes worked
    var minutesWorked = 0;
  
    // Validate input
    if (endDate < startDate) { return 0; }
    
    // Loop from your Start to End dates (by hour)
    var current = startDate;

    // Define work range
    var workHoursStart = 9;
    var workHoursEnd = 18;
    var includeWeekends = false;

    // Loop while currentDate is less than end Date (by minutes)
    while(current <= endDate){          
        // Is the current time within a work day (and if it occurs on a weekend or not)          
        if(current.getHours() >= workHoursStart && current.getHours() <= workHoursEnd && (includeWeekends ? current.getDay() !== 0 && current.getDay() !== 6 : true)){
              minutesWorked++;
        }
         
        // Increment current time
        current.setTime(current.getTime() + 1000 * 60);
    }

    // Return the number of hours
    return minutesWorked / 60;
}

or if you would prefer to pass in all of your variables as parameters, you could use :

// Simple function that accepts two parameters and calculates the number of hours worked within that range
function workingHoursBetweenDates(startDate, endDate, dayStart, dayEnd, includeWeekends) {
    // Store minutes worked
    var minutesWorked = 0;
  
    // Validate input
    if (endDate < startDate) { return 0; }
    
    // Loop from your Start to End dates (by hour)
    var current = startDate;

    // Define work range
    var workHoursStart = dayStart;
    var workHoursEnd = dayEnd;

    // Loop while currentDate is less than end Date (by minutes)
    while(current <= endDate){      
        // Store the current time (with minutes adjusted)
        var currentTime = current.getHours() + (current.getMinutes() / 60);
             
        // Is the current time within a work day (and if it occurs on a weekend or not)                   
        if(currentTime >= workHoursStart && currentTime < workHoursEnd && (includeWeekends ? current.getDay() !== 0 && current.getDay() !== 6 : true)){
              minutesWorked++;
        }
         
        // Increment current time
        current.setTime(current.getTime() + 1000 * 60);
    }

    // Return the number of hours
    return (minutesWorked / 60).toFixed(2);
}

or if you want a minified version thanks to Google’s Online Closure Compiler :

function workingHoursBetweenDates(a,b,e,f,g){var c=0;if(b<a)return 0;for(;a<=b;){var d=a.getHours()+a.getMinutes()/60;d>=e&&d<f&&(g?0!==a.getDay()&&6!==a.getDay():1)&&c++;a.setTime(a.getTime()+6E4)}return(c/60).toFixed(2)};

Basically, it simply starts at the beginning time and iterates until the end (while monitoring the number of minutes worked during this period). By no means is this optimal, but it should serve as a very basic example of how to calculate such a value within Javascript. Please feel free to post any improvements or optimizations within the comments section as this was just a hastily thrown together solution to solve the issue at hand.

You can find a working example here :

You can play around with an interactive example within JSBin

One of the common challenges for developers migrating from the Web Forms environment to MVC is learning how to adjust to a different application life-cycle. Web Forms had a very well defined chain of events that would be triggered prior to a page being rendered, however the lines aren’t as clear within MVC.

Earlier this month I stumbled upon the following document from Cephas Lin provided both a high-level overview and a detailed view of the general life-cycle within an MVC application and I thought I would share it :

Basically the life-cycle, it could be summarized (very simply) as follows :

1. The Application is started (through Application_Start) and the appropriate Routes are wired up and configured.
2. An HTTP Request comes in and MVC takes over.
3. Your Controller that cooresponds to that Route will be created, instantiated and any authorization filtering will be handled (if failed it will send back a failed request).
4. Any model binding will occur from the Request to any parameters to populate your values.
5. The logic of your Action will be executed as expected and it will find a View that corresponds to the one specified in the Action and pass it the appropriate Model.
6. The Model will populate the View and it will be served to the user.
7. The Result will be executed and the Controller will be disposed of.

This is a very generalized summary (it doesn’t go into detail about ActionFilters etc.). Hopefully it might help developers that are just migrating to MVC better understand what is going on behind the scenes.

If you wanted a more detailed exploration of it, I would recommend reviewing over the detailed view of the document above and checking out the following other related resources :

• Understanding the MVC Page Life Cycle
• What is the Page Life Cycle of an MVC Page and How does it compare to Web Forms?
• The Life of an ASP.NET MVC Request

In this month’s installment of the ILODS, we will take a look at all of the exciting announcements from Microsoft’s TechEd 2014 event as well as the usual collection of all sorts of other development-related news. Exciting things are ahead!

How Scott Hanselman Changed My Life

If you are a software developer working under the Microsoft umbrella, you are probably familiar with Scott Hanselman (and if you aren’t, you should be). This blog post from Noah Addy discusses how Scott inspired him to pursuit his dreams in the realm of technology. It’s a great read and it’s extremely inspiring story about how our heroes (even our development heroes) can help shape and improve our lives.

Meet vNext.

While I could probably spend an entire series introducing vNext (and I eventually will), I’ll give you the gist of it.

Probably one of the largest development announcements from Microsoft was the introduction of ASP.NET vNext. vNext is a complete revamp of the ASP.NET stack with a focus on being “leaner” and providing a better foundation for building both web-applications and those designed for Azure and the cloud. vNext flips the script and completely merges all of Web Pages, MVC and Web API into a single housing (MVC) and takes a very George R. R. Martin-equse approach to System.Web.

Actually – here are some of the release notes about it :

• MVC, Web API, and Web Pages will be merged into one framework, called MVC 6. MVC 6 has no dependency on System.Web.
• ASP.NET vNext includes new cloud-optimized versions of MVC 6, SignalR 3, and Entity Framework 7.
• ASP.NET vNext will support true side-by-side deployment for all dependencies, including .NET for cloud. Nothing will be in the GAC.
• ASP.NET vNext is host agnostic. You can host your app in IIS, or self-host in a custom process.
• Dependency injection is built into the framework.
• Web Forms, MVC 5, Web API 2, Web Pages 3, SignalR 2, EF 6 will be fully supported on ASP.NET vNext
• .NET vNext (Cloud Optimized) will be a subset of the .NET vNext Framework, optimized for cloud and server workloads.
• MVC 6, SignalR 3, EF 7 will have some breaking changes:
  • New project system
  • New configuration system
  • MVC / Web API / Web Pages merge, using a common set of abstractions for HTTP, routing, action selection, filters, model binding, and so on
  • No System.Web, new lightweight HttpContext

If you want to learn more about vNext, you can visit the vNext area of ASP.NET or you can check out Jon Galloway’s incredible collection of vNext resources here.

It’s Codin’ Season and I’m Huntin’ Code

Last year, I wrote up a post discussing Microsoft Research and the work that they have done with Pex. Pex, if you are unfamiliar with it, is a tool designed to help with white-box and unit-testing however it’s a bit more playful than that. The folks at MS Research elaborated on it a bit more and decided to make a game out of it called CodeHunt. CodeHunt is essentially a puzzle-based game that helps introduce people to coding through solving different challenges and progressing onto more difficult stages. It’s an interesting concept and I am sure that it could use a bit of work – but it is a step in a good direction to get people interested in coding (in a fun way).

A SQL Join Cheat Sheet

“You put your left-join in, you take your left-join out, you put your left-join in and you shake it all about.”

With the abundance of different kinds of SQL Joins out there, it can often get confusing when using them (if you don’t do so regularly). This cheat sheet filled with Venn diagrams might be worth printing out and laminating for the DBA in your life.

A Primer on Machine Learning : Differentiating between Magic and Machine!

If you have an interest in Machine Learning or frankly don’t know anything about it. Adam Geitgey provides a fairly concise and accessible introduction to the topic in this blog post. He details the different types of learning that a machine can do and even provides a few examples to demonstrate it as well. It’s not only an excellent primer on the topic, but if you find yourself interested he provides several links to continue your learning on the subject.

Change your Mind-set : Transitioning from jQuery to Angular

I stumbled across this excellent discussion on Stack Overflow which is worth reading for anyone working with Javascript frameworks. The question itself is from a developer that has a significant amount of experience with jQuery and is planning on making the transition to AngularJS. The discussion details some of the changes in mind-set and different hurdles that can be expected for anyone doing the same.

11 Across. I hate myself Down.

I’ve always been a fan of puzzles, but this is certainly not for everyone. Maria Pedersen and Ole Michelson created Regex Crossword, another puzzle site that torments its visitors by solving crossword puzzles through Regular Expressions (and they get crazy). It’s a nice switch from something like Suduku and you might find yourself learning a bit more about Regular Expressions in the process.

It sadly will not teach you when and when not to use them however.

If Shakespeare was in a rap battle…

If you remember that scene in Office Space where Michael Bolton (played by David Herman) is rapping, then this might be for you.

I know as a software developer and a fellow fan of rap music that I have often thought about analyzing all of the words within the rap genre to truly find which artist has the most diverse vocabulary. Thankfully I didn’t have to, as Matt Daniels decided to do just that. In one of his many analyses of hip-hop music, he culled through all of the data and compared today’s MCs against OG William Shakespeare to see how they compared. It’s an extremely entertaining read and it will only further reinforce the mantra : “Wu Tang Clan ain’t nothing to f*** with.”

Putting the ‘S’ in Solid : Swiss Army Knife Syndrome

In this short rant, Allan MacGregor discusses “Swiss Army Knife Syndrome” which results when the ‘S’ for single-responsibility in SOLID design principles turns to … well another four-letter ‘S’ word. It’s something that everyone needs to be reminded of now and then and what better way to do it then through a blog post filled with knives.

In this month’s installment of the ILODS, we take a look a quite a few announcements that were made at Microsoft’s Build conference, articles to help you figure out if you are over-thinking your development projects or if you are simply blaming the guy that was there before you, the Heartbleed bug, Javascript, open-sourcing, New Orleans and much, much more.

Knowing Too Much to Code

It’s not very often that we associate experience with in inability to get something done, however it may be the case in what Scott Hanselman calls “Analysis Paralysis”. In this blog post, Scott discusses how more experienced developers might “over-think” many sometimes simple applications and make them far more complex than they need to be. He reminds us to ask ourselves “are we going to need that” throughout the development process to help curb this paralysis from affecting our productivity.

From “Potent Potables” to the Human Genome

Although it isn’t directly development-related, it’s always fun to see what development can actually result in. Any fans of Jeopardy should remember the cerebral beat-down served by IBM’s Watson to trivia wizards : Ken Jennings and Brad Rutter (primarily thanks to its insane robot buzzer reflexes). However, it now appears that Watson is now on our side and it’s opponent is a nasty one : cancer.

IBM hopes that Watson will be able to analyze millions of medical records and find correlations between cancer patients that might be impossible for human analysis to discover. Hopefully, this data-first approach may lead to new treatment methods and may help Watson solve one of our generations most challenging questions : finding a cure to cancer.

Extensions. Extensions Everywhere!

In his talk at //Build this year, Mads Kristensen discussed the myriad of different tools and extensions available for Visual Studio that can help developers be more productive and in general make their lives easier. The list has extensions that cover a wide variety of topics such as productivity, templating, styling and more. I would highly recommend checking it out to see if you discover anything that makes you say “I’ve been looking for something like that!”.

And the Two Become One : Durandel and Angular Converge!

In this article, Rob Eisenberg (the creator of Durandel) discusses the differences and similarities between Durandel and the popular Angular Javascript frameworks in hopes of providing a response to “Which one should I use?”. He covers an ideal framework that merges many of the stronger features from each framework and how this convergence will help shape the futures of both of the respective libraries.

Change Your Password. Probably. 

One of the largest stories of this month has been the uprising of a nasty bug known as Heartbleed. The Heartbleed bug itself is a vulnerability within the popular OpenSSL cryptographic library and it basically leaves systems using it “exposed” and allows virtually anyone access to any secrets that might be housed behind the normally secure SSL walls if exploited.

If you are unsure if you might need to change your password or if you would like an idea at the popular systems that were affected, you may want to check out this link which details many popular sites to determine if you need to change your password. Additionally, you will want to ensure that you don’t change your password until the affected site has been properly patched and their certificates have been renewed.

Since this is a .NET specific blog, I will note that if you are using IIS then you have nothing to worry about as Microsoft uses schannel to handle all of its SSL needs.

Meet New Orleans.

This has nothing to do with the city in my home state and has everything to do with building highly-scalable Azure based applications. In this article, the ASP.NET team reintroduces project “Orleans”, which provides an approach to building high-scale applications using a service-based model. The project was used heavily within the popular Halo game series to help it achieve its massive scalability needs. It’s openly available currently, so you can head over an visit the project on CodePlex and check out if it may fit the bill for the needs of one of your current or upcoming projects.

Building Javascript Applications like a Superhero!

If you like Javascript and you have a strong desire to build them like a superhero, then this might be just the thing for you. The team at Superhero.js compiled a huge assortment of  resources relating to building and maintaining large-scale Javascript applications, organizing your code and utilizing the appropriate patterns, testing your applications and much, much more.

Introducing IdentityManager

In this post, security guru Brock Allen introduces his most recent creation : IdentityManager, a tool to help manage user identity data through the new ASP.NET Identity or his own MembershipReboot library. IdentityManager provides an extremely easy to use interface that should replace the recently departed ASP.NET Web Site Administration tool that many developers were extremely fond of in Visual Studio 2012. It supports user creation, password changes, e-mail, phone, claims and much, much more.

Passing the Blame.

Shamoon Siddiqui discusses why the latest developer at your company might seem like a wizard when compared to your previous developer. This piece covers a wide array of reasons why developers shouldn’t always be compared to one another or why one shouldn’t be necessarily blamed for decisions that were made at the time (hindsight is 20/20). It’s a solid article for any developer that can often be caught blaming others for their decisions without necessarily knowing what it was like being in their shoes.

The .NET Foundation and Open-Source

Another major announcement at the Build conference was the introduction of the .NET Foundation, a collection of open-source technologies and Microsoft’s development framework. It was established to help foster community involvement, collaboration and development with regards to open-source applications and to help bolster the relationship between Microsoft and the open-source community.

A wide range of Microsoft’s technologies within the .NET stack have already been open-sourced such as ASP.NET MVC, SignalR, Web API and even the powerful Roslyn compiler-as-a-service. If you want to dig around the source and see how some of the technologies were established, visit the link above and dive into the technology of your choice.

Additionally, the entire source of the .NET Framework is available as well that interests you and can be accessed through the Reference Source site here.

A little over a month ago, the ASP.NET team announced several changes and updates to the .NET Reference Source and in this post we are going to discuss how to actually integrate it into Visual Studio so that you can step into the actual .NET Framework source when debugging your applications.

What is Reference Source again?

Reference Source, if you are unfamiliar with it, was a project that Scott Guthrie and his team started back in 2007 in hopes of releasing the .NET Framework source to allow developers to easily reference it (without all kinds of decompilation and mischief) to see what was really going on under the hood. Shortly after that release, the team made a few changes that would allow developers to actually step through the source code which was a major step in a very cool direction.

One of the major difficulties with managing something that is constantly evolving like the .NET Framework is purely the fact that it is “constantly evolving”. Updating documentation usually takes time and with a project of this magnitude, it could simply be something that is “left over until the end” or simply doesn’t get done :

Reference Source circa 2007 via Scott Guthrie

Reference Source Meets Roslyn.

As part of this year’s announcement regarding Reference Source, it was mentioned that it would be joining forces with Microsoft’s latest development wonder, Roslyn.

Roslyn is a managed compiler-as-a-service that has really flipped the script in the .NET world recently. It provides all kinds of wonderful features that were simply not possible in previous years and has already been used not only by Microsoft but in many other arenas such as .NETFiddle, Bing Code Search, Semantic Merge and more. Roslyn was used to help generate a semantic index of the entire .NET Framework source to allow it to be searched through with the greatest of ease.

Currently, .NET 4.5.1 is indexed and readily available on the Reference Source site and the ASP.NET team announced a commitment to keep things updated with each upcoming release as they occur to prevent any stagnation that may have plagued the previous versions of the tool. So you can be relatively sure that whenever you are accessing the latest version of the Reference Source that it should be the latest and greatest. The improvements were not limited to just performance either.

The UI received a very stylish overhaul as well and yield some of the nicest looking documentation that you’ll come across :

The New and Improved Reference Source

Another undocumented feature is the tiny snippets of entertaining comments that you can find scattered throughout the source as well :

An example of one of the many entertaining comments throughout the source.

Putting it to Good Use.

Let’s actually put the Reference Source to use along with Visual Studio 2013 and use it to debug an application by not only stepping through our own code, but into the source of the .NET Framework as well.

To get started, there are a few changes we need to make within Visual Studio that will allow us to target the Reference Source (which will primarily consist of enabling and disabling a bunch of properties in the Options menu).

Open up Visual Studio and navigate on over to the options menu (Tools > Options > Debugging > General) as seen below :

You’ll need to enable and disable the following options within the Debugging Options in Visual Studio

and then you are going to disable the following options :

• Just My Code
• Step over Properties and Operators (Managed Only)
• Require Source Files to Exactly Match the Original Version

and enable these ones :

• Enable .NET Framework Source Stepping
• Enable Source Server Source

After making the changes, your options menu should look like this :

This is what your Debugging Options should look like prior to stepping through Reference Source

Then, you’ll need to make sure that when debugging that you are targeting the actual Visual Studio Reference Source. You can do this by visiting the Symbols area under options (Tools > Options > Debugging > Symbols) :

You’ll need to access the Symbols area in order to use Reference Source when debugging

From here, you’ll want to target the Reference Source symbols available at http://referencesource.microsoft.com/symbols. You’ll need to click the Add Symbols option within the Symbols area and add the previously mentioned URL :

Click the Folder icon and add the appropriate symbols reference for Reference Source

What I have found to be a safer and more reliable approach however, is to simply download the source and reference it locally from the following location :

http://referencesource.microsoft.com/DotNetReferenceSource.zip

After making those changes, you’ll need to ensure that the project that you are going to be debugging is targeting .NET 4.5.1. Debugging through Reference Source is going to currently be limited to 4.5.1 and above since those are the only actual versions of the .NET source that have been indexed so far.

Looking Under the Hood.

Now that we have configured everything, let’s make a really simple program to demonstrate traveling through the source.

// Generate a collection of values (1-100)
var numbers = Enumerable.Range(1, 100);
// Order them randomly
numbers = numbers.OrderBy(n => Guid.NewGuid());
// Store these values in an array
var numberArray = numbers.ToArray();
// Sort the array
Array.Sort(numberArray);

Using the simple program above, we will create a collection of numbers, randomly order them, store them in an array and then finally sort them using a variety of methods.

Let’s place a breakpoint on the first line and run the program.

When you hit your first breakpoint, right-click on the method (in this case System.Linq.Enumerable.Range) and you should see an option within the context menu called “Step Into Specific” which will allow you to send the debugger into the .NET source for that particular method as seen below :

You can use the “Step into Specific > (Your Method)” option to debug through the .NET source.

After selecting the method to step into through “Step into Specific”, you’ll see that the debugger jumps into the related .NET source and you can step through the method as you would expect within any other .NET application being debugged :

After using the “Step into Specific” option, you’ll be presented with the source for your specific function, which you can debug as expected.

And that’s basically all you need to know about using Reference Source within Visual Studio to debug your applications. You should be able to jump into any of the assemblies that are currently supported within Reference Source without any issue.

Considerations

A few other considerations if you are having trouble :

• Debugging through Reference Source currently ONLY works for full versions of Visual Studio 2013 (sorry no Express versions). I’ve spoken with several members of the Visual Studio team and they are looking into possibly removing this restriction in the future.
• Ensure that the assembly that you are attempting to step into is one of the available assemblies for debugging mentioned here.

If you still continue to encounter any errors or something isn’t working that you believe should – contact the Reference Source Feedback team via the “Feedback” link on the Reference Source page.

April 1st is a day that is frequently dedicated to pranks, bogus news and tomfoolery.

Generally keeps everyone’s shields of skepticism on high alert and I consider myself to fall into this category. So I have to say that when I received an e-mail from Microsoft with the tagline of “Congratulations 2014 Microsoft MVP!” I was extremely hesitant (I mean what a terrible day to make an announcement on).

April Fools Joke? Nigerian Prince Scam? Or Legit?

As I continued reading through the e-mail, I didn’t find any evidence that might require my bank account information or wire-transferring thousands of dollars to a Nigerian prince. In fact, things were beginning to look legitimate and that I might actually have received the award. A quick tweet to Dora Chan (the North American MVP Lead) quickly confirmed my suspicions and a small amount of celebration went down in my office :

Dora dispelling the possible April Fool’s Myth.

I was officially a Microsoft MVP for ASP.NET / IIS and I really couldn’t be more proud.

I’ve become very close with several MVPs primarily through my work in the ASP.NET Forums and I have a great deal of admiration for them. They are extremely smart and passionate people that dedicate days and hours of their lives to helping others learn and become better at what they do. I have looked up to several of these individuals every since I began contributing to the development community and I am extremely honored to be able to join the MVP ranks alongside them.

What the MVP Program Is? (this is primarily for my untechnical family members and friends)

To quote from the program’s page itself for those unfamiliar with the program :

The Microsoft Most Valuable Professional (MVP) Award is our way of saying thank you to exceptional, independent community leaders who share their passion, technical expertise, and real-world knowledge of Microsoft products with others. It is part of Microsoft’s commitment to supporting and enriching technical communities. Even before the rises of the Internet and social media, people have come together to willingly offer their ideas and best practices in technical communities.

How did you end up with one?

The simplest answer to this would revolve around the days (and likely weeks) of time that I spend in discussion groups, blogging, offline activities and contributing to the ASP.NET (and a few other) forums.

I’ve always been a fan of helping others in any ways that I could. My work on the forums has been extremely rewarding and it has yet to become tiresome (even averaging around an hour a day for a year and a half). I’ve met some great people that I can turn to for advice of my own and I’ve been able to mentor many novice developers and help point them in the right direction when they run into issues.

As far as how I actually ended up with the award… I was nominated by several users (some MVPs and some not) that encouraged me to pursue the actual award, believing that I would be a reasonable candidate for it. I was a bit hesitant at first, as I had heard the discussions behind the scenes regarding granting the award itself were extremely rigorous, but I figured “what the hell”.

So after a few months – I entered in all of my pertinent information, clicked send and basically forgot about it.

Thanks.

I am extremely honored to receive this award and it means a ton to me. So I figured I would throw out a handful of thanks since this is my blog and I can “do that” :

• Thanks to my wife, Katie for putting up for my hours of sitting in bed with my face illuminated from a Surface as I answered questions all night.
• Thanks to my employer, Structure X for being an awesome place to work for (and more specifically to Blane for being an incredible person to work for).
• Thanks to my parents, obviously because I wouldn’t be here.
• Thanks to my alma mater, McNeese State University for having a great Computer Science department that wasn’t actually afraid of Microsoft technologies like C#.
• Thanks to the ASP.NET Forums and all of the people involved in it (the moderators, the MVPs, the management team and everyone who goes there to either ask questions or answer them).
• Thanks to the academy, err… wrong speech.
• Thanks to Microsoft for making a kick-ass platform like .NET that I really enjoy working on and for sending me the e-mail that brought this post about.

Finally, thanks to you, whoever you are, for reading my blog and helping make part of this possible as well. I appreciate you.

In this St. Patrick’s day installment of an Interesting List of Development Stuff, we dive into a more .NET-centric approach (with a majority of the topics at least being in the realm of .NET) but as usual, there should be something for everyone. The Roslyn compiler continues to make waves and appears in several of the articles (which we may see as a trend as it continues to grow in popularity) and there’s also a few articles pertaining to games (if that’s your thing).

Depixelizing Pixel Art

Microsoft Research is always doing cool stuff and this article is no exception. It discusses an algorithm that was developed to help smooth the appearance of pixelated images (mostly involving Nintendo-related characters) and it yielded some really neat results. I am sure that nothing excites people more than smooth pixels, but this article has everything : badass-looking video game characters (that we have always wondered what they would look like in their unpixelated glory), legit scholarly work on algorithms, splice curves and more (again decorated with video game characters) and its all packed into 8 pages.

I would highly encourage anyone interested to read through the actual paper itself and if that isn’t your thing, at least take a look at the supplemental material to see it in action.

ElasticLinq

Brad Wilson and Jim Newkirk of Tier 3 introduce their latest creation ElasticLinq, which is an open-source project that aims at integrating elastic-searching using LINQ syntax within .NET. It’s a tool that was originally developed in-house at Tier 3 to help ease the transition for developers with traditional database backgrounds to NoSQL-based databases and now hopefully it can help you make the transition as well!

How Roslyn and Azure Helped Create .NET Fiddle

I’ll use this as a pseudo-followup to my post last year on .NET Fiddle. .NET Fiddle has really taken off and added all kinds of awesome new features such as NuGet support, MVC support and all kinds the general badassery that one would look for in an online developmental sandbox. This short article isn’t so much about the merits of .NET Fiddle, but more of a look behind the scenes at how it came to be; you can think of it as a love story between Azure and Roslyn.

Open-source Projects! Come on down!

If you are a big fan of open-source software or you have an open-source project, then listen up. OSSPerks.com features a large listing of available services and APIs that are offered free of charge to open-source projects. They vary in scope but there are a lot of very well known vendors involved – so if your project needs a little extra something and your pockets are light, check it out.

There’s a new operator in town.

It looks like one of the most popular suggestions to appear within Microsoft’s UserVoice system is finally coming to fruition. The Safe Navigator operator (?.) will be likely introduced within the next iteration of C# and Visual Basic and should aid in warding off those NullReferenceExceptions that always find a way into our lives, hearts and applications.

Atom, the completely hackable Editor

The folks at github set the web ablaze with all kinds of chatter and backroom deals when discussion of their Atom editor broke out. Atom was designed as a completely “hackable” editor that could be easily extended to do – really whatever you wanted it to do. It’s still a project that is very early in its infancy, but it is something to keep your eye on.

Meet Reference Source

The great Scott Hanselman discusses another one of the recent offspring from the seemingly promiscuous Roslyn compiler in the form of Reference Source. This incredible innovation will now allow developers to step through the actual source of the .NET Framework while debugging their applications (so if you have ever wondered just what kind of sort was going down in that Array.Sort() method, here is your chance). It’s certainly a tool worth keeping your eye on – and if you want to hear and see more about it, you can check out this post from the MSDN team as well.

Walking through the Code of Games

Fabien Sanglard‘s blog is a fascinating place to visit if you haven’t been by (you can get there by just clicking the link). He has a myriad of different articles, book reviews and discussions on algorithms, but the reason I am bringing it up are his source code reviews. Now, I know that most people would cringe at reading a source code review, but these focus on actual commercial games like Doom, Prince of Persia, Duke Nukem 3D and Fabien does a great job of “skipping to the good parts”.

2048.

I’m not saying anything more about this – you’ll likely hate me if you haven’t previously discovered it. It’s digital heroin.

What Does It Do?

Released just this month as an extension for non-Express editions of Visual Studio 2013, Bing Code Search presents some very cool and useful features, which may be especially useful for experienced developers that need a quicker method of accessing examples and resources and for new developers still trying to figure out the code they need to accomplish tasks like reading files or iterating through collections.

After installing the extension in Visual Studio, you’ll see the  a small Bing logo above the native Visual Studio Intellisense. This will allow you to search for and use code examples and snippets from sites like Stack Overflow, MSDN and more without ever leaving your development environment or dragging an open browser onto another monitor :

Using the Bing Code Search to suggest possible solutions to a problem

What is going on here?

Magic!

Just kidding, but in as with most recent Microsoft innovations in the realm of development, the Roslyn compiler is involved (which is a bit magical). Basically, when you begin your search, your specific query is sent up to Bing along with several other important contextual pieces of information related to your project (such as the Project type, contextual keywords and other goodies) and then it returns a filtered and ranked set of results that might best match the code example you are looking for.

Since there isn’t a holy grail website containing all of the latest a greatest code examples, the code search will actually scour a multitude of different Q/A sites along with some other documentation and resources and compile a listing of relevant code examples that the developer can easily use either for documentation or to copy-paste directly into their project.

How Do I Use It?

The Bing Code Search extension is currently only available for Visual Studio 2013 (non-Express editions) and can be easily downloaded and installed from the Visual Studio gallery at link provided below :

• Download the Bing Code Search Extension for Visual Studio 2013

If you don’t have Visual Studio 2013 or you just want to get an idea of how the service works, you can access a fully working example running below at Microsoft Research’s CodeSnippet area :

• Try out Bing Code Search Online at Microsoft Research

Try it out.

As a free tool that is incredibly easy to use, I would highly recommend giving it a shot if you have a non-Express edition of Visual Studio 2013 installed. It’s still a very early product and will likely continue to improve in the future (hopefully expanding to non-Express editions as well as earlier versions of Visual Studio), but it may be a great tool to consider adding to your development arsenal either as a time-saver if you are an experienced developer or as an excellent learning tool for those just diving into the development world.

In this installment of my monthly treasure trove of development stuff, we take a slightly more .NET-oriented approach by covering several ASP.NET specific topics, resources and more. But there are quite a few other things that may be applicable to just about any kind of developers (and especially those that may be looking for a job).

Send a Valentine’s Day Math-o-Gram

In honor of Valentine’s Day, the folks over at Desmos decided that rather than sending a crummy card to your loved one, you could give them something that all women really love: math. By creating a very simple Node.js application, you can plug in different formulas and create a customizable “love graph” to send to your significant other.. or just play around with it.

Sidewaffle

No, sadly this is not some new breakfast-related concoction covered with delicious syrup. What is it however is an incredibly useful extension to Visual Studio that adds a bunch of different snippets, templates and other goodies into Visual Studio to help you become a more efficient and productive .NET developer.

Codility Training

Codility is a great site that administers short, automated programming tests for companies that are looking to hire developers. The tests can be performed in a variety of languages and they don’t simply evaluate if the applicant can solve the problem at hand, but how efficient they solved it (considering computational complexity) and if they handled edge cases as well. Now, obviously most readers of this blog are not going to be hiring managers, but Codility offers a free training area to help prepare those that are entering the job market to beef up their problem solving skills. It’s a superb resource for those of you out there that are currently in the job market and want to improve your chops.

Who needs Code Reviews?

A slightly satirical look at the benefits to productivity, developer happiness and deadlines when developers stop working about reviewing code and just start coding.

Strapfork

While it is still just in beta, Strapfork is a new visual editor for developing themes using Twitter’s Bootstrap. It aims to make the entire process of customizing and creating your own themes a cinch by allowing you to adjust every detail from gradients to typography and more. Stay tuned for more!

A Last Look at ASP.NET in 2013 and what to look forward to in 2014!

Jon Galloway covers the good times and the bad times had in 2013 by ASP.NET and how it has grown and continues to develop into a young adult (we are so proud). He reviews over all of the major improvements that have been made in the past year and details what to expect and watch for in 2014.

Do you really need jQuery?

Do you ever wonder if you really need to include that jQuery reference in your project or if there might be another very simple approach that could save you all those delicious kilobytes? Well then this is just the link for you. This site reviews over a bevy of tasks that jQuery typically handles and provides the equivalent code in pure Javascript. It’s a great resource for those that may want to slim down their sites and applications a bit if they are just using jQuery for handling things like AJAX or trivial DOM manipulation.

Nu-Gotta-Get-It

If you develop .NET applications, then you probably are a fan of NuGet (if not, go read about it and then come back when you are a fan). This site helps you find the best and most popular NuGet packages that you might be missing out on and allows you rank existing packages based on quality, documentation and more. It’s worth checking out if you are looking to incorporate a specific feature or package into your application and there are a ton of different choices out there.

Using the Pomodoro Technique and Trello to Lead a More Efficient Life

A great article by John Sonmez using the Pomodoro technique to help dramatically improve your productivity not only in your career, but also to help organize your life.

IdentityReboot and MembershipReboot

Security guru, Brock Allen introduces two of his major projects which aim to improve the existing ways that ASP.NET handles both Identity and Membership from a security perspective. If you have any qualms about weaknesses within ASP.NET and its built-in security mechanisms, you can be almost assured that Brock has addressed those in these two packages. Even if you aren’t a security expert, the introductions are worthy reads that may interest you enough to use them in the future.

This is obviously an exaggeration.

Sometimes things just blow up.

If you have recently attempted to create a new ASP.NET MVC5 project (or any new Web Project within Visual Studio 2013) and decided that you wanted some of that sweet SignalR magic in your application, then you may have encountered the following error :

An exception of type ‘System.IO.FileLoadException’ occurred in Microsoft.AspNet.SignalR.Core.dll but was not handled in user code.

Additional information: Could not load file or assembly ‘Microsoft.Owin, Version=2.0.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35’ or one of its dependencies. The located assembly’s manifest definition does not match the assembly reference. (Exception from HRESULT: 0x80131040)

This can easily be reproduced through the following steps :

1. Create a new Web Application Project in Visual Studio 2013 that uses built-in Forms Authentication (Individual User Accounts).
2. Add the SignalR package through NuGet.
3. Attempt to add the following code to your Startup.cs file :

   public partial class Startup
   {
           public void Configuration(IAppBuilder app)
           {
               // Add SignalR Mappings
               app.MapSignalR();
   
               ConfigureAuth(app);
           }
   }

If you did everything right, then grab some popcorn because you are about to see this :

Why is this happening to me?

Of all of the things to blame, we are going to choose NuGet for this one.

This is currently a known issue within NuGet. The reason for this is that SignalR and some other binaries are built with a dependency over Microsoft.Owin Version 2.0.0, however the appropriate assembly binding redirects are not occurring. This causes a problem as the latest available version of Microsoft.Owin in the public NuGet feed is greater than 2.0.0.

Okay. But how do I fix it?

There are two options here, which I have each had success with so I’ll start with the easiest approach, installing a specific updated version of Microsoft.Owin (and Microsoft.Owin.Security) and ensuring that you are properly targeting it within your web.config.

You can do this within the following steps :

• Access the NuGet command-line tool within Visual Studio (accessible under Tools > Library Package Manager > Package Manager Console)
• Install an updated version of Microsoft.Owin and Microsoft.Owin.Security (2.0.1, 2.1.0, 2.2.0 or any other version) using the following command :

  Install-Package Microsoft.Owin -Version 2.1.0
  Install-Package Microsoft.Owin.Security -Version 2.1.0

• Ensure that your web.config has the appropriate <bindingRedirect> attributes to target the version you selected as seen below :

  <runtime>
     <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
         <!-- Other Assemblies here -->
         <dependentAssembly>
             <assemblyIdentity name="Microsoft.Owin" publicKeyToken="31bf3856ad364e35" culture="neutral" />
             <!-- Notice this targets 2.1.0.0 -->
             <bindingRedirect oldVersion="0.0.0.0-2.1.0.0" newVersion="2.1.0.0" />
         </dependentAssembly>
         <dependentAssembly>
             <assemblyIdentity name="Microsoft.Owin.Security" publicKeyToken="31bf3856ad364e35" culture="neutral" />
             <!-- Notice this targets 2.1.0.0 -->
             <bindingRedirect oldVersion="0.0.0.0-2.1.0.0" newVersion="2.1.0.0" />
         </dependentAssembly>
     </assemblyBinding>
  </runtime>

The other longer and seemingly less reliable (in my experience) approach

This method appears to only work if the version of Owin that was installed through NuGet is already greater than one of the dependencies that you already have.

The second option involves creating a Console application and then add the SignalR package to it. Then copy the  bindingRedirects from the app.config file of this application to the web.config file in your previous exception-infested MVC application (as Console applications don’t have this same issue).

You really just need to update the oldVersion and newVersion attributes within the <bindingRedirect> sections for your Microsoft.Owin and Microsoft.Owin assemblies within the <assemblyBinding> section of your web.config from :

<runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
        <!-- Other <assemblyBinding> elements for your Project -->
        <dependentAssembly>
            <assemblyIdentity name="Microsoft.Owin" publicKeyToken="31bf3856ad364e35" culture="neutral" />
            <bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
        </dependentAssembly>
        <dependentAssembly>
            <assemblyIdentity name="Microsoft.Owin.Security" publicKeyToken="31bf3856ad364e35" culture="neutral" />
            <bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />
        </dependentAssembly>
    </assemblyBinding>
</runtime>

to :

<runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
        <!-- Other <assemblyBinding> elements for your Project -->
        <dependentAssembly>
            <assemblyIdentity name="Microsoft.Owin" publicKeyToken="31bf3856ad364e35" culture="neutral" />
            <bindingRedirect oldVersion="0.0.0.0-2.0.2.0" newVersion="2.0.2.0" />
        </dependentAssembly>
        <dependentAssembly>
            <assemblyIdentity name="Microsoft.Owin.Security" publicKeyToken="31bf3856ad364e35" culture="neutral" />
            <bindingRedirect oldVersion="0.0.0.0-2.0.2.0" newVersion="2.0.2.0" />
        </dependentAssembly>
    </assemblyBinding>
</runtime>

Or more simply, change the <bindingRedirect> sections for each of your Owin-related assemblies from :

<bindingRedirect oldVersion="0.0.0.0-2.0.0.0" newVersion="2.0.0.0" />

to :

<bindingRedirect oldVersion="0.0.0.0-2.0.2.0" newVersion="2.0.2.0" />

Languages

Since you need to actually know a language (at least one for humans and one for computers) before you begin your journey, it’s probably important to have an idea of what your choices are. There are primarily three main languages that you’ll encounter most often in the .NET world, so I’ll provide a few resources for each of the major ones to help you on your way :

C#

A modern, object-oriented, general purpose programming language with strong similarities to Java (if you are familiar with Java) and likely the most common language that you will see when working in the .NET world. C# is incredibly versatile and easy-to-learn and is widely supported. You should have no trouble finding examples for nearly any scenario that you would need in C#.

• Resources to Learn C#
  • Getting Started with C#
  • MSDN C# Resources Area
  • Microsoft Events Virtual Webcasts and Virtual Lab
  • Channel 9’s Series on C# Fundamentals for Beginners

Visual Basic

Another object-oriented language that may be quite a bit more elusive than C# with regards to being seen or used in many modern projects. Visual Basic has a syntax that you could argue is “all its own” and it may be a bit foreign to those coming from other languages like C, C++ or Java. Nevertheless, it is still a popular language and it is still being widely used today and while it wouldn’t be my first recommendation for a .NET language to pursue, it is an option.

• Resources to Learn Visual Basic
  • MSDN Visual Basic Resources Area
  • Visual Basic Tutor
  • Microsoft Events Virtual Webcasts and Virtual Lab
  • Channel 9’s Series on Visual Basic Fundamentals for Beginners

F#

One of the most elusive of the major .NET languages is F# and this is probably due to the fact that it is a functional language (although it can encompass object-oriented and imperative concepts as well) and it the youngest of the .NET languages. It has began to gain more traction in recent years however it would receive a bronze medal if a popularity contest was held between the three languages listed here. But if you are feeling adventurous or come from a functional programming background, it is worth checking out.

• Resources to F#
  • TryFSharp
  • MSDN Visual F# Resources
  • Microsoft Events Virtual Webcasts and Virtual Lab
  • An Introduction to F#

You’ll also need an actual development environment to run these in. Thankfully, Microsoft offers a free “Express” version of Visual Studio (its flagship IDE) completely free for personal and commercial usage, which you can download from the link provided below :

• Download Visual Studio Express 2013 and Get Started with .NET

Books

Books typically aren’t the first thing to come to mind when searching for resources on learning a technology, but people wouldn’t write them if they didn’t work. For you page-turners out there that learn best by being away from a screen and keyboard, I’ll provide a few highly recommended options that should give you a jump start into the .NET world :

Beginning ASP.NET 4.5: in C# and Visual Basic (Beginner Friendly)

This tutorial-centric book provides a great introduction to ASP.NET and is a perfect book for both developers that are new to .NET or those that may have worked with it previously as a refresher. The author does an excellent job of not only providing code to the reader, but thoroughly explaining why the code is there and how it works. (This is also a great choice as it provides both routes in C# and Visual Basic for those that are familiar with either of the languages)

Professional ASP.NET 4.5 in C# and VB (Beginner Friendly)

Don’t let the “Professional” in the title scare you away if you are just learning ASP.NET, as this title is a great choice for an introductory book to .NET or for those that have some experience under their belts. The superstar team of authors focuses on many of the foundational concepts throughout ASP.NET and covers all of the major features available within the technology so that the reader will feel confident tackling applications both big and small.

Beginning ASP.NET Web Pages with WebMatrix (Beginner Friendly)

This book is undoubtedly the best one that I have come across on ASP.NET’s Web Pages technology that uses the WebMatrix platform, which is excellent for those just getting started in .NET. This book is extremely comprehensive as well and covers not only ASP.NET specifics, but many of the tangent web development technologies like HTML, CSS, Javascript, AJAX and basically everything you would need to develop complete and dynamic web sites.

Pro ASP.NET MVC 4 (Some ASP.NET knowledge recommended)

Adam Freeman (and Steven Sanderson) provide an excellent introduction to ASP.NET MVC and hold your hand as your create your first MVC application and then things begin to rev up a bit in a title that covers MVC in a very comprehensive way. The book not only does a superb job of explaining how MVC applications operate and how to handle just about every situation that might arise when developing an MVC app.

Professional ASP.NET MVC 4(Some ASP.NET knowledge recommended)

Written by a team of rock-stars in the .NET world, Professional ASP.NET MVC 4 is a great primer to get started with ASP.NET MVC after you have a bit of foundational work under your belt. Much like the previous title, this work covers MVC in its entirety and goes into a bit greater depth about topics that are close tangents to MVC such as jQuery, AJAX calls, dependency injection and more.

As you can see, the MVC-specific books by nature are going to have a slightly larger learning curve than a traditional “Web Forms” approach. If you are a quick learner and already have some web development experience, then you should feel right at home jumping into them, but if you are looking for titles to hold your hand and explain ASP.NET in its entirety, then you may be better off with one of the “Beginner Friendly” books above.

Resources and Tutorials

For some reading can be one of the best ways to absorb the concepts when learning a new technology, however I have found that developers tend to learn best when they actually can sit in front of a keyboard and “develop”. I’ve always thought that the best way to learn to become better at something is to do that very thing and software development is not exempt from this rule.

I’ve compiled a list of different resources and tutorial series that I would recommend anyone that is looking to learn or become more proficient in ASP.NET to consider below :

Getting Started with ASP.NET

If I only had one resource to name on this entire post, this would be it.

Coincidentally, the first resource on the list just so happens to be one that shares the name with the technology itself (asp.net) so you can probably bet that it is going to be a pretty reliable place to visit. The Getting Started area of the ASP.NET site has everything a developer of any level would need to further their knowledge: tutorials, video series, walk-throughs, examples, discussions and more. All of the content was written and developed by leading members of the .NET community or actual members of the .NET development team and the quality shows.

Microsoft Events and Hands-On Labs

An often overlooked resources for those looking to get some “hands-on” experience (even though they are through videos) is Microsoft’s Events site. It features full-length lab sessions and webcasts that cover a variety of topics for developers of all experience levels, which is great for those that prefer a more structured, instructor-led learning environment. There are 500+ different events listed under ASP.NET and the events can be accessed either on-demand or you can even participate in a live lab in progress (assuming you schedule to attend it) via web cast.

Channel 9

Channel 9 is Microsoft’s video archive of all things development and it contains thousands of videos that cover just about every aspect of Microsoft development and technology. You can find video tutorials, explanations and overviews on ASP.NET and any of its underlying sub-categories (Web Forms, MVC, WebMatrix, Web API, SignalR, SPA and more) all in an extremely easy to use and follow format that allows the viewer to easily “skip to the good parts”.

Microsoft’s Beginners Development Center

Microsoft’s Beginners Development Center is another excellent resource that not only provides a series of tutorials for ASP.NET, but it also features a crash-course on Web Development in general including an introduction to HTML, Javascript, CSS and more. If you continue to explore around the site, you’ll see that it isn’t restricted to any particular area of development and has content for web applications, desktop applications, web services and more.

Microsoft Virtual Academy

Another learning resources available from the folks at Redmond is the Microsoft Virtual Academy. The academy is a web-based, course-driven learning environment that has full courses that cover just about every major topic and technology covered by Microsoft. If you are looking to learn more about .NET or any Microsoft technology and you learn best using structured courses, then this is certainly worth checking out.

Any of the above resources would be excellent areas to focus your learning and I would recommend scouring through each of them, as you would be surprised how the teaching styles of different instructors might help you learn or understand something more effectively. I will mention it again however – if you want the most comprehensive place to look for learning ASP.NET, then visit ASP.NET

Supplementary Learning

While tutorials and books are excellent resources, there are a few other resources that I would recommend (if you are interested) that cover not only ASP.NET but development in general and would likely be worth checking out :

PluralSight

If you are a developer and you like instructor-led training through well-designed courses, taught by people that know what they are talking about, then you need to seriously consider investing in a PluralSight subscription. PluralSight is the premier developer training site not only for learning about .NET or Microsoft-related technologies in general, but ANYTHING development related. The courses cover a wide-range of categories and range from “FizzBuzz” and “Hello World” level to designing scalable enterprise-level system architecture.

Code Academy

Code Academy is a great resource to learn many of the the supplementary skills and technologies that are associated with ASP.NET such as Javascript, HTML, CSS, jQuery and more. These may play a bit less of a factor when you are first getting started (especially if you are working with Web Forms) but as you migrate to more advanced applications and want a bit more control over how things look, these are valuable skills to pick up.

DotNetFiddle

DotNetFiddle is a great tool to tinker with basic .NET Applications from the comfort of your browser. It supports all of the languages listed above (C#, F# and Visual Basic) and has support for easily integrating NuGet packages into your applications as well.

Software development is a fascinating thing.

With a scope so vast and so many languages, topics and general cool things that people are doing, it can be difficult to keep up. So I have decided to start compiling a few of the links, resources, blog posts and other projects that I find “interesting” or just worth reading and putting them up on here to share with others. I don’t really plan on having any particular scope for the content and it may or may not even be related to .NET, but I thought it would be a nice addition to the blog.

Overthinking Development

Ars Technica compiled a collection of posts that stems from a question that was posed on Stack Exchange regarding how far you should plan into the future when developing software (or if you should even look into the future at all). Several developers chime in and provide different points for different scenarios in a very read-worthy article.

Kimono Labs

The folks over at Kimono Labs recently created a neat little tool that will essentially turn any website into a structured and usable API that can be stored, queried and used to create other wonderful things all from the comfort of your browser. It’s currently in the beta phase and who knows what the future might hold when it is officially released.

Choosing a Javascript MVC Framework

Craig McKeachie reviews over some of the major players in the Javascript MVC Framework game that you might encounter if you wanted to develop a sweet SPA application. He discusses some benchmark numbers, features and some things to consider when choosing one over the other.

Learnfun and Playfun

Tom Murphy, a recent PHD graduate from Carnegie Mellon decided to venture out and see if he could write some software to teach a computer to play Nintendo games and succeeded (relatively). In a series of entertaining videos, he reviews over the algorithm that he uses to “teach” the computers how to play by exposing them to a small portion of the game being played and then lets it loose and demonstrates some pretty entertaining things.

How to Not Hire a Google Software Engineer

A short-article that discusses why a start-up looking to hire one of the elusive “rock-star” developers from everyone’s favorite search engine giant failed event with a hefty “$500,000” salary offer.

Programmers and 4K

I love high-resolution monitors, especially when I am doing anything development related. This blog post covers over why 4K is basically designed for programmers and software developers and why it may actually be cost effective to go buy one for yourself.

Algorithms and Combat

The folks over at CodeCombat, a start-up with a focus on using creative means teach development and to find talented developers through games and puzzles, review over an algorithm design contest they held and some of the results. As with most things on the Internet, if you think that you have done something in the best possible way, you are wrong (and people will love to tell you about it).

Updated .NET Releases

The ASP.NET team released a series of “.1” releases earlier this month that featured improvements for ASP.NET MVC (5.1), Web API (2.1) and Web Pages (3.1). Each of these are available through their respective NuGet packages.

Mentoring Software Engineers

Matt Brown has a nice blog post on the process of mentoring  up-and-coming Software Engineers and some things to consider both for the mentor and the student. It’s a great article for anyone that has ever done any mentoring of fellow software developers and hopefully interests those that have not to do so.

So I thought I would wrap up this year with a hastily written summary of some of the things I did this year to help make a contribution to the development world.

I never would have realized how time-consuming consistently helping the community would be when I began this journey earlier this year. It was a huge investment on my part and thankfully I was able to continue on this path without my wife threatening to kill me although she did hear the “let me finish typing this one thing / post / answer” quite a bit, so I have to thank her for my current state of being un-murdered. I would estimate that I probably spent at least around 8-10+ hours a week specifically doing community-based activities and I had a great time doing it.

If I couldn’t sleep, I would hop up and write a blog post or spend a few hours answering questions or sometimes I would mash on my Surface until either the battery died (which isn’t an easy task) or I simply fell asleep (which occasionally occurred mid-answer). When I wake up I would answer questions or work on blog posts before eating breakfast or during lunch, it became a habit but in my mind, a positive one.

Let’s take a look at where I spent a majority of my time.

The ASP.NET Forums.

Since I spent an overwhelming majority of my time working with .NET and other Microsoft development technologies, I couldn’t really think of a better place to focus my efforts than a forum that focused on just that. I had always remembered ending up there when searching for different issues and felt that Stack Overflow was a bit too chaotic, competitive and unfocused to be my primary choice.

So beginning in January, I began answering questions and tried to avoid just blatantly posting links to other sites whenever possible. I have focused on making a genuine effort to not only answer the questions asked but also help explain exactly what is going on and recommend better methods and best practices that they should consider using in the future. As a result, many of the answers I provide often resemble tiny, well-formatted blog posts, which I hope not only benefit the original poster discover what they were looking for, but to serve as a resource for future users that may encounter the same problems.

Above all, I feel that these contributions have no only allowed me to impart some of the knowledge that I have gained over the years onto others, but it has also help sharpen my skills through teaching others and communicating with other community experts and MVPs to help all of us improve as a whole.

And I haven’t stopped since, let’s take a look at some numbers :

• Posts since January : 9,001 (averaging ~25 posts per day)
• Posts marked as Answer : 4,268 (averaging  ~12 answers per day)
• Points since January : 60,542 (averaging ~170 points per day)
• Views for posts since January : 785,212

I know that people often say that “points” are meaningless and for the most part they are. However, I do feel that they are a motivating factor for people like me to keep doing something that can often be stressful or time-consuming, but they serve as a number to let me know that I am contributing to something. All of these values were extremely helpful in setting personal benchmarks and goals to strive for to keep me going throughout the year and I am happy with the results.

During my time spent here, I have had the opportunity to meet some incredible people. The ASP.NET forums are full of Microsoft MVPs, ASP.NET Insiders, Microsoft employees and all sorts of wonderful developers with astounding accolades. The moderators always kept things clean, quickly removed any spam that might occasionally turn up and made it an enjoyable place to spend my time.

I would encourage any .NET developers that aren’t currently using these forums as a resource to head on over there, sign-up and post something if you run into any issues.

Blogging.

I began this blog in late January and honestly didn’t really have any expectations for it at all so I have to admit that my little to no expectations were dramatically exceeded when I noticed that people were actually visiting the site. I honestly wish I could spend more time on here writing (and finishing) posts as a majority of them have been quite well received and even published and spread out on a few different sites across the internet, which is really cool.

When I initially started the blog I may have set a pace that wasn’t really realistic at 8 blog posts a month and I quickly realized that in April. I could feel myself getting burned out trying to think of new topics to cover and eventually building up some excess stress that I really didn’t need. So I took a break during the summer and have since relaxed the number of posts to a much lighter amount (2-3 per month), which I think is a maintainable target to shoot for.

Speaking of numbers, let’s take a look at some of the statistics for the site since its inception :

• Visitors since launch : 78,032 (averaging ~239 per day)
• Views since Launch : 124,962 (averaging ~338 per day)
• Total Posts since Launch : 43

Month-by-month Traffic Breakdown.

The blog has been extremely popular and has received far more traffic than I would have imagined. Many of the articles that I have posted on the site have been published and spread across the web on sites like CodeProject, Reddit and have been used within several other areas such as resource guides and magazines.

Since many of these blog posts often contain practical code and examples, I have made an effort to upload them to sites like github so that the open-source community can use them to help solve many of the problems that they have may have encountered in the past (or possibly in the future). Blogging has opened up many doors with regards to additional community involvement and I have been extended invitations for speaking events and presentations, online mentoring, guest authoring and beta testing new components and releases within the realm of .NET.

Thanks everyone that has stopped by and those of you that are reading this now, I want you to know that I appreciate you taking the time to do so.

Stack Overflow.

I honestly thought when I dedicated this year to community contribution, the first site that came to mind would be Stack Overflow. It is without a doubt the largest development-oriented Q&A site on the web and it is usually where just about every question has an answer. But surprisingly, I haven’t really done much there this year apart from moderation duties as I have found the community there to often be quite aggressive and cutthroat when it comes to “rep”.

I’ve spent most of my time on the site doing this that help the community without actually posting answers. Since I currently have enough privileges there already, I tend to spend any idle time editing posts, approving edits, flagging posts and other related topics. I would encourage any users out there that have these abilities to use them as a site the magnitude of SO has a huge need for helping hands when it comes to these duties.

Real-world Contributions.

This year I have taken part in several personal development-related community projects. I was invited and currently serve on a Computer Science Advisory Board at a small public university to discuss the importance of many of Microsoft’s technologies and their practical uses outside of academia (with regards to future employment and usefulness).

I have also taken part in a variety of private mentoring sessions for younger / junior developers and recent graduates to learn the ins-and-outs of C# and the .NET environment in general. These sessions have included both one-on-one mentoring and tutoring as well as group presentations.

Previously Set Goals and Results.

In late March, I threw together another blog post that detailed some goals that I had set for myself that I thought were fairly ambitious, so since the year is basically over. Let’s see how each of the goals compare to the actual results :

• Goal : 50,000 + Points and 7,500+ Posts on the ASP.NET Forums
  Result : 61,056 Points and 9,117 Posts

• Goal : 4,000+ Questions Answered on the ASP.NET Forums
  Result : 4,223 Questions Answered

• Goal : 20,000+ Reputation on Stack Overflow
  Result : 18,830 Reputation (I’m not too disappointed about this one)

• Goal : 40+ Blog Posts
  Result : 43 Blog Posts (and 14 drafts)

• Goal : 15,000+ Blog Visits
  Result : 124,962 Visits (I undershot this one by a mile)

Overall, 4 out of 5 isn’t too shabby.

What I learned.

Since I have a News Year’s Eve party to get to, I’ll keep this succinct and go with some bullet points :

• Contribute even if you think you can’t. Experience is unique and two people rarely share the same experience or tackle a problem the same way. If you find a situation that someone encounters and is having difficulty with, consider sharing how you tackled or solved the problem. It can work wonders.
• Teaching is a great way to learn. I can’t express how many things I have learned by helping others throughout this year. I know that I am a much stronger developer than I was at the beginning of this year and I would attribute much of that to the dedication that I have put into teaching others and learning along the way.
• Helping others helps you. Since contributing in all of these different ways, countless doors have been opened for me. Speaking engagements, interviews, guest contributions, job opportunities and much, much more. I would highly recommend taking the leap and giving back if you get a chance, I can just about promise that you’ll get a return on your investment in one way or another.
• Keep your e-mail Address private. Although I put this here in jest, I can’t tell you how many e-mails I get per day of folks asking questions outside of the forums and other areas. It’s not that I mind, but it was a little unexpected to see 20+ emails when I wake up and they are all from users asking for help.

Thanks again everyone for giving me something to strive for over the past year and thanks again for visiting.

It’s always nice to be using the latest and greatest of things, however not everyone really enjoys “change” (especially with regard to their development environments).

So this quick article will cover how to go about creating and using ASP.NET MVC5 applications within Visual Studio 2012 for those out there that want to keep up with the newest version of their favorite development technology but may not have the courage (or the cash) to upgrade to Visual Studio 2013.

Visual Studio 2012 by default will not offer you the option to create an MVC5 Web Application.

In November of this year, the .NET team released the ASP.NET and Web Tools 2013.1 Update for Visual Studio 2012. I wish I could say the steps necessary to integrate MVC5 into Visual Studio 2012 were more complicated than simply downloading this, but they aren’t.

You can download the update itself from the link provided below :

• Download the ASP.NET and Web Tools 2013.1 Update for Visual Studio 2012 here!

You’ll find that after installing the update and restarting Visual Studio 2012 that you’ll be able to create a new ASP.NET MVC5 application through Visual Studio 2012 :

After installing the update, you’ll see that MVC5 is now available in Visual Studio 2012.

Great! What else?

The update not only provides the necessary foundation for creating MVC5 applications, but it features the following additional improvements as well :

• Bootstrap Integration – All MVC5 applications and application templates by default will have their markup “bootstrap-ified” using Twitter Bootstrap (which is integrated into the applications by default).
• Web API 2 Templates – The latest version of Web API template isn’t going to be left out either. You’ll be able to create new Web API services just like MVC5 applications.
• Entity Framework 6 – Entity Framework 6 will be installed and included within this update and will be used for all of the scaffolding operations in Web API or MVC5.
• Improved Scaffolding – This improved scaffolding functions as a code generation framework for ASP.NET Web applications. It makes it easy to add boilerplate code to your project that interacts with a data model and will ensure that any items added through scaffolding will have all of the necessary dependencies (packages, references, etc.).
• Razor Editor Improvements – You’ll find that the toolkit has a variety of improvements and supports the Razor 3 engine.
• New NuGet – This update also includes the latest version of NuGet 2.7, which removes some of the need for manually restoring packages that go missing and also ensuring that all of your packages are up to date.

So if you are a bit hesitant to give Visual Studio 2013 a try, but you want to play around with some of the newer features and development templates that it provides, I would recommend downloading and checking out this update.