Blog

Reviewing Scrumban the Book

Fri, 27 Jan 2012 21:25:38 GMT

I’ve been reading a bunch of kanban and lean books recently as I work on my Pluralsight course on Introducing Kanban (not published yet – will link to it when it is). The most recent one I’ve finished is Scrumban, Essays on Kanban Systems for Lean Software Development, by Corey Ladas (I’m doing the reviews in LIFO order). I made a bunch of notes while reading this book, and it has a great deal of useful information. I read David Anderson’s Kanban book first, followed by Benson and Barry’s Personal Kanban. I think reading Scrumban last was definitely the right choice, though if I were recommending these books today I would most likely suggest someone start with Personal Kanban, as it’s the lightest weight of the three.

One thing that sets Scrumban apart from the other books is the narrative style and organization of the book. As it says in the title’s byline, this book is a collection of essays – there isn’t a great deal of cohesion or a consistent narrative guiding you through the book. It also tends to assume a fair bit of of knowledge on the part of the reader, which is one reason why I wouldn’t start off with this book if you’re just starting to learn about kanban and lean software development. I also don’t think the title is particularly fitting, since there is only one essay that deals with scrum and mentions the term scrumban in the whole book. I have a feeling the title was chosen mainly because it was short and would leverage the popularity of scrum to drive up book sales – whether this was the case or was successful I can’t say.

I found a great deal of value in the book, and it is certainly no rehash of the other two kanban titles listed above. There are some very important, basic concepts covered here such as the analogy of kanban tokens to money in one of the first essays. Corey does a great job of examining multiple different approaches to processes and showing their pros and cons. Things like methods for synchronizing different handoffs between related up- and downstream collaborators in a process are explained clearly and are honestly things I’d never given much thought previously. The book also does a great job of reinforcing the notion that time-boxed iterations are a stepping stone to an even more streamlined process. If you’ve ever considered the logical progression of moving from infrequent software builds, to having a daily build, to having continuous integration, you can see the same logic being applied to moving from large project phases and handoffs (e.g. waterfall) to many smaller and iterative iterations (sprints), to continuous software delivery and one piece flow (ideal).

One criticism I do have of the book is that it often didn’t define new terms and acronyms as they were introduced. I noted a bunch of them:

There were probably more that I missed because I was already familiar with the term, and of course it’s possible some of these were covered somewhere in the book and I missed them, but these were my “google these later” notes. The links above are the result of my google-fu after-the-fact.

The latter 2/3 of the book shows a bunch of different ways to model processes using task boards, and the effects of each of these designs. The analysis from these areas of the book are easily worth the price of the whole book, considering how much time they’ll save you if you’re just getting started. The book doesn’t propose one right way to go about implementing such systems, but it does a very good job of showing the pros and cons of a number of approaches.

Overall, I thought the book had some great information, but could have been organized better. I would give it 3 or 4 stars on Amazon and would recommend other books first, but if you’ve read the others and still want to learn more, there’s some great information here.

Updating Blog to Orchard and Switching Domains

Thu, 26 Jan 2012 20:43:53 GMT

So, yesterday I posted a review of the new Asus Ultrabook and, as has become rather predictable lately, the virtual web server hosting my Graffiti-powered blog started having 100% CPU for quite a while after the post went live. Now, I don’t get *that* much traffic, but apparently something with my configuration of Graffiti, the server, and the traffic that I do get is enough for it to bring that server to its knees. And Graffiti, great though it was years ago, just had to go.

I opted to go with Orchard for several reasons. I’d been on the fence between Orchard and WordPress, but after using WordPress for some other one-off projects over the last 18 months, I’ve grown disenchanted with it. While I did find that it was very cheap to find hosting for WordPress, I also found that these cheaper hosts were (shockingly) not as responsive as I was used to, and also since WordPress is to blogging as Windows has been to PCs, it also is the target of loads of automated hacks, and it didn’t take long before the WordPress accounts I had set up on these shared hosts were compromised. After cleaning them up multiple times only to have the problems recur, I decided I’d just avoid the whole problem by using Orchard (the blogging equivalent of buying a Mac). I’m hosting my new blog with Cytanium.com, which is run by the same awesome folks who run ORCSWEB hosting, but is set up better for a personal site like this.

Orchard is incredibly easy to get set up, has loads of extensions, and also happens to use the platform, language, and design approach that I prefer (in this case, .NET, C#, and MVC). There’s a great introductory course on Pluralsight (intro module is free) by my fellow NimblePros employee Kevin Kuebler, too, if you’d like some help getting started. Migrating to Orchard was fairly straightforward. I used John Papa’s blog series on migrating from Graffiti to Orchard as my primary guide, and it was a huge help. The data migration involved pulling the data out of Graffiti into BlogML, and then sucking in the BlogML back into Orchard. I cleaned up the code for doing this a bit, though the comments are still all wrapped in <p>…</p>, so use John’s script to fix that. The latest version of the GraffitiToBlogML code should be here.

I’m hoping to get Disqus set up for my comments soon (using this tool to import from BlogML to WXR), as well as to migrate my old blog data from AspAdvice.com, ArmyAdvice.com, and asp.net/blogs, so that all of my blogging for the last decade can all live here. And hopefully this new account will perform better than the old one – I know I was losing visitors who came to my old site and found it unresponsive and left. If you’re reading this, thanks for sticking with me! :)

About Steve

Wed, 25 Jan 2012 23:13:46 GMT

Hi, I'm Steve Smith. I go by Ardalis online because, well, you'd understand if your name was Steve Smith.

This is now the fifth place I've had a blog, if you don't count my initial home page and articles on ASPAlliance.com, which were somewhat blog-like but preceded the term. Unlike my past blog moves (from the ASP.NET/blogs site to AspAdvice.com/blogs and my ArmySteve.com / ArmyAdvice.com/blogs/ArmySteve blogs, and then from there to SteveSmithBlog.com), this time I'm pulling everything into one place. So far I only have the most recent stuff here, but soon you should see content dating back to 10 years ago, all in one easy to find location.

If you're here, you've found my blog. You may also wish to stalk me via other means:

Here's some more info on me, which is slightly outdated at the moment (Jan 2012).

Steve Smith is currently a Senior Architect with The Code Project and CTO of Lake Quincy Media, which he co-founded in 2005. He also founded and continues to run ASPAlliance.com, a popular resource for Microsoft programmers. He is a Microsoft Regional Director, an ASP.NET MVP (profile), an INETA Speaker, and an ASPInsider. He's written or contributed to several books on ASP.NET and related topics and is a frequent speaker at industry conferences such as DevConnections and TechEd. Steve also founded and organizes the Hudson Software Craftsmanship group in Hudson, Ohio, where he and his wife Michelle also own office space and she manages their agile consulting company, NimblePros.com.

Steve is a US Army veteran who served in Iraq as a combat engineer platoon leader tasked with finding and destroying unexploded ordnance and clearing IEDs. He received his honorable discharge as an army Captain in 2005 and is now happy to be 100% a civilian.

Steve lives in Ohio with his wife and business partner Michelle, their daughter Ilyana, and son Nikita. When he's not trying to keep up with his business or technology, Steve enjoys games, bicycling, and karate.

History

In January 2012 I moved my blog from SteveSmithBlog.com to Ardalis.com, which is shorter, more memorable, and lines up with my twitter alias.

In July 2008 I moved my blog from AspAdvice.com/blogs/ssmith to my own domain, SteveSmithBlog.com. I'm keeping all the old content at the old blog, as well as my previous Army blog that I kept while I was in Iraq in 2004.

Asus Zen Ultrabook First Impressions

Wed, 25 Jan 2012 09:18:11 GMT

Last week a received a new Asus UX31E Zenbook Ultrabook laptop computer, which I’ve been putting through the paces. I’d like to write up my thoughts on the unboxing and my initial impression of the machine, and I’ll write more in a few weeks once I’ve had some more time to use it. Overall, I really like it so far. It’s thin, light, shiny, and feels solidly put together. It’s also extremely fast to start up and has a very reasonable active use battery life and a better sleep/standby battery life than any laptop I’ve ever owned.

Unboxing

I got my Asus Zenbook Ultrabook on Amazon, so of course it came in an Amazon box. Inside the Amazon box was the Asus box:

And inside the Asus shipping box is the actual Zenbook packaging:

After removing a bit of shrink wrap, this box opens to reveal the Zenbook and its accessories:

After a bit of unpacking and cleaning up some of the Russian nesting doll style boxes, the components look like this:

The laptop is incredibly thin. Here it is compared to a thin Bic pen on my desk:

It comes with a magnetic clasp carrying sleeve, which I really like. It’s handy to slide the Zenbook in and out of, and it has a nice texture and feel to it, in addition to feeling pretty durable (though it’s too early to say how well it holds up to real usage). Because it’s so thin, the Zenbook doesn’t have ports for Ethernet and VGA, opting instead to support only thinner ports like USB and micro-HDMI. It comes with a small accessory bag and two adapters:

A USB to Ethernet/RJ-45 adapter
A micro-HDMI to VGA adapter

I do have two small complaints about the accessories. Firstly, I wish it came with an HDMI adapter, since our office projector supports HDMI. That said, I wouldn’t want to give up the VGA adapter, since that’s still the universal standard for projectors everywhere. Secondly, the accessory bag, while compact and stylishly a match for the larger Zenbook sleeve, does not actually fit into the sleeve. Likewise, the power adapter certainly doesn’t fit into the sleeve, so you’ll certainly still need some kind of proper laptop bag or backpack to hold these things. It would have been nice if the sleeve somehow could be just as slick and portable as it is now while still somehow being able to hold the adapters and/or the accessory bag, but I suspect those two desires are simply incompatible with real-world space constraints.

To support standard HDMI output from the Zenbook, I’ll most likely pick up one of these HDMI Female to Micro HDMI Mail Adapters for under $3.

The front and back of the Zenbook are very simple. The smooth finish is great to look at and has a nice, slick feel to it. The sleeve, again, is a nice addition to the package, as I’m sure it will protect the Zenbook from fingerprints and accidentally slipping from my fingers in transit.

The power adapter is light and the connector the the Zenbook itself is tiny. I think it’s smaller than a standard 3.5mm headphone jack, though I haven’t measured it or tried to plug my headphones into the power port of the laptop (yet). I certainly appreciate having a light power supply, since I’ve had laptops in the past with power bricks that weighed (literally) more than the Zenbook itself (I’m looking at you, Alienware).

Once you open up the machine, it has a nice-sized screen, a huge trackpad, built-in speakers on the inside of the screen’s hinge, a webcam, and the same smooth metal finish found on the outside case.

Starting For The First Time

The Zenbook comes with Windows 7 Home Premium 64-bit. It also has the Bing Bar installed automatically, but this is the only “crapware” that seems to come preinstalled on the device. I left the Bing Bar running for almost a day before it annoyed me enough to remove it (I did try to give it a fair chance).

Once you’ve started, you’ll see some information about Instant On, which theoretically is a unique Asus technology that saves power and speeds boot time for the computer. I turned it on and the default desktop widget that displays expected Standby Time doubled as a result.

Asus also has an automatic update service running, which is set up nearly identically to Windows Update. You’ll want to make sure you get the latest drivers via Asus Update, as I have heard of others having issues that were resolved by these updates. One common issue I’ve seen relates to the trackpad. It’s different from others I’ve used, as it is both more sensitive to touch and by default somewhat slower (in terms of how fast the mouse pointer moves on the screen based on how far you move your finger – adjustable in Windows). The left and right “buttons” are actually just regions on the touchpad, too, and so occasionally I’ve accidentally dragged things as I was trying to click. These are I’m sure just things I need to get used to. I’ve also read others’ complaints about the keyboard. It, too, is different from most laptop keyboards I’ve used, but I haven’t had any problems with it, and I’m a relatively fast touch typist. It requires some getting used to, just like riding a new and unfamiliar bicycle, but once you’re acclimated to it, it’s fine in my so far limited experience.

The one other oddity I noticed so far is that the power button is placed where the Delete button usually goes (and the delete key is just to the left of the power key). I almost, once, hit the power button while going for the delete key. I’m pretty sure it just would have gone to sleep (which it does quite quickly) and I’d have simply had to wake it back up (also very quick), but I caught myself and have had no issue with remembering where the del key is since.

Disclosure of Material Connection: I received one or more of the products or services mentioned above for free in the hope that I would mention it on my blog. Regardless, I only recommend products or services I use personally and believe my readers will enjoy. I am disclosing this in accordance with the Federal Trade Commission’s 16 CFR, Part 255: “Guides Concerning the Use of Endorsements and Testimonials in Advertising.”

Here’s another review of the Zenbook on CNET you may find interesting if you read this far. I agree with their sentiment, “who doesn't want a thin, unibody metal lightweight laptop that starts fast and has a great battery life?”

Run Your Unit Tests in Parallel to Maximize Performance

Thu, 19 Jan 2012 02:05:09 GMT

If you’re at all serious about testing, at some point you’re going to have a rather large suite of tests that need to run, and you’ll find that your builds are taking longer than you would like because of how long the tests run. For example, consider this suite of 24 tests, each one of which looks like this one:

If you run 24 of these, it’s going to take about 24 seconds, by default:

Now of course it’s important to keep your unit tests and integration tests separate and to know which is which, but even once you’ve done that, anything you can do to speed up your test execution times is going to be a big help to your productivity. Slow builds due to slow tests kill productivity:

One simple way you can speed up your tests is to run them in parallel. Doing so with MSTest is actually extremely easy to do, although it’s not at all obvious how to do it, since the setting you need to adjust is hidden away and has no user interface exposed. The really cool thing is that, after you make the change, even if you don’t use the Visual Studio built-in test runner, your tests will run in parallel.

Enabling Parallel Testing in MSTest

Like most of the settings used by MSTest, the setting you need to tweak to enable parallel unit test execution is in the .testsettings file that you’re using. In a brand new test project, you should have a Local.testsettings file, like this one:

If you open this file and click through the various settings boxes, you won’t find anything there related to test parallization. Go ahead and look. Ok, satisfied now? Good, let’s move on.

Now, if you right-click on the file and open it with an XML Editor, you’ll find some more interesting settings.

Here’s the default XML file:

If you go click on the <Execution> element, and attempt to add an attribute to it, you should get some Intellisense/statement completion, showing you what the acceptable attributes are:

In this case, the option you want is parallelTestCount. If you simply set it to 0, the system will automatically choose a number of parallel tests equal to the number of cores detected on your system. In my case, I have a 4-core machine, so it will use 4 cores. Save the file.

Note: Typically at this point if you re-run your tests, they will continue to run one-at-a-time. The .testsettings files are cached and are not read immediately when you make changes to them. I’ve had success getting them to update by going to the Test View window and hitting the Refresh button there, but if that fails you could simply try closing Visual Studio and re-opening it and your project.

Run your tests again. Here’s a screenshot showing them running in the Visual Studio test runner. You can see there are 4 tests In Progress at the same time:

Of course, you can also set the value to a number that exceeds the number of (apparent) cores on your system. I’ve gotten it to work with as many as 16 on one machine, but on the one I’m working on now, it fails once it exceeds 5 cores. According to a friend of mine, there is a hotfix available that fixes this bug and allows VS2008/VS2010 to use this setting with a parallelTestCount > 5, and apparently this already works in some environments without this hotfix (such as my laptop). Likewise, I was able to run tests in parallel using ReSharper’s test runner on my laptop, but on this desktop machine running the latest 6.1 version of R# it is only running one test at a time.

Nonetheless, if you set the value to 5 and run my suite of 24 1s tests, the entire suite executes in about 5 seconds. That’s an 80% reduction in total test time, which is pretty amazing, and of course this number gets even bigger if you make it larger (assuming you have the hardware to support it).

Caveats

You need to be using MSTest. This doesn’t work with NUnit.

You may need to be using the Visual Studio built-in test runner. I had it working with the ReSharper test runner, but it’s not working now on this machine, so YMMV.

You may not be able to exceed <Execution parallelTestCount="5">. If you need to do so, contact Microsoft support for the hotfix. If it’s a publicly available link, please link to it in the comments below.

Your tests should be thread-safe and side effect free. This rules out most integration tests (what’s the difference between unit tests and integration tests?). You also need to be very careful about any use of global state. Here’s simple example of a test suite that passes when run sequentially but fails when run in parallel (click to open in new window):

Summary

Especially as CPUs continue to ship with greater and greater numbers of cores, rather than faster clock speeds, the ability to take advantage of the potential performance of these systems will depend on our ability to perform operations in parallel. One area in which MSTest currently has the lead on alternatives like NUnit is in parallel test execution, and I hope that the next version of Visual Studio improves upon this feature and makes it more discoverable and addresses some of the current issues it suffers from. I have confirmed that the XML attribute and test runner behavior in the Visual Studio 11 CTP distributed at the BUILD conference in September 2011 work just as they do today in VS2010.

You can view and download the sample code from its BitBucket Mercurial Repository here.

Unit Test or Integration Test and Why You Should Care

Thu, 19 Jan 2012 00:37:06 GMT

There remains a fair bit of confusion about what constitutes which kind of test. Many developers are fairly new to testing, and tend to call any tests of their code “unit tests” even when they’re dealing with something substantially larger than a unit. The tools don’t really help much here, since the various test runner frameworks all call themselves unit test frameworks, and the various test runners themselves almost universally refer to the tests they run as “unit tests” whether they are or not. For instance, Visual Studio 2010 starts every new Test Project with a class called UnitTest1 and lets you add a new Unit Test, but nowhere does it mention Integration Tests, Acceptance Tests, Smoke Tests, etc, as you use the same code templates to create each of these.

Visual Studio 2010

ReSharper and most other add-in test runners follow the same convention – if you ran run it as a test on your code, it’s probably going to be referred to as a Unit Test.

ReSharper 6.1

So what constitutes a unit test, and what constitutes an integration test? What about other kinds of tests beyond these two? There’s a decent StackOverflow answer related to this topic, which lists several kinds of tests and their definitions. Here is what it has to say about Unit Tests and Integration Tests, specifically:

Unit test: Specify and test one point of the contract of single method of a class. This should have a very narrow and well defined scope. Complex dependencies and interactions to the outside world are stubbed or mocked.
Integration test: Test the correct inter-operation of multiple subsystems. There is whole spectrum there, from testing integration between two classes, to testing integration with the production environment.

I have my own definition of a unit test, which is that it’s a test that only tests a single path through a single method. More importantly, it’s a test that has zero dependencies on infrastructure, or on code outside of your control. Unit tests should run fast – as in very, very fast – because they aren’t touching file systems, databases, networks, email servers, system clocks, etc. They run your code. Period. If you have code that has dependencies, you need to remove them when running your unit tests, typically by using mocks, fakes, or stubs. I’ve written before about dependencies, if you’re not sure what I mean:

If you have a test that depends on any of the dependencies listed in the above posts, then you have an integration test. Integration tests are great and necessary, but they’re generally at least an order of magnitude slower than unit tests, and as such you’re going to be able to run far fewer of them in a given amount of time. Therefore, you want to write as many unit tests as you can, and write integration tests for things unit tests can’t do (like actually testing your infrastructure and interactions between components). Basically, you want to follow the Test Pyramid, just like in the United States people are encouraged to eat based on the Food Pyramid (with one key difference being that the Test Pyramid is probably better advice and is less controversial).

Basically, you want a lot more servings of Unit Tests in your daily diet than Integration Tests, and remember that UI tests, being the most expensive and usually the most brittle, are a sometimes food.

How Can You Tell if a Test is a Unit Test or an Integration Test?

Here are some quick questions you can use to qualify your tests. There may be some exceptions to these rules, but these are generally good guidelines. It’s usually a good idea to separate your unit and integration tests, either as separate projects/assemblies, or at least using separate categories, so that you can run them separately. You’ll want to run the unit tests all the time, and they should be fast enough that doing so isn’t too painful. You’ll want to run the integration tests as often as you can bear to do so, but often these take long enough to run that you don’t want to run them with every compile or before every check-in.

Q: Does the System Under Test (SUT) require an installed and configured and available database in order to run the test successfully?

A: If yes, then it’s an Integration Test

Q: Does the SUT talk to the file system?

A: If yes, then it’s an Integration Test

Q: Does the SUT reference configuration files directly?

A: See previous question. It’s an Integration Test.

Q: Does the SUT reference a service over the network?

A: If yes, then it’s an Integration Test

Q: Does the test take more than 10ms to execute?

A: If yes, it’s very likely an Integration Test, or at the very least it may be possible to refactor it to run faster.

Q: Does the SUT send emails as part of the test execution, even via a local SMTP server like smtp4dev?

A: If yes, then it’s an Integration Test.

Q: Does the SUT depend on the system clock? Are there certain days of the week or times of day when it would behave differently?

A: If yes, then it’s an Integration Test.

Q: Does the test make use of a mocking framework?

A: If yes, then it’s likely a Unit Test. Generally you shouldn’t need to mock much in your integration tests, or you risk not actually testing your system.

References

MSDN describes Unit Testing and Integration Testing if you’d like an “official” Microsoft source

“What is Unit Test, Integration Test, Smoke test, Regression Test?”

“What are unit testing and integration testing, and what other types of testing should I know about?”

CodeMash 2012 Sessions

Mon, 16 Jan 2012 15:23:53 GMT

Last week I presented two half-day workshops at CodeMash’s PreCompiler on Wednesday (with Brendan Enrick), and a session on ASP.NET MVC 4 on Thursday. CodeMash 2012 was an amazing conference and I’d like to personally thank the organizers as well as the attendees of my own events for making it such a great event. I’ll post a separate write-up with my experiences shortly – for now I just need to get my slides and demos posted for folks who want them.

Beginning Software Craftsmanship

The morning PreCompiler was on Beginning Software Craftsmanship, and included some presentations on software craftsmanship, deliberate practice, testing, and pairing. We had about 25 people in attendance, which was just about perfect for the room we had. Unfortunately, we had a tiny little 6’ screen to present on, but we made it work and thankfully most of this workshop involves hands-on coding, not watching slides. The group worked through the Prime Factors kata several times, and then the String Calculator kata. You can download the Beginning Software Craftsmanship slides, katas, and the FizzBuzz demo that Brendan and I worked through here.

Intermediate Software Craftsmanship

In the afternoon PreCompiler, we continued delving into software craftsmanship and practice, with an emphasis on writing quality code. There was a quick repeat presentation on why software craftsmanship and practice are important, which was good since the afternoon session was standing room only with over 50 people in it at one point, so there were many new faces in addition to folks from the morning session. Brendan and I presented one lecture on refactoring and SOLID principles to set up the next kata, the Gilded Rose refactoring kata. This kata starts with some existing working code, which we provided in several different languages from online sources:

The intent of this kata is to practice your refactoring skills, and also to practice working with legacy code that has no test coverage and is in fact very difficult to get under test. Working in pairs, the teams sought to implement the new feature requested in the kata while following the constraints and attempting to improve the overall design of the code (by, for instance, making it more DRY and applying the SOLID principles).

Following the Gilded Rose kata, we worked through the Greed kata, which implements the rules of a simple dice game. Included in the download below are several implementations of this kata in C#, including one that uses a rules engine that allows new rules to be added while following the Open/Closed Principle (no changes need to be made to the scoring logic classes).

Download the Intermediate Software Craftsmanship slides, katas, and demos here.

A Lap Around ASP.NET MVC 4

On Thursday I gave a morning session on ASP.NET MVC 4. Unfortunately, I wasn’t able to talk about some of the new features that were under development due to NDA restrictions. However, that kind of changed about 30 minutes before my talk when Scott Hanselman announced several of the previously private features that were coming to MVC 4, namely integration of Web API directly into MVC and a few new project templates, including a single-page application template. Look for more info on these topics on Scott’s blog and/or from the Gu himself, soon.

My session focused on the new mobile features, recipes, and async features of MVC 4. You can find my Lap Around ASP.NET MVC 4 slides and demos here.

Hope you enjoyed CodeMash and I look forward to seeing you again soon. Feel free to follow me on twitter (@ardalis) to join the conversation!

Silverlight 5

Fri, 09 Dec 2011 15:00:16 GMT

“The reports of my death have been greatly exaggerated.” – Mark Twain

Today, Silverlight 5 is released and available for download! The Release Candidate has been around for some time, and many of us were expecting the release in November. Well, here it is, November 39th, and it’s here! Here are some of the things that are New or Improved in Silverlight 5:

Binding Improvements, including ICustomTypeProvider, Binding in Style Setters, DataContextChanged Event, and Custom Markup Extensions
Support for the XNA 3D API for 3D graphics

3D Render Targets
3D surface composition settings
3D multi-sample anti-aliasing

Other improvements to the Graphics Stack
Hardware decoding for H.264 media
Low-latency sound effects (good for games)
Variable Speed Playback and Trick-play (great if you want to listen to podcasts at high speed)
Text Improvements

Text Tracking and Leading
Linked and Multi-column Text
OpenType Support

Better OS integration

P/Invoke support
Multiple Window support
Full file system access (in full trust)
Default Filename support in Open/Save FileDialogs
64-bit browser support in Windows
Power awareness (don’t sleep while movie is playing, for instance)

Performance Improvements

Faster Parser
Multi-Core JIT compilation (improved start-up time)

Double-Click (and n-click) support
PivotViewer control
ComboBox type-ahead search
Printing improvements
Tasks from Task Parallel Library

Pete Brown has a great write-up of these and more features. There is another, official list of What’s New in Silverlight 5 available on the Silverlight.net site. You can learn more at http://silverlight.net/learn, or from Pete’s book, Silverlight 5 in Action.

Handy EnumerableExtensions

Thu, 10 Nov 2011 15:50:32 GMT

There’s a great site for finding extension methods, ExtensionMethod.net. I don’t believe either of these came from there, and I’ve not (yet) submitted them there, but here are a couple of extensions on IEnumerable<T> that I’ve found useful recently.

ForEach<T>

The first one is simply a method that allows you to easily iterate over a sequence and perform an action on it. This is a pretty commonly useful extension method, so much so that it’s now included in .NET 4.0 out of the box. But if you’re using an older version of the framework, this is one you can roll yourself.

public static void ForEach<T>(this IEnumerable<T> items, Action<T> action)

    foreach (T item in items)

        action(item);

ContainsAny<T>

If you have a collection, you can test for whether it contains an item by using the .Contains(T item) extension method. However, this only works for single instances of an item. What if you have a set of items and you need to know if that set contains any elements of a second set of items? For that, you want to use ContainsAny(), which you can use with either a params collection (specify each item inline) or with an enumerable parameter. Here are the methods:

public static bool ContainsAny<T>(this IEnumerable<T> sequence, params T[] matches)

    return matches.Any(value => sequence.Contains(value));

public static bool ContainsAny<T>(this IEnumerable<T> sequence, IEnumerable<T> matches)

    return matches.Any(value => sequence.Contains(value));

And here are some passing unit tests that demonstrate how these are used:

[TestFixture]

public class ContainsAnyShould

    [Test]

    public void ReturnTrueGivenMatchInItemCollection()

        var testList = new List<string>() { "A", "B", "C" };

        var filterList = new List<string>() { "C", "D", "E" };

        Assert.IsTrue(testList.ContainsAny(filterList));

    [Test]

    public void ReturnFalseGivenNoMatchInItemCollection()

        var testList = new List<string>() { "A", "B", "C" };

        var filterList = new List<string>() { "D", "E" };

        Assert.IsFalse(testList.ContainsAny(filterList));

    [Test]

    public void ReturnTrueGivenMatchInParamCollection()

        var testList = new List<string>() { "A", "B", "C" };

        Assert.IsTrue(testList.ContainsAny("C", "D", "E"));

    [Test]

    public void ReturnFalseGivenNoMatchInParamCollection()

        var testList = new List<string>() { "A", "B", "C" };

        Assert.IsFalse(testList.ContainsAny("D", "E"));

Hope these help!

View HTML Source of Email in GMail and Google Apps

Thu, 10 Nov 2011 09:54:06 GMT

If you’re working on creating a pleasant-looking HTML email template for your site’s newsletter, you’ll want to test it out on the major email clients, including Outlook and GMail. For instance, if you get The Code Project’s Insider Daily News in your GMail inbox, it will look something like this:

Now, if you view the source for this page, you’ll get something that’s less than useful. The whole thing looks like a giant <script> block and has no relation to the HTML that was in your email template. Of course, the interface uses frames (iframes), and depending on your browser you can also view the frame source:

Which will yield this:

How useful!

If you *actually* want to see the HTML markup for an email as it was received by the mail server, the way to do that in GMail or Google Apps is to click the triangle icon in the upper right of the message, and select Show Original:

This will open up a new browser window or tab, with the full email content, including the headers. Something like this, perhaps:

All that and *still* no HTML! But we’re almost there. If you look at the last line of the headers in the image above, you can see that in this case the message says it has Content-Transfer-Encoding: base64. That means that long mess of characters in the body of the message is base64-encoded, which further means that we can easily decode it using any base64 decoder. You can write your own, but there are numerous online tools that will decode base64 for you, including this one I found after a quick search. Simply cut and paste everything below (but not including) the Content-Transfer-Encoding: base64 line into the box on the page and click the button and you should see your decoded, beautiful, actual HTML of your email message. What could be easier than that?

Now just copy the output to Notepad or your HTML editor of choice and you should be ready to make whatever tweaks you and your design team would like.

Inner Fields and Lazy Initialization in C#

Sat, 29 Oct 2011 12:07:46 GMT

Using lazy initialization in C#, a class’s state is set up such that each property’s get method performs a check to see if the underlying field is null. If it is, then it calculates or populates the field before returning it. This is a very simple and common approach, but it requires that the class follows a convention of only accessing the field via the property. Unfortunately, there are no language features that can enforce this, so it’s possible for errors to creep in. Here’s an example of this approach working correctly:

public class Order

    // other properties

    private Customer _customer;

    public Customer Customer

get

            if (_customer == null)

                _customer = new Customer();

            return _customer;

    public string PrintLabel()

        return Customer.CompanyName + "\n" + Customer.Address;

Now here’s where this approach can break down. Consider the same class as above, but with a rewritten PrintLabel() method:

public string PrintLabel()

  return _customer.CompanyName + "\n" + _customer.Address;

This code will still compile just fine, but now will very likely result in a NullReferenceException when it attempts to access properties of the _customer, which may not yet be initialized. The solution to this would be to control access to the _customer member. We’ve already set its access to private, though, which is as restrictive as we can make it. We could force it to be initialized by moving the work into the class’s constructor, but then we’re losing the benefits of lazy initialization. I wonder if it wouldn’t be useful to do something like this instead:

public class Order

    // other properties

    private Customer _customer;

    public Customer Customer

get

            if (_customer == null)

                _customer = new Customer();

            return _customer;

    public string PrintLabel()

        string result = _customer.CompanyName; // probably results in a NullReferenceException

        return result + "\n" + Customer.Address; // ok to access Customer

We already have auto-properties in C# that avoid the need for having backing fields in the default case. I think being able to protect access to backing fields so that they can be configured to only be accessible by their property would be quite useful in a number of cases, including this very common one. I also don’t believe this would break any existing code or change the language in a way that would make it less easy to understand. What do you think, is this something the C# team should consider adding in a future version of the language?

One approach that can be used with the relatively new Lazy<T> type is this one (thanks to Jose Romanie for pointing this out):

public class Order

    public Order()

        _customerInitializer = new Lazy<Customer>(() => new Customer());

    // other properties

    private Lazy<Customer> _customerInitializer;

    public Customer Customer

get

            return _customerInitializer.Value;

    public string PrintLabel()

        string result = Customer.CompanyName; // ok to access Customer

        return result + "\n" + _customerInitializer.Value.Address; // ok to access via .Value

I like this approach, and I’m generally a fan of Lazy<T>. It might eliminate the need for the private backing field idea for properties, as it does provide a means of enforcing the initialization even if the backing field is accessed from within the class. The only downside is that you need to work with a Lazy<T> instead of a T, but within the class it’s probably not a bad thing for this detail to be exposed. Thoughts?

RazorEngine Performance and Template Caching

Wed, 26 Oct 2011 17:09:36 GMT

I’ve been using RazorEngine on a project and have been impressed with its simplicity and ease-of-use. However, the performance of the application isn’t quite where I need it to be, and I was pretty sure the issue was with how I was using RazorEngine, especially since I could anecdotally see that the processor consumption on the machine running the app was quite high, and looking at the running tasks it was clear that most of that was a result of csc.exe (C# compiler) activity.

A bit of searching found this discussion thread on codeplex regarding the re-compiling of existing templates. The issue is a known one with version 2.1, which is the current release and what I’m using. However, I talked to Matthew Abbott (aka Antaris) via his blog where he recently discussed what’s coming in RazorEngine v3, and that led me to go ahead and pull the latest pre-release RazorEngine v3 code out of GitHub.

From there it was pretty trivial to get my code working with the new bits. Fortunately I’d created an interface ITemplateParser and implemented a RazorEngineTemplateParser, and this latter class was the only one I needed to change to use the new API. I created a couple of nearly identical unit tests, with the key difference being when they make the call to parse the template. The caching version provides the same name for the template with each call, while the non-caching one provides a new Guid string as the template name, ensuring a cache miss.

I don’t have any fancy graphs to show off, since all I did was run a 2-minute load test of each unit test with 5 users and no think time using Visual Studio 2010’s load test runner. The results were pretty significant, though, and corresponded with the performance I was seeing in my actual application (about 1 request per second on one thread):

5 Concurrent Users, Non-Cached

5 Tests/Second

5 Concurrent Users, Cached

1600 Tests/Second

Install Application as Service on Windows Server 2008

Tue, 25 Oct 2011 10:23:03 GMT

You can use the sc.exe command to install an EXE as a service on Windows Server 2008. There’s a good article on creating an application that can easily run as either a console app or as a service here. From an administrator command prompt, the syntax is something like this:

sc \\servername create MyService.ServiceName binpath= d:\services\Foo\Foo.exe displayname= MyService.ServiceName

Note that for this particular utility, the command line options include the “=” sign in them, so you must have no space before the “=” and you must have a space after the “=”. Also the server name must be preceded by \\ to work.

Assuming it works, you should see something like this:

As you can see from the help message above, the SC.EXE utility can be used for much more than simply creating services, but this is something I’ve had to use it for more than once (and hence I’m blogging it since it’s not necessarily easy to search for).

Using If This Then That to Automate Your Life

Mon, 24 Oct 2011 23:13:23 GMT

I’ve just started getting into If This Then That (ifttt.com) and have set up a simple task that will update my Steve Smith Facebook Page whenever I post something here to my blog. Getting this set up was extremely simple to do, and so far although I’ve only been using it for about an hour I’m quite impressed and enamored with ifttt.com. Here’s how easy it is to set up something like this:

1. Register with ifttt.com

This took 30 seconds.

2. Create a task

If this (the trigger):

Then (the action to take – create a new Link Post on my Facebook Page):

End Result:

This is actually the first post I’m making since adding this task, so if this post shows up on my Facebook Page then it worked.

Recipes

You don’t have to reinvent every wheel with If-This-Then-That. They support the notion of recipes, which are basically combinations of triggers and tasks that others have found useful and shared. For instance, right now the most popular recipe is one that will automatically save to a folder in DropBox every photo that someone tags you in on Facebook. Another popular one will automatically email you if the weather forecast calls for rain tomorrow (perhaps to say, “Don’t forget your umbrella!”). There are over five thousand recipes available so far, so it’s a good place to browse for ideas for how you might use If-This-Then-That to automate some of your life.

Do you have a favorite recipe or use for If-This-Then-That? Please let me know in the comments below.

Working with Lazy Loading in Entity Framework Code First

Sun, 02 Oct 2011 22:57:45 GMT

Entity Framework 4 has Lazy Loading built-in and enabled by default. Here’s a quick bit of code to show you how to work with this feature. To get started with this, simply create a new Console Application and in nuget (Package Manager Console), run this command:

install-package EntityFramework.Sample

This will install a simple blog post example. Copy and paste the following into your Program.cs file (replace everything):

     using System;

    using System.Collections.Generic;

    using System.Linq;

    using System.Text;

    using EFExample.Models;

    namespace EFExample

    {

        class Program

        {

            static void Main(string[] args)

            {

                var context = new BlogContext();

                Console.WriteLine("Default Lazy Loading setting is: " + context.Configuration.LazyLoadingEnabled);

                Console.WriteLine("Disabling Lazy Loading...");

                context.Configuration.LazyLoadingEnabled = false;

                // remove a post

                //context.Posts.Remove(context.Posts.First());

                //context.SaveChanges();

                // add a post

                //var newPost = new Post() { Title = "a test post", PublishDate = DateTime.Now, Comments = GetComments() };

                //context.Posts.Add(newPost);

                //context.SaveChanges();

                Console.WriteLine("Dependent Collection is Null with no Lazy Load, no Explicit Include");

                foreach (var post in context.Posts)

                {

                    Console.WriteLine(post.Title);

                    if (post.Comments != null)

                    {

                        foreach (var comment in post.Comments)

                        {

                            Console.WriteLine("  -" + comment.Text);

                        }

                    }

                }

                Console.WriteLine("".PadLeft(50, '-'));

                Console.WriteLine("With Explicit Include, It is Available (1 db call)");

                foreach (var post in context.Posts.Include("Comments"))

                {

                    Console.WriteLine(post.Title);

                    if (post.Comments != null)

                    {

                        foreach (var comment in post.Comments)

                        {

                            Console.WriteLine("  -" + comment.Text);

                        }

                    }

                }

                Console.WriteLine("".PadLeft(50, '-'));

                var anotherContext = new BlogContext();

                Console.WriteLine("With Lazy Loading On, It is Available But Populated Only On First Request");

                foreach (var post in anotherContext.Posts)

                {

                    Console.WriteLine(post.Title);

                    if (post.Comments != null)

                    {

                        foreach (var comment in post.Comments)

                        {

                            Console.WriteLine("  -" + comment.Text);

                        }

                    }

                }

                Console.ReadLine();

            }

            private static ICollection<Comment> GetComments()

            {

                var comments = new List<Comment>();

                for (int i = 0; i < 3; i++)

                {

                    comments.Add(new Comment() { Author = "author" + i, Text = "comment " + i });

                }

                return comments;

            }

        }

    }

I have three test cases shown here. If you run the program (after adding a post using the commented add a post code) you should see this output:

By default, Entity Framework 4 uses Lazy Loading. You can disable it with this code:

context.Configuration.LazyLoadingEnabled = false;

Once this is done, dependent collections like the Comments property of a Post in our example will be null if they are not specifically included. If you know you need to include a dependent collection or property, you can do so with the .Include() method when you reference the DbSet, like so:

foreach (var post in context.Posts.Include("Comments"))

With Lazy Loading enabled (again, the default case), there is no need to specify the Include if you’re OK with the fact that in this example 2 calls will be made to the database:

Call One (List Posts – click to enlarge)

Call Two (List Comments for single post)

Now, let’s say you want to disable lazy loading by default (i.e. you don’t want to have to remember to set the property every time you instantiate a context). This is quite simple if you’re using EF Code First and you have a DbContext like the BlogContext in this sample. Simply add a constructor and in the constructor disable Lazy Loading, like so:

    public class BlogContext : DbContext {

        public DbSet<Post> Posts { get; set; }

        public DbSet<Comment> Comments { get; set; }

        public BlogContext() : base()

        {

            this.Configuration.LazyLoadingEnabled = false;

        }

    }

That’s it! Now you know how to work with Lazy Loading in Entity Framework 4.

Analyzing Windows 8 and WinRT

Fri, 30 Sep 2011 15:06:33 GMT

Last week at BUILD, Microsoft introduced their vision for the next generation of Windows devices with announcements and previews of Windows 8, Metro style applications, and WinRT. The BUILD conference was the most secretive event I’ve ever known Microsoft to hold, with very few leaks prior to the keynotes that began on Tuesday, September 13th. Now that the event has come and gone, you can watch the sessions and keynote presentations for yourself here. In this post, I am going to offer my own analysis of the event and its announcements, with what I view as some of the strengths and weaknesses of Microsoft’s strategy, and the threats and opportunities it creates. I’m also going to provide links to a large number of related resources, and I welcome you to post links to your own reaction or others you’ve found insightful in the comments below. A good place to get started is the Building Windows 8 blog, if you haven’t looked there yet.

What Does Windows 8 Offer?

Some key messaging from Microsoft regarding Windows 8 are that it is a no-compromise operating system, and that one of the key elements of its design is to be “fast and fluid.” By no compromise, they mean you are not left with an OS that is only good as a tablet or only good on a desktop. You can install and use Windows 8 productively on your desktop system, and you can do so with a touch-friendly tablet or similar form factor. The experience when using the new start menu and Live Tiles is designed to be fast and fluid, and so far based on my usage of the developer preview device I received, it certainly accomplishes this. The new platform is built around supporting a new style of application development, dubbed Metro style applications. Jensen Harris, in an excellent session that should be required viewing for any developer considering building apps for Windows 8, describes the design principles behind these applications in his 8 Traits of Great Metro Style Apps talk last Tuesday.

Windows 8 will also offer new opportunities for developers and consumers in the form of a greatly improved application distribution model. There will be a new Windows Store built into Windows 8, where consumers will be able to find, download, purchase, and install new apps for their Windows 8 PCs. The store itself is not yet available, but the early versions of the tools needed to create the distributable packages are available to developers now. These apps will be verified by Microsoft, but developers will be able to run many verification and validation checks against their app locally, eliminating some frustration when submitting apps. Apps will also run in a sandboxed environment, with increased security compared with standard Win32 applications today.

For some time, Windows has had a desktop that in my opinion has been largely underutilized. It’s a place to put some pretty pictures and maybe a few icons, but otherwise it’s fairly static and anything you want to do happens with the desktop in the background. It also doesn’t provide any up-to-date information, with the exception of add-ins like widgets and system tray notifications. With Windows 8 and the use of Live Tiles, this changes and the main view into Windows becomes a dynamic, information-rich display. Every application can provide Live Tile implementations that surface important details relevant to the application. An email app might show the number of unread messages, while a weather app might show the current weather. Users of Windows Phone 7 devices are familiar with Live Tiles and can already appreciate how much more quickly they allow information to be gleaned from the device, and their inclusion in Windows 8 is welcome, if not surprising (we saw them previewed months ago).

The new Metro design paradigm is clearly a big bet for Microsoft and one that is similar in scope to the announcements centered around .NET and the CLR ten years ago. The newly announced WinRT APIs that is used to build these Metro-style applications in Windows 8 run completely separate from the .NET framework and CLR used by "classic Windows" applications built on the Win32 library today. At least in for now, the focus of Metro-style applications is clearly on consumer scenarios such as games and fun social applications. Data-centric business applications and workhorse apps like Photoshop or Visual Studio will continue to live on as Win32 applications using the classic Windows desktop, it seems to me.

Developers can build Metro style applications built on the WinRT APIs in Windows using one of several options, as shown in this diagram. Note that this is not the diagram that Microsoft used during their keynotes, but rather a somewhat more accurate one from Doug Seven (former Microsoft employee) who clarified the original diagram last week. Read his post on why the original diagram was so confusing.

The green areas of the “boxology” diagram represent the new components of Metro style Apps. Developers can build these apps using HTML/CSS/JavaScript, just as they build web applications today. They can build them with C++ using DirectX or XAML. Or they can build them using managed languages like C# and VB, using the CLR and the .NET Framework (version 4.5). There was some confusion about how these various pieces all inter-relate, and Doug’s post helps to eliminate some of them but let me address them here briefly as well. A lot of the issue comes down to conflating different concepts, specifically languages, APIs, platforms, and products.

XAML, HTML, JavaScript, C# – these are all languages, and are separate from platforms and APIs. You can write XAML for WPF, XAML for Silverlight, or XAML that runs on Windows in the form of new Metro style Apps. Likewise HTML can run on a variety of platforms, of which each browser is essentially a platform. HTML/JavaScript applications can now target the Windows platform directly via WinRT APIs. It’s been possible to use HTML and JavaScript, together or separately, outside of browsers for a very long time now, and this is just one more example of where this can be done. You can also think of “Metro style” as a design language, with its own patterns and best practices, as described by Jensen Harris in his talk.

Strengths

Obviously Microsoft has a huge existing install base with Windows, with nearly 450 million copies of Windows 7 sold and over 500 million people signing into Windows Live Services (per month, I think). Microsoft has also committed to backward compatibility – every application that runs on Windows 7 will run on Windows 8. This is a huge strength, and it seems clear that a large number of Windows users will upgrade to Windows 8, at some point.

The new Metro style design is really beautiful. I honestly haven’t met a single person who doesn’t like it. I’ve shown it off in the last week to family, friends, coworkers, and strangers on airplanes and ferry boats. Everyone finds it easy to use, and is impressed by the responsiveness of the touch UI. This is a big strength. Here’s one comment from Twitter on the new UI:

The forthcoming Windows Store, assuming it measures up to its promises, is also a big strength. Installing applications on Windows 7 today, compared with installing applications on my Windows Phone 7 (or iPad or iPhone), is much more difficult and time-consuming. In the first case, nothing from locating to purchasing to installing the application is consistent. In the second case, every bit of the process is consistent and stable. With the App store that will be available with Windows 8, I predict a new dawn for cool Windows Apps.

Finally, Microsoft’s development tools are far and away easier to use than Apple’s, and their developer market share is much larger (even given the huge numbers of iOS developers Apple has gained in the last few years). Assuming Microsoft continues to provide great tools with which to build Apps for its platform, both the tools themselves and the developers who use them will continue to be a strength for Microsoft. Here’s another thought from the Twitterverse:

Windows 8 devices are full PCs. You can take them to class, a meeting, or while you travel just like other tablets, but still have full access to your PC’s capabilities. And when you’re at your desk, you can easily use the device as your primary computer by docking it with other, less portable hardware like external keyboard, mouse, and/or monitors. Given the choice between having to buy one computer for real work and a separate tablet for convenience use, versus only needing to buy a single device without compromising in this regard, I suspect a large share of the market will opt for the single device offering (some analysts are predicting 15% tablet market share for Microsoft in 2014 versus 1% in 2010).

Microsoft is also clearly hoping that by embracing standard languages like HTML, CSS, and JavaScript for building these Apps, it will lower the barrier for many developers to create Apps for Windows 8. Especially developers who might not consider themselves Microsoft or Windows developers today. There’s no question there are more Web developers than C++ or C# or VB developers, so there’s great potential here as well.

Weaknesses

Time to market will be critical, of course. Microsoft is already late to the game, while the iPad continues to dominate the tablet market. The first iPad was launched on 3 April 2010. Microsoft has not yet released any dates for a Win8 launch, but I certainly don’t expect it to reach General Availability before 3 April 2012, so they will over 2 years behind the market leader. I also have no inside information on when the next iPad will ship, but given Apple’s nearly annual release cycle of the iPad and iPhone, it seems likely that an iPad 3 will be making its debut in 2012 as well. It’s likely that these 3rd generation devices, in addition to having 1st and 2nd generation customers eager to upgrade, will have already dealt with various rough edges that the first generation of Microsoft devices (from various vendors) will be just running into.

While its developers and their tools are one of its great assets, Microsoft is also looking for a great deal of new learning from its developer community. Whether you’re currently a C++, web, or .NET developer, you will have to learn new APIs and perhaps new languages in order to be productive with building Metro style Apps for Windows 8. Many developers may choose to stick with what they know.

Even if a large number of developers begin to develop new Metro style Apps, the same diversity of languages that offers Microsoft some strengths is also a disadvantage. Microsoft developers building applications with the .NET Framework have lived in a multi-lingual world from the start, but over time natural selection and market forces have lifted the C# language into dominance. With that dominance, .NET developers today find it much easier to locate books and online resources that they can readily use, and employers find it easy to locate developers who use the same tools they do. The risk with supporting 3 different ways to build Metro style Apps is that the same kind of “Tower of Babel” effect that plagued .NET developers will exist for Metro style App developers. How often will C#/XAML developers find solutions to their questions that are in HTML/JavaScript, and vice versa? And if you’re an ASP.NET/C# developer today, where do you invest your time while learning how to build Metro style Apps? Do you pick up XAML, which is completely foreign to ASP.NET, or do you go the somewhat familiar HTML/JS route, and give up your perhaps-beloved C# language? This classic Paradox of Choice (more on this in my post on which stack I would recommend for ASP.NET developers)may prove to be a hindrance to Metro style App development.

The story for Windows 8 that we’ve seen so far does not include much for the business/enterprise developer. Games and social apps seem to be the focus at this stage. It’s possible that as we get closer to a release, Microsoft will announce features that target businesses more so than consumers, but it’s also likely that such features may be pushed off until a later version of Windows. If that’s the case, it may be that many businesses don’t find a compelling reason to upgrade to Windows 8, and may wait and see what Windows 9 offers.

Opportunities

Microsoft has a huge opportunity in the tablet space. Windows 8 is clearly well-poised to challenge the iPad in the rapidly-growing tablet market. Just as netbooks were huge a few years ago, tablets are huge today, and Microsoft is no doubt hoping they can capitalize on tablets just as they did on netbooks.

As more and more devices use the Metro style UI, Microsoft is likely to gain loyal customers who find the Live Tiles and general design appealing. Currently Windows Phone 7 and XBox Kinect share the same Metro design as Windows 8, and we have seen that even some Windows Server applications will be taking on more of a Metro style. Just as Apple is able to draw in and keep customers with its many iWhatever devices, Microsoft has an opportunity to do the same thing through appropriate use of its Metro design across form factors.

There are also great opportunities for Windows developers who build Metro style Apps that are distributed through the Windows Store. I have no doubt there will be new companies made famous by as-yet-unseen apps that are built for this platform. Who will write an App that will become as popular on Windows 8 as Angry Birds is on iOS? Time will tell.

Threats

The biggest thread to Microsoft’s Windows 8 strategy is clearly Apple. As the dominant player in the touch tablet market, Apple may challenge Microsoft in a number of ways. Already Apple has a large number of loyal customers, and this number will continue to grow. Apple also may have a price advantage, though historically Apple’s devices have sold at a premium relative to their competition and thus far we have no pricing on consumer Windows 8 devices (we do know the MSRP of the developer preview devices, but that would not be an apples-to-apples comparison). If nothing else, there are millions of used iPads that will likely be entering the secondary market as Windows Tablets are being launched, and these may provide a “good enough” tablet for many customers who might otherwise have opted for the more versatile Windows Tablet devices.

Other market players, such as Google, may also enter the market in earnest. We’re still quite a ways out from launch, so there’s time for other disruptors to jump in.

Longer term, it’s possible that Windows’ use of HTML and JavaScript may backfire, in that many Windows developers may learn these skills to build Windows Apps, but later move to other possibly non-Microsoft platforms that also make use of these languages, and which may offer greater reach.

Finally, with HTML/JS Apps, it’s possible to easily reference web resources, including things such as advertising scripts. As Google remains the largest advertising player in this space, it’s possible that many free Windows Apps will leverage Google for their advertising, providing Google with a potentially huge revenue stream and even greater access beyond the browser to Windows users. Microsoft would be wise to offer an App advertising model that keeps many developers using Microsoft’s advertising tools and keeps that revenue for itself, rather than Google.

Questions and Answers

Q: Where should I go to learn more?
A: The two best resources today are the BUILD sessions and the Building Windows 8 Blog. There are other blogger and industry resources listed below, too.

Q: Where can I download Visual Studio 11 Developer Preview?
A: http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=27543

Q: Can I download a preview of the full VS11 Ultimate?
A: Yes, if you have an MSDN subscription.

Q: Can I download the source code to the sample Metro style Apps shown at BUILD and installed on the developer tablet?
A: Yes, here: http://code.msdn.microsoft.com/Windows-Developer-Preview-6b53adbb

Q: What about the hands-on labs and virtual machines that were available during BUILD? Can I get those, too?
A: Yes, even those. Here are the VS11 ALM Virtual Machine and Hands-On-Labs instructions. (these relate to VS11, but not so much to Windows 8, WinRT, and Metro style Apps)

Q: What is WinRT?
A: WinRT is a set of APIs that are used to build Metro style Apps. WinRT is strictly for building Metro style Apps in Windows 8 – you can’t build traditional Windows applications with WinRT, or server-side applications.

Q: When I work with WinRT from C#/VB, is there a CLR involved?
A: Yes, the CLR is loaded just as with a standard .NET application.

Q: What if I’m using C++ or JavaScript – is the CLR involved then?
A: No, these languages run in their own runtime environments.

Q: If I’m building an App using C#, can I only use WinRT libraries, or can I still use the .NET Framework libraries?
A: You can use the new WinRT libraries, as well as a subset of the .NET Framework APIs. The exact set of things that exist in one or the other isn’t determine yet. In cases where you could do the same thing in either WinRT or .NET, the .NET approach is typically removed so there is a consistent interface. Also .NET APIs that block, as opposed to those that can be accessed asynchronously, will typically be removed and replaced with WinRT APIs. In terms of how this is exposed, it’s done via a profile in Visual Studio, similar to how Silverlight and Windows Phone as well as Windows Client profiles allow access to only portions of the framework today.

Q: If I’m building my App with (C++/C#/JavaScript), will my API calls look like standard functions in my language and with my object types, or will they use a different standard?
A: The WinRT APIs have projections for C++_, JavaScript, and .NET. Each one is designed to make working with WinRT from that language consistent with the language’s type system, capitalization standards, etc. Learn more about how this works here.

Resources

WinRT and the Paradox of Choice (my follow up to this analysis)

Former Microsoft employee Doug Seven clarifies the Windows 8 Marketecture Diagram

Microsoft Watcher Mary-Jo Foley further analyzes Microsoft’s Windows 8 architecture slide

Microsoft RD Andrew Brust describes his reaction to the BUILD announcements in A Tale of Two Windows

Microsoft RD Rocky Lhotka describes how WinRT relates to .NET

Microsoft RD Scott Cate describes Metro (4:13 minute video)

Microsoft RD Vinod Unny’s take on the Windows 8 Dev Stack

Microsoft RD Dan Wahlin explains Why He’s Excited About Windows 8

Mono Founder Miguel de Icaza Demystifies WinRT

Microsoft RD Stephen Forte Describes His First Day Using the Windows 8 Developer Tablet as his only computer

3 Tips to Improve Your Connection Strings

Fri, 30 Sep 2011 14:43:33 GMT

Due to some database moves, I’ve recently been touching a lot of connection strings, which has me thinking about the topic. In fact, I put together a short survey on twitter, and invited a bunch of developers and DBAs to share their thoughts, both on twitter and in the survey, on some issues relating to connection strings. Here are three tips you should know about that, if you’re not already using, should improve your use of connection strings.

Use Windows Authentication (if you can)

By far the biggest tip I can offer is that you should be using Windows Authentication. You can find this guidance directly from Microsoft, when they discuss Choosing an Authentication Mode on MSDN/Books Online. Here it is, in their exact words:

Why is this preferred? Because the user’s credentials are never sent over the wire. “Windows Authentication is the default authentication mode, and is much more secure than SQL Server Authentication.” From the poll I conducted, it seems that most folks do realize that Windows Auth is the way to go, with fully 2/3 of respondents going that route, and another 25% trying to mitigate the security issues of Sql Authentication by at least encrypting the connection strings within the config file:

What are the downsides? Well, it only works with Windows machines, and not across domain boundaries, are the two biggest ones. There are rumors about performance issues with Windows Authentication, but as far as I can tell, these are without merit. Here’s one thread that explains why even in a worst case scenario, there shouldn’t be any noticeable performance difference between Windows Authentication and SQL Authentication. The main reasons given by Microsoft why you might choose SQL Auth are:

Support older applications and those that require SQL Server authentication
Support mixed operating systems, where some users are not authenticated by a Windows domain
Allow users to connect from unknown or untrusted domains.
Allow SQL Server to support Web-based applications where users create and connect as their own identities.
Allow software developers to distribute applications using a complex permission hierarchy based on known, preset SQL Server logins.

Unless one of these applies to you, use Windows Authentication. Here are a few more responses from Twitter:

Use a Fully Qualified Domain Name for your Database Server Name

Sometimes, your database will need to move from one physical server to another. Similarly, sometimes a web site will need to move from one web server (or hosting center) to another. In both cases, client applications need to be able to connect to the database (or web site) at its new location. In both cases, the use of a Fully Qualified Domain Name (FQDN) for the server’s name coupled with the ubiquitous Domain Name Service (DNS) to translate this name into an actual address (IP address) makes it unnecessary for the client to make any change as a result of the move. If, instead of using a FQDN, you connect to your database’s server by referring to its machine name, or worse, its IP address, then any time the database needs to move to another physical machine, you will need to update every connection string on every application on every machine that references this database. Depending on the scope of your operation, this can quickly turn into a significant amount of work. From my survey, about 42% of respondents recommended using FQDNs, with another 43% saying they would use the server’s Machine Name. Just 9% would refer to the server via its IP Address, something I would personally call a worst practice (I speak from experience here). Here’s the survey results – I was actually surprised nobody chose the dark blue option just to be snarky:

Here are a few more comments related to this question:

It’s also worth checking out Dynamic Update, as Mike Letterle recommends here:

My recommendation is to create a FQDN per database, rather than using something that corresponds to a particular server. For instance, it’s not uncommon to have a separate database for authentication and another one for an application’s primary data. Maybe when your app launches both of these are on a machine named SQL1, at IP address 192.168.0.123. And let’s assume just to make it interesting that your app will run on a web farm with N web servers, so any time you need to make a change, you’re touching at least N config files.

When you specify the server in your connection string, if you use 192.168.0.123, congratulations, you’ve just hardcoded your application to something that can change extremely easily, and you have zero abstraction layer so there is a 100% chance you will need to touch this connection string if either database were to move. If you refer to the server as SQL1, then at least the IP address can chance and your app can still connect. But what if you upgrade to a bigger server and move the databases over to the creatively named new server, SQL2? Now you’ll need to update that connection string… bummer. So now what if you refer to the server as sql1.mydomain.com, which is a FQDN, for both databases? Now you’re safe from IP address changes as well as machine name changes, as long as you’re ok with the idea that the FQDN sql1.mydomain.com might actually point to an IP address that is bound to a machine named SQL2.

But what if your application is reaching the limits of what one database server can handle, and you need to split the authentication database to one database server, and the main application database to another (or let’s say it will stay on SQL1). Now, again, you’re going to have to go and touch config files and edit connection strings even if you’re using a FQDN to refer to the original database server.

Now, consider if you refer to your server names with FQDNs that map to each database. For the authentication database, you refer to it as auth.db.mydomain.com and for the cool application you refer to it as coolapp.db.mydomain.com. Now of course in DNS both of these map to 192.168.0.123 initially. If you move everything to SQL2 with a new IP, you can simply change both records. If you split the databases, you just change one record to reflect the IP of the new server. You have the ultimate in flexibility and everything is neatly abstracted so that a change in the location of a resource in your network can be managed at the level where it makes sense – using network tools (DNS) rather than impacting every application that depends on the resource.

And if for some reason it’s beyond your reach to have an internal DNS resolve FQDNs for you, it may still be worthwhile for you to follow this practice, but simply store the mapping between FQDNs and IPs in each of your application/web servers’ hosts files (located in c:\windows\system32\drivers\etc\hosts). The hosts file is checked before external DNS is, so anything you specify in there will be used by that machine when it maps FQDNs to IPs.

Include Your Application’s Name in its Connection String

Rob Sullivan was nice enough to point me to this tip, which he’s blogged about in the past. If you don’t include an Application Name= or App= parameter in your connection string, typically the only thing you will see in a tool like SQL Profiler is “.NET SqlClient Data Provider” for every data connection coming in via ADO.NET. Once you add in the App= parameter, you’ll see your actual application name, instead. For instance, adding “app=my northwind app” results in a SQL Profiler result that looks like this:

If you’re running a server that a lot of different applications are talking to, this can make it much easier to determine where the various queries are coming from. Also, if you have a cluster or web farm environment, you can include the hostname of the machine as part of the application name (yes you can get this via other columns, too, if you don’t do this), as Rob also suggests:

Just like that, no more mystery involved in determining where various connections and queries are originating. In the past, I had solved this problem by using SQL Authentication and making each application have its own SQL Server login. However, with this tip coupled with the first one above, that’s no longer something I would recommend or endorse.

For the sake of completeness, here’s the answer to the first question from the survey. I was hoping I could use these responses to slice the data and see how the answers to the other two questions varied by user role (app dev, DBA, sysadmin), but unfortunately that didn’t work out – maybe next time.

Thanks to everyone who took my little survey and also participated in the discussion on Twitter. I learned a few new things that I’ve already started to implement, and I hope this summary helps out other application developers and SQL Server DBAs who work with them/us.

Speaking at DevReach 2011

Fri, 30 Sep 2011 13:42:19 GMT

I’m very pleased to be speaking again at DevReach in Sofia, Bulgaria next month. As usual, the conference has an amazing list of speakers (which I’m still somewhat amazed includes me), with Scott Hanselman making the trip out this year to give several sessions. If you have the opportunity to attend, I highly recommend it. There’s certainly no other conference in Eastern Europe that comes close.

This year, I’ll be presenting on three topics. The first is something new for me. I’ll be co-presenting with Richard Campbell of DotNetRocks on Performance Tuning ASP.NET – Stories from the Trenches. For this session, Richard and I are each going to share some of our real world performance tuning stories with the audience. It should be a lot of fun and will also show off some important tips and techniques for diagnosing and fixing performance problems in real world systems.

The next topic is also performance-related, which is Improving ASP.NET MVC Application Performance. I presented on this topic earlier this year at MVCConf, and it was very well-received. There are, needless to say, a few tips and tricks related to performance that are specific to ASP.NET MVC (as opposed to ASP.NET Web Forms), which I’ll be covering. I may also look at some of the new async features of ASP.NET MVC 4 and how these impact performance, but I’m not sure yet if that will fit into the session.

The third session will be on Common Design Patterns. This is a presentation I’ve given several times, and allows developers to learn about the “low hanging fruit” of design patterns – the ones that I’ve found to be helpful in the largest number of common situations for .NET developers. Whether you can’t name a single design pattern or you know dozens of them by name and use, this should be an interesting session, and one which usually (at least in the United States) involves audience members a fair bit.

I’m looking forward to the trip, the sessions, and many great conversations with attendees and speakers from around the world. I hope to see you there!

Cleveland 2011 Software Engineering 101

Fri, 30 Sep 2011 12:30:39 GMT

Next Friday, 7 October 2011, Microsoft in Cleveland is hosting a free one-day event focused on the basics of Software Engineering. There are a handful of seats left before the event sells out. You can learn more and RSVP for Software Engineering 101 here (until tickets run out). The event is being held at the Microsoft office here:

Microsoft Corporation
6050 Oak Tree Blvd
Independence, OH 44131

Last year, the event sold out (well, “sold” is misleading, since it’s free), and it’s on track to do so this year as well. Here’s some more information, from the event’s home page:

This is a one-day, FREE event designed to improve your software development skills. Rather than focusing on introductions to new technologies or tools, this conference will help you get better at your craft. The morning sessions will focus on fundamental principles, patterns, and practices of software development, and the afternoon will be spent on practical exercises that put these fundamentals into action. While the sessions will mostly make use of .NET and Visual Studio, these topics apply to any language or platform.

If possible, bring your own laptop for use in the hands on sessions, with your choice of development and testing tools installed. We will have prepared material for Visual Studio 2008/2010 and C#, but other environments are welcome. If you cannot bring a laptop, don't worry - we'll be pairing together so as long as half the attendees have laptops, it will be fine.

Some of the topics that will be covered include NuGet, Mercurial, software testing, refactoring, object oriented principles, and advanced testing with mock objects. I will be presenting on applying SOLID principles to improve the design of existing code. The event is being sponsored by NimblePros, HudsonSC, Microsoft, and Pluralsight.

Wiring up an AutoCompleteBox to a JSON Service in Silverlight

Fri, 23 Sep 2011 10:17:52 GMT

I’m currently building an internal application for The Code Project that needs to be able to transfer the contents of some potentially very large files over the wire. After considering various ways to get the data from point A to point B, we decided the easiest thing would be to process the text file on the client, and send batches of rows up to the server for processing. Initially we looked at building a WPF client for this, but then switched over to Silverlight 4 since the rest of the application is web-based and we didn’t want staff to have to worry about a separate standalone application.

Basically the files get translated into simple lists on the server, so the UI simply consists of “Enter/choose a list” and a drag-and-drop file uploader. The list selection UI needs to support both selection from existing lists, or creation of new lists. To that end, I did some searching for an AutoCompleteTextBox in Silverlight, and found Jeff Wilcox’s article on Introducing the AutoCompleteBox. Of course, it doesn’t show how to wire up the contents to a JSON call, so another search yielded Tim Heuer’s article on Making Use of JSON data in Silverlight. Putting them together, you get something that works quite well for what I need.

Here’s my XAML for the AutoCompleteBox:

<sdk:AutoCompleteBox Height="20" HorizontalAlignment="Left"

Margin="12,0,0,0"

Name="autoCompleteBox1" VerticalAlignment="Top"

Width="376" Grid.Row="1"

ValueMemberBinding="{Binding Name}" >

   <sdk:AutoCompleteBox.ItemTemplate>

        <DataTemplate>

            <TextBlock Text="{Binding Name}"></TextBlock>

        </DataTemplate>

   </sdk:AutoCompleteBox.ItemTemplate>

</sdk:AutoCompleteBox>

Note: I’m not a Silverlight expert, so if I’m doing things against best practices, I apologize. It does, however, work for me as shown. I wired up the loading of the AutoCompleteBox in my form’s load, since it’s the only thing this page does so I saw no point in doing it lazily when the AutoCompleteBox is used. I simply added Loaded=”UserControl_Loaded” to my root UserControl element for this.

Then in the MainPage.xaml.cs, I implemented this Loaded handler like so:

    private void UserControl_Loaded(object sender, RoutedEventArgs e)

    {

        WebClient proxy = new WebClient();

        string url = String.Format("{0}/Test/ListSuppressionLists", Constants.SERVICEHOSTNAME);

        proxy.OpenReadCompleted += new OpenReadCompletedEventHandler(proxy_OpenReadCompleted);

        proxy.OpenReadAsync(new Uri(url));

    }

    void proxy_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)

    {

        Stream myStream = e.Result;

        var serializer = new DataContractJsonSerializer(typeof(SuppressionList[]));

        SuppressionList[] lists = (SuppressionList[]) serializer.ReadObject(myStream);

        autoCompleteBox1.ItemsSource = lists;

    }

All that remains is to implement a controller in the ASP.NET MVC application that this Silverlight control will live in (and make sure it has the clientaccesspolicy.xml and crossdomain.xml files, if needed). The controller action needs to AllowGet with its JsonResult, too. Here’s basically what it looks like:

    public JsonResult ListSuppressionLists()

    {

        // _repository is provided via the Controller constructor and IOC

        return Json(_repository.ListReadOnly(), JsonRequestBehavior.AllowGet);

    }

Here’s the result in action:

Blog

Reviewing Scrumban the Book

Updating Blog to Orchard and Switching Domains

About Steve

Asus Zen Ultrabook First Impressions

Unboxing

Starting For The First Time

Run Your Unit Tests in Parallel to Maximize Performance

Enabling Parallel Testing in MSTest

Caveats

Summary

Unit Test or Integration Test and Why You Should Care

Visual Studio 2010

ReSharper 6.1

How Can You Tell if a Test is a Unit Test or an Integration Test?

References

CodeMash 2012 Sessions

Beginning Software Craftsmanship

Intermediate Software Craftsmanship

A Lap Around ASP.NET MVC 4

Silverlight 5

Handy EnumerableExtensions

ForEach<T>

ContainsAny<T>

View HTML Source of Email in GMail and Google Apps

Inner Fields and Lazy Initialization in C#

RazorEngine Performance and Template Caching

5 Concurrent Users, Non-Cached

5 Concurrent Users, Cached

Install Application as Service on Windows Server 2008

Using If This Then That to Automate Your Life

Recipes

Working with Lazy Loading in Entity Framework Code First

Analyzing Windows 8 and WinRT

What Does Windows 8 Offer?

Strengths

Weaknesses

Opportunities

Threats

Questions and Answers

Resources

3 Tips to Improve Your Connection Strings

Use Windows Authentication (if you can)

Use a Fully Qualified Domain Name for your Database Server Name

Include Your Application’s Name in its Connection String

Speaking at DevReach 2011

Cleveland 2011 Software Engineering 101

Microsoft Corporation 6050 Oak Tree Blvd Independence, OH 44131

Wiring up an AutoCompleteBox to a JSON Service in Silverlight

Microsoft Corporation
6050 Oak Tree Blvd
Independence, OH 44131