Report: Microsoft TechDays 2013: Day 1

Disclaimer: This is a cross-post from iDA MediaFoundry, the company I work for.

TechDays is Microsoft’s conference geared toward developers and IT professionals. During the three day lasting event participants are brought up to speed with the latest developments pertaining to Microsoft’s development and cloud platforms. Back-to-back presentations from local and international speakers alike are interspersed with hands-on labs and strolls between the various partners’ booths. The Cronos booth in particular featured its very own barista and was serving hot steaming coffee all day long.

Even though the Microsoft TechDays 2013 conference actually only officially kicked off on March 6, I attended the pre-conference, which was comprised of a whole day of Visual Studio 2012 and Team Foundation Server (TFS) oriented sessions. The former, Visual Studio, is well known to anyone who develops for Microsoft platforms. TFS, however, was a bit of an unknown to me. It turns out to be much more than just a source code repository. Microsoft is positioning TFS as an Application Lifecycle Management (ALM) solution, which includes various testing and project management features. Most of the pre-conference sessions were devoted to ALM, which turned out to be more engaging than it sounds. Here’s a brief breakdown of the sessions I attended on March 5, 2013.

Deep Dive Modern ALM with Visual Studio 2012: It’s a Team Sport

This was the pre-conference’s very first session, presented by Brian Keller, Principal Technical Evangelist for Microsoft ( Keller introduced us to Application Lifecycle Management, a management concept which encompasses all phases a software product’s development: design, development, testing and operations. Microsoft’s solution is called Team Foundation Server and is often misconstrued as merely a source control system. While this is certainly part of what TFS has to offer, it also provides a number of other features like sprint, build and test management. In summary, TFS is a centralized project management tool which integrates source control, bug reporting, test management, sprint planning and pretty much everything else that’s involved with keeping tabs on the progress of a software development project. It goes without saying that this system depends on a mostly Microsoft/Windows-based architecture, although Visual Studio and TFS now also deeply integrate with Git for version control and Selenium for cross-browser UI testing. Keller briefly demoed features like sprint boards, the Kanban board and burn-down charts. Another thing TFS supports QA-teams with is collecting feedback from stakeholders. Visual Studio can be used in tandem with Microsoft Test Manager to manage customer feedback collected by a desktop application which records diagnostic information, screenshots and video screen captures.

Brian subsequently went on to discuss a couple of the most important new features in Visual Studio 2012:

  • Revamped unit testing support, now extensible by design with adapters for many 3rd party unit test frameworks, e.g. XUnit, NUnit, etc.
  • Team Explorer > My Work with the ability to shelve ongoing file changes and Visual Studio application state
  • Integrated code-review process support in Visual Studio 2012
  • Updated code diff-tool
  • Code clone analysis: quickly surface copy-pasted code throughout Visual Studio 2012 solutions, including fine-grained as well as coarse-grained filtering
  • IntelliTrace can now be installed on production servers for enhanced in-the-field debugging (supports breakpoints)

A couple of upcoming new features for VS 2012 Update 2 are:

  • Tools for Git, which will allow Visual Studio and TFS to integrate with any Git repository, including those hosted on GitHub and BitBucket
  • Updated Test Hub

Brian Keller also tipped us off on the Team Foundation Service being free for the first 5 users. In addition, he also mentioned that all other users above the first 5 are also free until the platform preview ends.

TFS in the Cloud or TFS on-premises?

The second session I attended was hosted by Marcel de Vries, a Microsoft MVP for ALM based out of The Netherlands ( In line with Microsoft’s shift to cloud computing, TFS is offered in two flavors: on-premises and cloud-based. De Vries’ talk was based around a demo of the cloud-based version of TFS, dubbed Team Foundation Service, and a concluding comparison of both flavors. Interestingly, Marcel demonstrated how TFS integrates tightly with services deployed on Azure. Additionally, when TFS and Azure are combined, developers can make use of hosted build servers (at Microsoft’s datacenters). These build “farms” currently support Visual Studio’s major built-in build templates, including Windows Phone 8 and TypeScript. Windows Store builds are curiously missing. For more exotic build types one can set up a local build machine and link it up to the TFS instance in the cloud.

Testing with MTM 2012 and Lab Management

Once more presented by Brian Keller, this session took a closer look at Microsoft Test Manager and Microsoft Lab Manager. Test Manager is a tool which has extensive support for manual testing. It provides a convenient interface for managing test cases and test steps. It supports the QA engineer with step recording and playback, whilst logging diagnostic information for later reference by developers. In addition to formal testing based on test cases, MTM also provides functionality for managing ad-hoc, exploratory testing.

Lab Manager provides tooling for running automated tests on virtual machines which run on Hyper-V or other virtualization platforms (e.g. VMWare, VirtualBox, etc.).

Cross-browser CodedUI Test Automation

Presented by Marcel de Vries. CodedUI tests enable developers and testers to create automated UI tests for applications developed for the web or .NET platforms like Silverlight, WPF and WinForms. Windows Phone support is missing. In order to access and manipulate UI elements, CodedUI tests use Windows’ accessibility framework which was originally intended for use by persons with disabilities to provide features like screen reading. Microsoft recently added compatibility with Selenium, which enables wider browser compatibility, i.e. Firefox and Chrome (in addition to Internet Explorer, of course). Tests can also be parameterized using @-annotations.

Behavior Driven Development was described as one of the best practices compatible with the CodedUI Framework. A small hands-on session demonstrated the use of a code-first approach to implementing BDD’s “Given-When-Then” structure.

Lab Management

Pieter Gheysens hosted the last session of the day specifically about Lab Management. He is a member of VISUG, the Visual Studio User Group, which organizes 10-15 user group meetings per year. Lab Management should be seen as an addition to TFS, which extends the build management functionality provided by Microsoft Test Manager. It is used to provision test environments. It allows quick spawning of virtual machines based on pre-set VM templates. In order to make use of these features, however, you or your organization will need a license for Visual Studio Premium or higher. Next, Gheysens took the time to elaborate on the added-value of Lab Management with Microsoft Test Manager.

Software continues to become more complex and with it, so do bugs. The time and effort required to reproduce potential bugs keeps rising and is thus making software development increasingly more expensive. By focusing on controlling quality in the early stages of development, the cost of resolving bugs decreases. Because Lab Management deals with the provisioning of production-like environments, it has the potential to bridge the gap between development/test teams and devops teams. Ultimately this will shorten cycle times and increase collaboration between the aforementioned teams. Subsequently it enables “deployment readiness”, i.e. the ability to push releases to customers faster and more reliably. Before diving into his extensive demo, Pieter Gheysens enumerated the top three reasons why bugs are so difficult to solve:

  1. Poor documentation: testers often don’t properly document the steps to reproduce
  2. Lack of visibility: developers often don’t have a clear understanding of all of the conditions the QA-team is testing in
  3. Environment/configuration differences between dev, test and devops

This article first appeared here.