Jason Zander's blog

New Team, New Challenges

Jason Zander — Thu, 20 Sep 2012 00:30:16 GMT

Last week we officially launched VS2012 and the .NET Framework 4.5. I’ve spent the last couple of weeks in launch activities in London, Seattle, Atlanta, and New York, sharing details on the new versions and doing whatever I can to help people get going on the new release. I can honestly say this is the best release I’ve worked on (and I’ve worked on basically all of them). We have been able to use half the milestones and land with higher quality this release thanks to several internal improvements as well as the new toolset we just released (I will have to share some of those improvements in future posts; I’ve heard from many of you that you are trying to do similar things).

Now that we have shipped I will be taking on a new challenge owning development efforts for Windows Azure. I’ll be joining my new peers Scott Guthrie (another DevDiv alumni) and Bharat Shah. I’m looking forward to working with Scott and Bharat as well as taking on a new set of challenges and technologies. Cloud computing is one of the most exciting technologies in the industry right now and I’m joining a great team working on cool stuff at global scale.

Wish me luck <g>

Tune in to the Visual Studio 2012 Launch

Jason Zander — Wed, 12 Sep 2012 17:00:00 GMT

This morning we kicked off the VS 2012 launch with an event in Seattle. You can tune in to the online coverage at http://www.visualstudiolaunch.com/ for live interviews and session recordings. In this blog post, I’ll share some of the info I presented at today’s event.

Modern Applications

It’s a really cool time to be a consumer today. New smart phones, tablets, ultrabooks, and lots of cool gadgets are coming out all the time. In this world, users have become accustomed to having a lot of choice in their applications and they expect to see certain features from the start (connected, touch, etc). We are also increasingly seeing more demand for these same types of features in the Enterprise. With products like Yammer, social has crossed over from networking with friends to my teammates. Finally, users are becoming accustomed to getting new features faster than ever before. If we want to be successful in this new world we will have to change up the way we are creating software.

The question for developers is how do we build such applications and do it with the fastest time to market? We will need a system that allows us to build out business and transactional logic at scale, exposing things in a way that we can handle many heterogeneous device types, with team software to speed up delivery. Today’s keynote walks you through how Visual Studio helps you solve these problems.

Visual Studio 2012

These trends are exciting, and provide compelling ways for users to interact with your apps. But they also present new challenges when it comes to the development of your apps. These are the kinds of things we had in mind when designing Visual Studio 2012 and .NET Framework 4.5.

We wanted to make sure that you could start with your existing software assets, and bring them forward to take advantage of the latest platforms. Using Visual Studio 2012, you’ll find that you can target a variety of Microsoft and non-Microsoft clients. You can also create backend services using SharePoint, SQL Server, Windows Azure, and Windows Server. And finally, you can manage your app in production using System Center integration.

Continuous Services

When designing the backend services for your app, you need them to scale to the demand, to be accessible from different clients, and to be able to leverage both cloud and on-premise components. VS 2012 and .NET Framework 4.5 contain the tools and technologies to help you be successful here. (Many of these are actually “favorite features” that I’ve blogged about before. ;-) ) ASP.NET Web API and Entity Framework Code First are two useful .NET features for building your services. With EF Code First, you can start by defining classes that represent the data model, and let EF create the database tables for you. Then you can create a Web API controller to expose the data as an HTTP-based service, which can be consumed using REST, JSON, or XML. This makes it really easy to access the service from a variety of clients, so you can build a set of companion apps for phones, tablets and browsers, across any platform.

New ASP.NET Web API project

Web Experiences

One place you’ll want to consume these services is from a website - this is where you’ll get to take advantage of the latest web tooling features in VS 2012. You’ll find enhancements like JavaScript IntelliSense and debugging, HTML 5 schema validation, DOM Explorer, and new code snippets. Also check out the new Page Inspector, which allows you to analyze running web pages and find the code that generated each HTML element:

Finally, when you’re all done, you can use the Visual Studio Publish wizard to deploy the website to Windows Azure.

Connected Devices

Once you have your services set up, you’ll want to access them (by consuming the Web API) from the client apps running on your connected devices. These apps might include existing desktop apps, a new Windows Store app, a Windows Phone app, or an app for another platform. VS 2012 introduces new features to help with the development of these apps, such as the C# & VB async and await keywords, which simplify asynchronous programming, resulting in more responsive apps. You’ll also find a new and enhanced XAML editor within Visual Studio, as well as design tools for Windows Store apps in Blend for Visual Studio 2012. In case you decide to create Windows Store versions of your existing desktop apps, VS 2012 includes portable libraries which allow you to refactor your application logic so that it can be consumed from both the WPF and Windows Store app (as well as Windows Phone, and a variety of other clients you might have plans for down the road…). We’ve also added great C++ graphics tools in this release for both editing, using the Vertex Shader, Pixel Shader and Output Merger, as well as debugging, using the pixel history and other diagnostic tools:

Conclusion

This is really just a glimpse into how you can use VS 2012 and .NET 4.5 to build modern apps that “wow” your users. Make sure to catch the full coverage from today’s event on http://www.visualstudiolaunch.com/. You can also read about the announcements we made today from Soma, Brian and the Visual Studio team blog.

Follow me at http://twitter.com/jlzander.

Visual Studio 2012 and .NET Framework 4.5 released to the web!

Jason Zander — Wed, 15 Aug 2012 17:50:00 GMT

I’m thrilled to announce that this morning we released Visual Studio 2012, Team Foundation Server 2012, and .NET Framework 4.5 to the web. It’s time to start your engines, and begin downloading today!

MSDN Subscribers can download immediately at the MSDN Subscriber Download Page, and volume licensing customers will be able to download starting tomorrow from the Volume Licensing Service Center. You’ll also be able to find the product in stores in the next month or so, as well as some availability to purchase through the Visual Studio product website in the next few days. Finally, to evaluate the free trial versions or download our free Express products, please visit the Visual Studio product website today.

This has been a great release for the team, and I’m really excited about all that we’ve accomplished. By adopting agile practices, and using our IDE and ALM tools, we’ve been able to complete the release in half as many milestones this time around. Here’s a picture of our release team, signing off on the final build:

Developing great apps for Windows 8 is an important goal of this release. Therefore, in coordination with today’s developer tools releases, you’ll notice that the final version of Windows 8 has released to the web as well. Furthermore, in addition to the Blend tools that ship with Visual Studio 2012 RTM, today we also released a new Blend + SketchFlow Preview for Visual Studio 2012 that addresses some top Blend customer requests, including support for WPF, Silverlight, and SketchFlow. For more details, check out BlendInsider, the Blend team blog.

Top 12 of Visual Studio 2012

In case you’re still deciding whether to download Visual Studio 2012, or haven’t been keeping up with all the news about the release, I’ll leave you with 12 good reasons to upgrade today. ;-)

#1) Develop for Windows 8

Visual Studio 2012 contains all the tools you need to develop killer apps for Windows 8, from templates, to designers, to testing, to debugging. Blend now comes with the Visual Studio installation providing rich visual tools for creating Windows store apps using HTML/CSS and XAML. Using these tools, you’ll find everything you need to develop a great app and submit it to the Windows Store.

For more information, see the Windows 8 App Developer Blog and the Windows Dev Center.

#2) Develop for the Web

Visual Studio 2012 and .NET 4.5 provide the latest advances in ASP.NET including web optimization improvements (minification and bundling), new templates, HTML & CSS editor improvements, page inspector, and new publishing tools. We’ve added new features to support JavaScript development including IntelliSense improvements, a new DOM explorer, and a JavaScript console. For more information, check out the Web Development team blog.

Page Inspector

#3) Develop for Windows Phone 8

Visual Studio 2012 will provide support for developing Windows Phone 8 applications (both with a Express SKU as well as a freely downloadable plug-in for VS Pro and above). This will come online in the future, once Windows Phone 8 and the developer SDK become available. Some new features to look forward to include native C++ support, the ability to target both Windows Phone 7.x and Windows Phone 8 applications, multi-chassis support, and enterprise publishing. Stay tuned for more info from the Windows Phone team.

C++ Windows Phone 8 Application

#4) Develop for Windows Azure

Visual Studio provides the best possible tools to develop your cloud services. In Visual Studio 2012, you’ll notice cloud tooling improvements including support for distributed caching, new publishing options, new templates, and a lower install footprint. Using Team Foundation Service with Windows Azure, you can now achieve continuous integration and continuous deployment of your software. For more information, please visit the Windows Azure .NET Developer center, and download today’s release of the Windows Azure SDK for .NET.

Deployment history

#5) Develop Business Applications

Visual Studio 2012 contains a variety of tools for developing business applications. SharePoint developers will find new designers for list and content types, new templates for site columns and Silverlight web pages, as well as new options for deploying SharePoint sites. ALM features like performance profiling, unit testing, and IntelliTrace are now available for SharePoint development. Client-side development has been improved as well, with support for JavaScript debugging and IntelliSense. For more information, please visit the SharePoint developer team blog.

SharePoint List Designer

Meanwhile, we’ve also announced a new app model for Office and SharePoint 2013, which enables you to host your apps in the cloud, and to use web technologies to develop them. Visual Studio 2012, along with the Microsoft Office Developer Tools for Visual Studio 2012 – Preview, gives you the tools to program with the new app models for Office and SharePoint. To learn more and get started building apps for Office & SharePoint 2013, head to http://dev.office.com.

LightSwitch is a powerful tool available for building business applications for the Desktop and the Cloud. Starting in Visual Studio 2012, LightSwitch is available as part of the Visual Studio Professional, Premium and Ultimate installations. LightSwitch includes a variety of improvements in Visual Studio 2012, such as a new theme, the ability to access data from any OData source as well as create OData services, Active Directory integration, and new business types. We also are working on support for HTML clients, which will be available as an add-on to VS2012. To learn more, please visit the LightSwitch Developer Center and the LightSwitch team blog.

LightSwitch in Visual Studio 2012

#6) Develop Games and other 3D Applications

Visual Studio 2012 includes graphics tools to help game developers become more productive, making it easier to build innovative games. From debugging DirectX graphics, to designing and coding DirectX shaders (HLSL), to inspecting and manipulating graphics assets (images and models), Visual Studio 2012 provides all the functionality you need to build graphically rich 2D/3D applications.

Visual Studio 2012 Graphics Diagnostics Tools

#7) Take advantage of the latest language advancements

If you’re developing in C# or Visual Basic, you can take advantage of the language new features in Visual Studio 2012 and .NET 4.5 for asynchronous programming. Using the new async and await keywords, you can write asynchronous code that looks a lot like the synchronous version:

The C++ support in Visual Studio 2012 includes the full C++ 11 standard library as well as new language features: stateless lambdas, SCARY iterators, range-based for loops, and scoped enumerations support. Visual C++ 11 also adds seamless access to Windows Runtime components through C++/CX as well as C++ Accelerated Massive Parallelism (C++ AMP), which enables hardware acceleration for the execution of your data-parallel C++ code.

For JavaScript development, please see more details about the improvements we’ve made in the Web development section above.

Lastly, if you’re using F#, you’ll enjoy improvements for information-rich programming, which enable you to program directly against data services, and are made possible by F# type providers and LINQ queries.

#8) Performance, Reliability, and Compatibility Improvements

In addition to adding new features, we’ve also invested heavily to improve the core capabilities of the product. For example, we’ve invested in performance and made significant improvements in areas such as the toolbox, typing and editing, debugging, and solution loading time.

We’ve also taken care to improve the backward compatibility of Visual Studio 2012, and enabled you to continue collaborating on projects with teammates using Visual Studio 2010 SP1.

#9) New IDE Productivity Features

The Visual Studio 2012 user interface includes an updated look and feel, which is consistent with the latest Microsoft products, and designed to focus your attention on the code. The overall environment has been streamlined, including simplified toolbars, a lightweight Find dialog, and less tab clutter by previewing files rather than opening them during debugging. Using Quick Launch, you can now search the IDE for any menu or command.

New Find Dialog

#10) Improve your code quality with enhanced testing tools

Visual Studio 2012 includes a wealth of testing tools.

Microsoft Test Manager 2012 has been enhanced to embrace exploratory testing (sometimes called agile testing), which allows you to explore the product in any way you want while keeping relevant steps and data that can be used to directly file bugs and feedback:

Lab Management has also been greatly simplified in this release with the consolidation of agents and the introduction of standard environments, which allow you to benefit from build-deploy-test workflows without the dependency on Hyper-V or SCVMM.

With Visual Studio 2012, we now provide the ability for you to include additional adapters to support 3rd party unit testing frameworks such as xUnit.net, NUnit, and others. The new Test Explorer will showcase all of the tests across your solution regardless of which testing framework they were written for. Visual Studio 2012 will continue to provide support for traditional unit tests written using the classic Visual Studio Unit Testing Framework, and adds support for writing tests in C++ as well.

New Test Explorer

#11) Reduce cycle times using tools for agile practices

Visual Studio 2012 contains a variety of tools to create transparency between team members, reduce waste, and accelerate the flow of the project. As you set out to start the project, PowerPoint storyboarding is a useful way to communicate the requirements of the software. When you get further along, the Microsoft Feedback Client can be used to gather feedback on the working bits from external stakeholders.

Team Foundation Server 2012 provides a rich toolset for planning out your sprints, managing the backlog, and tracking progress. I recommend reading my earlier post, where I explored these features in detail. As an example, below is a picture of the taskboard, which can be used to easily edit work items during a standup meeting:

#12) Deliver Cloud-Based Services with Smoother Collaboration between Operations and Engineering

Each release of our ALM tools, we’ve integrated additional roles to improve collaboration across the team, and decrease cycle time. This release, we’re including operations, which is increasingly important for today’s cloud-based services apps. Many of you are already using System Center to monitor your applications in production. This release, we’ve introduced a new management pack, which will allow critical production issues detected by System Center 2012 SP1 to be immediately assigned to the development team with high quality diagnostic information via TFS and Visual Studio.

System Center Operations Manager

These kinds of tools for operations and engineering are something we plan to continue delivering in the future. For example, System Center 2012 SP1 will also introduce “Global Service Monitor” (GSM), which allows you to monitor your application’s functionality, performance, and uptime from multiple endpoints around the world.

Conclusion

I’m very excited for the bits to be out and available for download! As you can see, there are a ton of new capabilities in this release, which is now the best version of Visual Studio we’ve ever shipped. I look forward to seeing all the amazing things that you will do with it. I hope this post gave you a glimpse of what’s in store. To learn more, I invite you to join us on September 12^th for the Visual Studio 2012 Launch event online at http://www.visualstudiolaunch.com/.

Follow me at http://twitter.com/jlzander.

Final Build for VS 2012 - Availability and Launch Dates Ahead

Jason Zander — Wed, 01 Aug 2012 16:00:00 GMT

The final build of Visual Studio 2012 is now complete! The engineering team is finished and is now preparing the build for our numerous distribution channels.

I’d also like to congratulate the Windows 8 team for completing their important release to manufacturing today. You can read more from the Windows team on the Building Windows 8 blog.

I’m looking forward to our next milestone when we make Visual Studio 2012 available for everyone to download from MSDN and elsewhere on August 15^th. Watch my blog for the official release information.

Finally, I’d like to invite you to join Soma and me on September 12^th as we officially launch Visual Studio 2012 via a live online event. For more information, please visit http://www.visualstudiolaunch.com/. I hope you will tune in to learn more about all the new capabilities in VS 2012.

Exciting times ahead!

Follow me at http://twitter.com/jlzander.

My Favorite Features: Entity Framework Code First and ASP.NET Web API

Jason Zander — Mon, 23 Jul 2012 18:59:00 GMT

It’s an exciting time for Entity Framework! Last Thursday, the team announced an open source release, which is now available on the Entity Framework CodePlex Site. I’ve been using Entity Framework quite a bit in my personal development, and thought I’d use this opportunity to continue my “Favorite Features” series with a post on EF.

In this post, I’m going to use the Code First workflow in Entity Framework to build an application. Entity Framework originally shipped as part of the .NET Framework, but in an effort to ship more often the last few versions have been shipped on NuGet, in-between releases of the .NET Framework. In addition to being available on NuGet, the latest version of Entity Framework (EF5) is also included in a number of places in Visual Studio 2012.

As part of building the app, I’ll also use ASP.NET Web API to build an HTTP service. ASP.NET Web API is another favorite feature of mine, and is great way to create services that can be consumed from different clients.

What’s New in EF5

I thought I’d start with a quick recap of the new features in Entity Framework 5, some of which we’ll get to use in this post. I’ve been looking forward to a number of these, and am happy to see them added in the latest release.

New features in Entity Framework 5:

· Enum support is a long awaited feature for EF and allows you to have enum properties in your domain classes. EF5 makes enum support available in the EF Designer and Code First.

· Table-valued functions in an existing database can now be included in models that are created using the EF Designer.

· Spatial data types can now be exposed in your model using the DbGeography and DbGeometry types. Spatial data can be included in models created with the EF Designer or Code First.

· EF5 also includes some significant performance improvements which you can find out more about on the ADO.NET Blog.

The EF Designer, which is included in Visual Studio 2012, also has some new features:

· Models can now be split up into multiple diagrams, which is great for working with larger models. You can also apply coloring to entities to help identify subsections of your model.

· Improvements to the wizard that reverse engineers a model from a database make it easier and quicker to batch import stored procedures for querying data.

Creating the Application

One of the places that EF5 shows up in Visual Studio 2012 is the project template for ASP.NET Web API, so if you create a new ASP.NET Web API project you have Entity Framework 5 available in your project by default.

In this post, I’ll create a simple web application to help folks find interesting tourist attractions. I’ll create a web page to help them locate the tourist attraction closest to a given location. Rather than having the web page communicate directly with the database, I’ll create a Web API to expose the data, so that applications on a variety of platforms can also access the data.

I’ll start by creating a new MVC 4 application, targeting .NET 4.5, and select the ‘Web API’ template.

Building a Model

One of the great things about Code First is that building your model is as simple as defining a set of classes. If needed, you can also supply additional configuration to define what the database looks like and how your classes map to the database.

In the Models folder of my project I’ll add a Models.cs file that contains the following classes.

using System.Collections.Generic;

using System.Data.Spatial;

namespace TouristAttractions.Models

{

public class TouristAttraction

{

public int TouristAttractionId { get; set; }

public string Name { get; set; }

public DbGeography Location { get; set; }

public List<Review> Reviews { get; set; }

}

public class Review

{

public int ReviewId { get; set; }

public string Author { get; set; }

public string Comments { get; set; }

public int TouristAttractionId { get; set; }

public TouristAttraction TouristAttraction { get; set; }

}

Adding an API Controller

Now that I have a model, I’m going to create an API controller that allows me to read and write tourist attractions. An API controller is similar to an MVC controller, except it is consumed as a service rather than hooked up to a set of views.

I need to first build the application before I add a controller. Next I’ll right-click on Controllers folder and select ‘Add->Controller…’ from the context menu. I’ll name the new controller ‘AttractionsController’, and select the ‘API controller with read/write actions, using Entity Framework’ template. This template will generate code that uses Entity Framework to read and write instances of my TouristAttraction class.

I can also specify which Entity Framework context I want to use for data access. A context is a class that represents a session with the database and allows me to read and write data. I haven’t created a context yet, so I’ll select <New data context…> from the list, and a new context will be created for me (I’ll call it TourismContext).

When I complete the Add Controller Wizard, a number of items get added to my project. The new TourismContext that I asked the wizard to create has been added to the Models folder. This class derives from DbContext, which is the primary API of Entity Framework. The context also exposes a DbSet for each type that I want to access. DbContext has a set of conventions to pick a database to try and use, but ASP.NET Web API has overridden these conventions and told my context to load its connection information from the config file (using the “name=” syntax in the constructor).

public class TourismContext : DbContext

{

public TourismContext() : base("name=TourismContext")

{

}

public DbSet<TouristAttraction> TouristAttractions { get; set; }

}

Sure enough, if I look in Web.config I find the TourismContext connection string, pointing my context to a LocalDb database called TourismContext (followed by a timestamp to ensure it doesn’t collide with any previous ASP.NET Web API projects).

</connectionStrings>

Finally, the API controller itself has been added to the Controllers folder. The controller is coded up to support getting all TouristAttractions, finding a TouristAttraction with a certain key, and adding, updating and deleting TouristAttractions. I’ll just show part of the generated code for the sake of brevity:

public class AttractionsController : ApiController

{

private TourismContext db = new TourismContext();

// GET api/Attractions

public IEnumerable<TouristAttraction> GetTouristAttractions()

{

return db.TouristAttractions.AsEnumerable();

}

// GET api/Attractions/5

public TouristAttraction GetTouristAttraction(int id)

{

TouristAttraction touristattraction = db.TouristAttractions.Find(id);

if (touristattraction == null)

{

throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));

}

return touristattraction;

}

...

}

I’ll also add a new GetTouristAttraction method to AttractionsController, that takes some coordinates and finds the closest attraction.

public TouristAttraction GetTouristAttraction(double longitude, double latitude)

{

var location = DbGeography.FromText(
string.Format("POINT ({0} {1})", longitude, latitude));

var query = from a in db.TouristAttractions

orderby a.Location.Distance(location)

select a;

return query.FirstOrDefault();

}

Consuming the Web API

Because ASP.NET Web API uses the basics of HTTP for communication, my service can be consumed from any number of platforms and technologies. As just one example, I’ll build a simple web page that accesses the service from JavaScript.

I’ll replace the contents of Views\Home\Index.cshtml with the following code:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<title>Find Nearest Attraction</title>

src="http://ecn.dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.3&mkt=en-us">

</script>

function search() {

var lat = $('#latitude').val();

var long = $('#longitude').val();

$.ajax({

url: "api/Attractions/?longitude=" + long + "&latitude=" + lat,

type: "GET",

success: function (data) {

if (data == null) {

$('#attractionName').html("No attractions to search");

}

else {

$('#attractionName').html("You should visit " + data.Name);

displayMap(data.Location.Geography.WellKnownText, data.Name);

}

});

}

function displayMap(coordinateString, name) {

// WellKnownText is in format 'POINT (<longitude>, <latitude>)'

coordinateString = coordinateString.replace("POINT (", "").replace(")", "");

var long = coordinateString.substring(0, coordinateString.indexOf(" "));

var lat = coordinateString.substring(coordinateString.indexOf(" ") + 1);

// Show map centered on nearest attraction

var map = new VEMap('myMap');

map.LoadMap(new VELatLong(lat, long), 15, VEMapStyle.Aerial);

// Add a pin for the attraction

var pin = new VEShape(VEShapeType.Pushpin, new VELatLong(lat, long));

pin.SetTitle(name);

map.AddShape(pin);

}

</script>

</head>

<body>

<h1>Find the Closest Tourist Attraction</h1>

<div>

<label for="longitude">Longitude:</label>

<label for="latitude">Latitude:</label>

</div>

</body>

</html>

The main functionality of this page is in the search function. When the user specifies the coordinates to search for, this function uses an HTTP PUT request to ask the service for the closest attraction. The displayMap function then uses Bing Maps to display the data visually.

If I run the project, I can test that the page appears correctly. However, we don’t have any data to display yet:

Now you may be wondering how it connected to the database when I didn’t do anything to create one. Because my database didn’t exist, Entity Framework Code First used a set of conventions to determine what the schema should look like, and created it for me. If I look at my LocalDb instance, I see the new database that it created:

Rest assured, if you don’t like the default conventions there are plenty of options for changing table names, column names, data types and almost every other aspect of the schema that gets created. Code First can also be used to map to an existing database. That is beyond the scope of this post but you can check out the EF Power Tools as a good starting point.

Seeding the Data

Now I want to get some seed data into my database so that we can see the web page working properly. I’m going to use Entity Framework Code First Migrations to do this. The Migrations feature allows me to evolve the database as my model changes (we’ll see this in action shortly), and it also allows me to specify some seed data that should be present in the database.

To start using Code First Migrations, I can use the Enable-Migrations command in the Package Manager Console to switch on Migrations for my TourismContext. Package Manager Console can be opened from the Tools->Library Package Manager menu in Visual Studio.

Enabling migrations has added a new Migrations folder to my project that contains two items:

· Configuration.cs – This file allows me to define settings for how my database is to be migrated. This includes things such as the folder that migrations are generated in, seed data to be applied to the database and registration of providers for third party databases (i.e. MySql).

· <timestamp>_InitialCreate.cs – This is a migration that represents the changes that I’ve already applied to the database (i.e. creation of the TouristAttractions and Reviews tables). The migrations feature has recorded in my local database that this migration has already been applied.

I’ll modify Configuration.cs to specify some seed data in the Seed method. You’ll notice that I’m using the AddOrUpdate method which allows me to specify a property to match on – in my case that is the Name of the TouristAttraction. If Migrations finds an existing TouristAttraction with that name, it will update its current values to match the ones I’ve supplied; if not it will insert a new TouristAttraction.

protected override void Seed(TouristAttractions.Models.TourismContext context)

{

context.TouristAttractions.AddOrUpdate(a => a.Name,

new TouristAttraction

{

Name = "Space Needle, Seattle",

Location = DbGeography.FromText("POINT(-122.348670959473 47.619930267334)")

});

context.TouristAttractions.AddOrUpdate(a => a.Name,

new TouristAttraction

{

Name = "Pike Place Market, Seattle",

Location = DbGeography.FromText("POINT(-122.341697692871 47.6094245910645)")

});

context.TouristAttractions.AddOrUpdate(a => a.Name,

new TouristAttraction

{

Name = "Statue of Liberty, NY",

Location = DbGeography.FromText("POINT(-74.0439682006836 40.6886405944824)")

});

}

Now I can run the Update-Database command from Package Manager Console and the seed data will be applied to my local database. When I run the application, I can see this in action:

Changing the Model

I have a simple application up and running, but it’s likely that my requirements will change over time. For example, I may decide I want to let users provide a Rating when they review an attraction.

public class Review

{

public int ReviewId { get; set; }

public string Author { get; set; }

public string Comments { get; set; }

public int Rating { get; set; }

public int TouristAttractionId { get; set; }

public TouristAttraction TouristAttraction { get; set; }

}

However when I update my model, it no longer matches the database schema that Code First created. If I were to run the application I would get an InvalidOperationException stating that “The model backing the 'TourismContext' context has changed since the database was created. Consider using Code First Migrations to update the database”.

I’ve already enabled Migrations to work with seed data though, so I can run the ‘Add-Migration AddRating’ command to scaffold my pending changes to a new migration, and give it a name (‘AddRating’).

Running this command adds a new <timestamp>_AddRating.cs file to the Migrations folder. This file contains the steps to make my database schema match the current model:

namespace TouristAttractions.Migrations

{

using System;

using System.Data.Entity.Migrations;

public partial class AddRating : DbMigration

{

public override void Up()

{

AddColumn("dbo.Reviews", "Rating", c => c.Int(nullable: false));

}

public override void Down()

{

DropColumn("dbo.Reviews", "Rating");

}

Because this is just scaffolded code, I could edit it. For example, I could create indexes, or add columns or tables that aren’t part of my Code First model. I could also use the Sql method to execute any arbitrary SQL as part of the migration.

For this example the scaffolded code is fine, so I’ll run the Update-Database command in Package Manager Console. This command will check that database to see which migrations have been applied, compare that to the migrations in my project and apply any pending ones. Now that the schema is updated, I can run my application again and everything works just fine.

Conclusion

I hope this post gave you some good insight into Entity Framework Code First and ASP.NET Web API. To learn about Entity Framework, I recommend visiting the Entity Framework Developer Center and the Entity Framework Team Blog. For Web API, please visit http://www.asp.net/web-api.

Enjoy!

Follow me at http://twitter.com/jlzander.

Introducing “Napa” - Office 365 Development Tools

Jason Zander — Tue, 17 Jul 2012 13:00:00 GMT

Yesterday was a very exciting day for Office and SharePoint! The team unveiled plans for the new Office at a press conference, and released a public preview of Office and SharePoint 2013. You can find the press release available on the Microsoft News Center, and watch the video webcast by CEO Steve Ballmer on-demand . You can also download the release at office.com/preview.

But the excitement doesn’t stop there – if you’re a developer you’ll be very happy to hear about the new ways in which you’ll be able to develop for Office and SharePoint.

Office and SharePoint 2013 feature a new Cloud App Model that embraces web standards, and allows you to build a new class of apps that combine web technologies and cloud services, right within Office and SharePoint. One of the primary investments for Office and SharePoint 2013 has been cloud enablement. Apps can be hosted in the cloud, which enables you to deploy, update and maintain your apps more quickly. You also have the ability to publish and sell your apps through a new Office Store, or distribute IT approved apps through an internal App Catalog within your organization. To learn more about the new Cloud App Model and Office Store, I recommend reading Ludovic Hauduc’s announcement and watching the videos on the new Apps for Office and SharePoint blog.

Introducing “Napa”

In sync with yesterday’s Office and SharePoint release, I’m happy to share that we released a preview of a new toolset called “Napa”, which is the easiest way to start building apps for the new Cloud App Model. As we set out to create developer tools for the new Cloud App Model, we took a fresh look at the overall solution we wanted to give to our customers. We wanted to provide a lightweight, in-browser experience, so that you could quickly build your SharePoint or Office web app in the same browser where they would run. Therefore, we created a first-class development environment called “Napa”, as an online companion to Visual Studio.

“Napa” is a free app for SharePoint. Since “Napa” is web based, you don’t need to install anything on your machine to start developing for Office and SharePoint. Just fire up your browser and start coding. As your application matures and you need more advanced tools, you can seamlessly switch to the more powerful, fully featured Visual Studio IDE, and continue developing there. To learn more about the latest advances in Visual Studio 2012 tooling for SharePoint, please visit MSDN.

Of course, in parallel with “Napa”, you can still continue using the existing extensibility models for Office and SharePoint, like VBA, COM, VSTO, and SharePoint solutions. (However, please note that these cannot be submitted to the new Office Store.)

Getting Started

Let’s take a peek at what this all looks like. To give “Napa” a try, first sign up for the Microsoft Office 365 Developer Preview at http://dev.office.com.

When you sign up, a Developer site will be created for you. This site gives you your own instance of Office 365, where you can develop, deploy and test your Office 365 apps.

Next, you’ll want to install “Napa” in order to add the tools to your Developer Site.

(Please visit MSDN for the complete instructions on these “Getting Started” steps.)

Creating a Project

Next (with “Napa” installed on your Developer Site), click on “Get tools to build apps” to launch “Napa”.

“Napa” supports building all of the app types for Office and SharePoint allowing you to run in both the web app and rich client versions of the Office applications (i.e. Excel, Word).

Let’s get started by building an app for SharePoint.

Select “App for SharePoint” and click “Create” and you can start writing the code for your app right in the browser.

As a web developer, one of the first things you’ll notice is that the new Cloud App Model is based on web standards. You’ll spend your time coding in HTML, client-side ASPX, CSS and JavaScript.

Even though “Napa” is a browser based application (that works in all of the modern browsers), we wanted to ensure you had the rich editing experience you would want as a developer. Let’s drill into a few key features of the editor you might not expect from a browser based developer tool.

Reading and Writing Code

We want you to be productive reading and writing code so we’ve added syntax colorization, instance highlighting, indenting, bracket matching and completion as you type.

For example, as you scroll through the code, notice that as you click on an identifier, all of the instances are highlighted in the editor.

Our simple, text based auto complete for JavaScript and CSS includes a rich set of code snippets (CTRL+SPACE). For example, we can use the for loop snippet:

After adding the for loop using the snippet, you can tab through the identifiers and change their names if desired.

We also make it easy to select common values such as true/false, literals and so on in JavaScript and CSS.

Code Cleanup

To help you tidy up your code and ensure correctness, we’ve added the capability to see errors and warnings for JavaScript and CSS. Navigate between the errors by pressing (CTRL+,).

And we have on demand formatting for JavaScript and CSS (CTRL+ALT+F) which allows you to select a block of code and tidy it up.

Code Navigation

To help you navigate your code, we’ve added Find (CTRL+F), Find/Replace (CTRL+H) and the ability to see a quick outline of your code (CTRL+ALT+O), as pictured below.

For the full list of key bindings, hit (CTRL+.). This will bring up a page with a list of all of the keyboard shortcuts.

App Properties

“Napa” allows you to edit your app manifest and properties visually using a lightweight designer for the most common settings. Click on the “Properties” icon in the lower left corner to bring up the designer.

Run

As you looked through Default.aspx and app.js you’ll have seen that the app is a simple page with the string “initializing….” That gets changed to “Hello <username>” after a call to query SharePoint for the current user information succeeds showing that the app integrates back with SharePoint.

In the lower left corner, click the run button to run the app for SharePoint. This will package up the app, add it to your Developer Site and open it in the browser.

In other words, without installing any software on the client machine, “Napa” allows you to create a project, edit the project and run it on SharePoint Online. Since the code is all client side, you can use your browser debugging tools to debug your code. (e.g. F12 in Internet Explorer)

We think this is a big leap forward in simplifying getting started as a developer. You no longer have to install software, notably SharePoint server, on your development machine in order to create your first app.

Opening a Copy in Visual Studio 2012

At some point, you will want to leverage the full power of the Microsoft Office Developer Tools for Visual Studio 2012. For example, one of the key new capabilities in the Cloud App Model is that apps can be hosted on SharePoint, Windows Azure Web Sites or your own web server. Visual Studio will enable you to modify projects started in “Napa” or create new apps from scratch so they can target all of the hosting options. You can also take advantage of the great web development features in Visual Studio 2012 such as the DOM explorer or JavaScript debugger.

To make the transition to Visual Studio seamless, “Napa” will not only allow you to download your project, but it will also help you install any software you need in order to develop apps for Office and SharePoint from Visual Studio.

Click on the “Open in VS” button in the lower left corner.

The first time you use this feature, you will be asked for a language preference that Visual Studio will use if you add server code elements to your project.

When you click “Continue”, you’ll be prompted to run an exe that will check that you have Visual Studio 2012, the Microsoft Office Developer Tools for Visual Studio 2012 - Preview add-in, and all of its dependencies. If you don’t, it will launch the Microsoft Web Platform Installer to install the required software. It will then download and open the project in Visual Studio 2012.

What you’ll notice is that when you run from Visual Studio, the project will already be set up to develop and debug remotely to your Developer Site.

For those of you that know you want to start with Visual Studio, a direct download of the Microsoft Office Developer Tools for Visual Studio 2012 RC - Preview is available here.

Apps for Office

Now that we’ve built an app for SharePoint, let’s go back to “Napa” and build an app for Office. This time, when you create a new project, let’s choose a Content app for Excel.

By default, an app for Office consists of HTML, CSS and JavaScript files reinforcing that the Office Cloud App Model is standard web development.

This time, when we run the app, we run it in the Excel Web App – no need to install the Microsoft Office 2013 Preview in order to build your first app for Office.

We do enable you to run in the Office client applications should you have them installed, that is an option in the Properties designer.

Finally, in addition to apps for SharePoint and apps for Excel, “Napa” also supports creating task pane and mail apps.

Learn More

We’ve just scratched the surface of apps for Office and SharePoint in this post. I recommend visiting the new Apps for Office and SharePoint Developer Center to learn more. And don’t forget to sign up for the Microsoft Office 365 Developer Preview to give “Napa" a try!

Follow me at http://twitter.com/jlzander.

Live from TechEd Europe: LightSwitch HTML Client Preview and Visual Studio 2012 Tools for SharePoint

Jason Zander — Tue, 26 Jun 2012 07:40:00 GMT

This morning I presented the keynote at TechEd Europe 2012 in Amsterdam, and shared some updates on our tools. If you’re not attending the event in person, you can still tune in online. The keynote video recording is available on-demand on Channel9.

The first announcement you’re likely to hear about is our LightSwitch HTML Client Preview release...

LightSwitch HTML Client Preview Availability

At TechEd North America 2012, I showed how LightSwitch is embracing a standards based approach with HTML5, JavaScript and CSS, so you can build companion touch-centric apps that run on multiple devices. This approach allows you to take advantage of the same backend services you’re using across your applications, as well as the productivity gains of LightSwitch.

We’re excited to announce that the LightSwitch HTML Client Preview is available today for MSDN subscribers, and will be available publicly on Thursday June 28^th! To learn more about the release, provide feedback, or ask questions, please visit the LightSwitch Developer Center, team blog, and forums.

Visual Studio 2012 Tools for SharePoint 2010

This morning I also demoed SharePoint tools. With Visual Studio 2012 RC, we’re delivering another compelling release for writing SharePoint 2010 solutions. We’ve developed a rich experience for creating SharePoint lists and content types, so that you no longer need to deal with the complex schema or error-prone hand-editing of XML. Our new SharePoint List Designer allows you to visually and accurately define new lists and content types:

We’re also working hard to make sure that you get the most accurate IntelliSense when working with SharePoint solutions. When developing a sandboxed solution, we now filter to the APIs that are available in production, so that you get immediate feedback on the right APIs to use. We’ve also augmented IntelliSense to parse JavaScript files that are stored in the SharePoint content database, and now provide IntelliSense for the functions and members in those files.

Visual Studio 2012 RC includes several enhancements for Office 365 development, where SharePoint solutions run in a sandboxed process. For example, the Visual Web Part template has been updated to be compatible with the sandbox and can now be safely deployed to Office 365. We’ve also introduced a new Silverlight Web Part template, in case you prefer to define your Web Parts in XAML. Finally, we’ve improved the experience of deploying sandboxed solutions with a new Publish dialog, which allows you to directly publish to Office 365 or any other remote SharePoint Server.

ALM support for SharePoint development continues to improve in the Visual Studio 2012 RC. We’ve expanded our profiling support so that you can get rich information about the bottlenecks in both farm and sandboxed solutions . I also announced previously that we’ll continue to add ALM support in the first Ultimate Feature Pack, which will feature unit testing support as well as support for SharePoint load testing.

Conclusion

I look forward to hearing from you as you have an opportunity to try out these features.

Enjoy the event, and make sure to check out the view the videos online as they become available!

Follow me at twitter.com/jlzander.

What you need to know about developing for Windows on ARM (WOA)

Jason Zander — Tue, 12 Jun 2012 12:40:00 GMT

You’ve probably heard about the new Windows on ARM PCs that will be coming to market with Windows 8. If you’ve been following the TechEd North America coverage, then you’ve also seen these devices in the keynote. In this post, we’re going to cover what this all means for developers.

For an introduction to Windows on ARM, I recommend reading Steven Sinofsky’s post on the “Building Windows 8” blog: Building Windows for the ARM processor architecture. As Steven mentions, ARM testing devices are currently available to a small partner program. However all developers can start preparing their Metro style apps for ARM PCs today.

In this blog post, I’ll walk you through developing an application to run on an ARM PC. What you’ll find is that developing an app for Windows on ARM is the same as developing a Metro style app for x86/64 PCs; that is, the same Metro style app will run on either hardware. Also, many Visual Studio paradigms you’ve come to know from building other application types (designing, testing, debugging, etc.) will carry over to your experience of building Metro style apps. In addition to the walkthrough below, I’ve also recorded a video so you can see this in action:

As Windows hardware has evolved over the years, we’ve been updating Visual Studio to help you build applications that target each version. For example, today you can use Visual Studio to build apps that run on x86 and x64 PCs. You can also use Visual Studio to build apps that run on ARM hardware, including Windows Phone and Windows Embedded Compact. With Windows 8, you will now be able to build apps that target Windows on ARM. (To clarify, Visual Studio itself will not run on ARM, but it will enable you to build apps that run on ARM devices.) For those interested, I’ve provided details on the engineering process at the end of this post, including some history on how we were able to leverage our experience with other chips in the past.

Walkthrough

Let’s see what it looks like to build one of these apps in Visual Studio 2012. Regardless of whether you’re using JavaScript, C++, Visual Basic, or C#, if you’ve built a Metro style app that targets x86/x64 then you already know how to build one that targets ARM. You use the same Metro style project templates, which provide the starting point for building an app.

In this case, we’re going to start with the Windows Blog Reader app, and walk through the process of debugging, testing, and deploying it on an ARM device. You can find tutorials to create this app in JavaScript, C#/VB, or C++.

Remote Debugging

Visual Studio provides the ability to do remote debugging. You’ll need to use this feature when working with an ARM device, since Visual Studio will always be running on an x86/x64 machine. Before you can start remote debugging, you’ll need to install the Remote Tools for Visual Studio 2012 RC onto your ARM device. The first thing we’ll do is launch the Remote Debugger from the device’s Start screen. You may receive a prompt to automatically configure your firewall settings (click Configure to continue).

Next from the toolbar we select “Remote Machine”.

(Note: If you’re using C++, you’ll also need to click the Debug dropdown and select Configuration Manager, and then set Platform to “ARM.”) Visual Studio 2012 will bring up the Remote Debugger Connections dialog. If the device is on the same subnet, then the device will appear under “My Subnet” (or if you are doing it through the project properties window, click the “Find…” button on the Debug tab). Alternatively you can manually configure it by entering the device’s machine name or IP address. Select your machine and then enter your login credentials for the machine if prompted (this will depend on the authentication mode you selected).

Next you’ll see a prompt on your ARM device to acquire a developer license:

Visual Studio will package and deploy your app and then launch it on the ARM device. Making all this happen requires a fair bit of work in MSBuild, the compilers, and the package wizard, but this all happens transparently and allows you to just focus on building your app.

At this point you actually have a remote debugger attached! Let’s set a breakpoint so we can actually see the debugger in action. To do this, press Shift+F5 to stop debugging, and open the DateConverter.cs file. Set a breakpoint on the first line of the Convert method, and press F5 again. (For JavaScript set the breakpoint in the getBlogPosts function in the data.js file, and for C++ set it in the Convert method in DateConverter.h).

You’ll see that execution actually stops at the breakpoint, and you have the full debugger capabilities available (i.e. Stepping, Breakpoints, Locals, Watches, Call Stack, Immediate Window, etc.). In particular notice the Registers window, which is supported for ARM and helps you see how things are running on the device. You can now press F11 to continue to step through the method, and then Shift+F5 to stop debugging.

C#:

C++:

JavaScript:

Unit Testing

Let’s look at how we would add unit tests for our app, and execute them on the ARM device. Right-click the solution and click “Add->New Project”, and select the “Unit Test Library (Metro style apps)” template. Name the project “BlogReaderUnitTestLibrary” and click Ok.

Right-click References and select “Add Reference…”, then click “Solution” and select “WindowsBlogReader”. Update UnitTest1.cs with the following code:

[TestClass]
public class UnitTest1
{
    
    [TestMethod]
    public void ValidateConvertForYearWithValidInput()
    {
        var converterInstance = new DateConverter();

        //checks if Convert method returns the year properly.
        DateTime currentTime = DateTime.Now;
        string actualYear = 
            (string)converterInstance.Convert((object)currentTime, 
                                              typeof(string), "year", "Invariant");
        string expectedYear = DateTime.Now.Year.ToString();
        Assert.AreEqual(expectedYear, actualYear, 
        "The expected year to be returned by the Convert method and the actual returned value are not equal");
    }

    [TestMethod]
    public void ValidateConvertWithInvalidInput()
    {
        var converterInstance = new DateConverter();

        //checks if Convert method throws exception when invoked with a string input.
        string currentTimeSTring = DateTime.Now.ToString();

        Assert.ThrowsException<ArgumentException>(() => 
            (string)converterInstance.Convert((object)currentTimeSTring, 
                                              typeof(string), 
                                              "year", 
                                              "Invariant"),
            "Invoking Convert with a non-DateTime type doesn't throw");
    }
}

Similarly, C++ has a Unit Test Library template for Metro style apps. One key difference to be aware of is C++ unit tests work against a WinMD file and not against an EXE project, so in the case of this walkthrough DateConverter.h would need to be moved to a separate library project and compiled as a WinMD. The Windows Dev Center has more information on how to unit test Metro style apps.

We can use the new Test Explorer to launch our tests by clicking Test->Windows->Test Explorer. (Note this will run the tests on your Visual Studio machine, not on the ARM device.)

The Remote Tools for Visual Studio 2012 RC that we installed earlier include a command-line unit test runner (vstest.console.exe) that we can use to execute our tests on the ARM device. It supports .trx files for offline viewing and sharing of results. (Note that JavaScript Unit Testing is not supported on ARM.) Start by creating an AppX package from your test project (right-click project, click on Store->Create AppX package). Follow the prompts and select “ARM” as the type of package you want to build. Now copy the AppX package to the device (a USB stick can help here). From a command prompt, change to this directory:

%ProgramFiles%\Microsoft Visual Studio\11.0\Common7\IDE\CommonExtensions\Microsoft\TestWindow

Run this command to install the certificate for the AppX:

certutil –addstore root BlogReaderUnitTestLibrary_1.0.0.0_ARM_Debug.cer

Now type the following command:

vstest.console.exe BlogReaderUnitTestLibrary_1.0.0.0_ARM_Debug.appx /logger:trx

The /logger:trx switch creates a trx file which can be used for detailed analysis of the results.

Manual Testing

You can execute manual testing scenarios on your ARM device with the help of Microsoft Test Manager. To do this, you run Microsoft Test Manager on your x86/x64 machine and connect to your remote device. As you test, the bugs that you log have all the diagnostic information collected from the attached ARM device. You can also take screenshots of the device directly from your host machine and auto-create bugs in Team Foundation Server.

Let’s see this in action. Launch the Microsoft Test Tools Adapter service on your device, which is responsible for collecting diagnostic information:

Click ‘Start Service’:

From your host machine, launch Microsoft Test Manager and go to your "Test" center (assuming we have already created test plans and test cases already):

Click the "Modify" link:

Finally, enter the name of the remote device that would like to connect to:

You can also chose to install your WindowsBlogReader app in to the remote device right from the testing center using the "Install Windows metro style App" link. Click "Run" in the toolbar to start the manual testing session. You’ll see a popup message on your device indicating that the manual testing session has started.

Now you can execute the individual test cases, mark them as pass or fail, and log bugs with rich diagnostic info captured directly from the device.

Remote Profiling

Due to their power and size goals, WOA and SoC devices have different CPU, memory and I/O subsystem characteristics than a typical development machine. Performance testing will help guide any tuning that is needed for you to build best-in-class apps for your users to use, on any device.

Let’s look at how we can setup remote profiling to analyze the app’s performance. Click Debug->Start Performance Analysis. You’ll see a note to check the remote machine for UAC prompts (for a program named VSPerf.exe). Accept the elevation prompt on the ARM device, and the application will deploy and run on the remote device with profiling.

The profiler’s now attached, and you can execute your scenario:

Once you’re done working with the app, click Stop profiling. The report will then be copied back to your development machine and opened in Visual Studio.

There are all sorts of ways you can investigate the results – you can zoom on the graph to see results for a particular range of time, you can use the summary page to get a quick view of what was the most expensive parts of the selected time range, and you can drill down on call tree branches and their cost. Here is the Call Tree view:

The Function Details View lets you see a visual representation of the cost of the methods that call the method you are interested in, the breakdown of the methods it calls, and the cost of each line of code executing in the method itself.

It’s also worth noting that remote profiling supports pause and resume functionality just like local profiling does.

Packaging Your App

When it comes time to upload your app to the store, you can build a “Neutral” package if you only have managed code in your app (C#, VB, JavaScript). This indicates that the package contains code that will run on either x86, x64 or ARM. To create the package, right-click the project and select Store->Create App Package.

If you have a mix of both native and managed code, you’ll want to build packages for each of the architectures that you support, including ARM.

Prior to uploading, it’s a good idea to run the Windows App Certification Kit (WinACK) on the actual ARM device, to verify everything works as expected in the target environment. In Visual Studio 2012 RC, we’ve made this easier by providing a single MSI that includes everything you need for installing it on the ARM device. You can get this MSI by downloading the Windows Software Development Kit (SDK) for Windows 8 Release Preview. After installing this SDK, you’ll see a file called “Windows App Certification Kit arm-arm_en-us.msi” under C:\Users\<user>\Downloads\Windows Kits\8.0\StandaloneSDK\Installers. Just copy that file to your ARM device and run it from there.

Behind the Scenes: Engineering for ARM

Designing for ARM

Within the engineering team, we established some design principles for targeting multiple chip architectures. For one, we wanted to abstract most chip differences from developers, with the goal that you can write apps that run on multiple chips without needing to do anything special. Second, we wanted to limit the places within the product that deeply know about chip architectures, with the goal that porting our product to new chip architectures is narrowly defined and straightforward. This enables our team to add new features and scenarios efficiently in the future.

The process of engineering for ARM was different for each language (JavaScript, C++, and C#/VB), based on existing implementation details of the various runtimes and compilers.

JavaScript uses a JIT compiler, so platform targeting is taken care of at runtime. Therefore Metro style apps using JavaScript are platform neutral, and you can write once to run on x86/x64/ARM.

C# and Visual Basic are also abstracted from hardware differences. They compile to MSIL, which is platform neutral. Therefore, Metro style apps using C# or Visual Basic can be compiled once to run on x86/x64/ARM.

C++ is close to the metal, and compiled to the machine language for the platform that you’re targeting. This offers developers full control, but also requires that they specify the hardware where the app will be supported.

Taking these differences into account, we were able to create designs that worked well for each respective language platform.

Engineering Process

The story about how we engineered for ARM begins one decade ago, when we ported the .NET Framework to 64-bit. While we always intended to support multiple chip architectures, this real-world experience was very useful. It motivated design changes that stayed with the product, and that made supporting ARM easier. We also have a lot of experience in the Developer Division writing compilers and runtimes for the ARM architecture itself, through our work with Windows Phone and Windows Embedded. The .NET Compact Framework first shipped 10 years ago and we’ve supplied C++ compilers to build the Windows Embedded Compact operating system since the mid-1990s. Our focus in the phone and embedded space has always been to make code run efficiently on small systems. However, today’s smartphones of today are more powerful computers than desktop computers of a decade ago! A group in Microsoft Research did an experiment running the main desktop .NET Framework on a smartphone, and found that it performs well. Their experience made us confident that our work to port the desktop .NET Framework to ARM would be successful.

As a result of our existing product designs, we were able to support the ARM chip in a relatively straight-forward way. There was no need to make architectural-level changes to accommodate ARM. That said there was still substantial work to do.

For example, we found assumptions in a few source files, where a 32-bit process was assumed to exclusively mean an x86 environment, but it could now also mean ARM. We also experienced the advanced scenarios mentioned in the section above, firsthand.

The biggest challenge was working with pre-release hardware, particularly early in the release. At first, we had to telnet into Windows to get anything done, since we were working with a Windows build without the Windows shell. We soon got a Windows PE build and hardware with video-out, USB and Ethernet. At that point, we could use Windows more like you would expect.

You can see a picture below, of some of the hardware that we used while building Windows 8.

A really exciting aspect of targeting a new platform is that everything is changing at once. The tool stack is one additional piece of movement. It takes a lot of coordinated teamwork to build systems as large and important as Windows 8 and the platform for Metro style apps, and this release couldn’t have happened without the great partnership between the Developer Division and Windows.

Conclusion

In this post, we walked through the process of developing a Metro style app to run on Windows on ARM. We saw that there are very few differences to make your Metro style apps target ARM. We covered a few specific tips that you need to know, such as how to do remote debugging and profiling on the device. Finally, we ended with an inside story on how the team went about enabling it all. I hope that this post helps answers some questions that you might have had, and also helps prepare you for developing apps that target Windows on ARM.

Enjoy!

Follow me at twitter.com/jlzander.

TechEd North America 2012 Keynote News

Jason Zander — Mon, 11 Jun 2012 14:53:00 GMT

We’re here in Orlando this week at TechEd North America 2012, with thousands of developers and IT professionals. If you’re not attending the event in person, you can still tune into the live stream at http://northamerica.msteched.com/. This morning I presented in the Day One keynote. In this blog post, I’ll walk through some of the key announcements and demos I covered.

[UPDATE 6/13/12: You can now find a video recording of the Day One keynote available on Channel9.]

Windows 8 ARM Development

Visual Studio 2012 includes support for building Windows 8 Metro style apps. Along with the Windows 8 release, there will be some exciting new hardware based on the ARM processor. Today, I showed what it looks like to develop an app for one of these devices. For example, below is a screenshot from the debugger where you can see the Registers Windows and Disassembly code for an app running on ARM.

Stay tuned for another blog post tomorrow, where I’ll dive into all the details you need to know about developing for Windows on ARM.

LightSwitch OData Support and SAP

There are a number of other LightSwitch features to be aware of in the Visual Studio 2012 RC, such as the new Cosmopolitan theme and Azure deployment with the latest Azure release. One feature that I’m personally very excited about is the OData support. Last month, in conjunction with SAP, IBM, Citrix, Progress, and WSO2, we submitted OData to the OASIS standards org. OData is a key building block for cloud services. Using LightSwitch in Visual Studio 2012, you can both consume and produce OData feeds. There are many OData providers available that you use with LightSwitch. Today we showed an interesting example of using LightSwitch to consume an OData feed from SAP NetWeaver Gateway, which allows you to programmatically access SAP data and business processes. Below you can see a screenshot of defining a relationship between Customer data from SQL Server and Sales Order information from SAP using the LightSwitch designer. I think this will be a really useful feature for your line of business apps, and I encourage you to try it out.

LightSwitch HTML5 Support

We are working hard to help you build great rich client experiences. At the same time, we understand that many of you are being asked to create applications that can be run on multiple devices. We want you to be able to take advantage of the same backend services in these applications, as well as the productivity gains obtained with LightSwitch. The best way to create companion applications that can run on multiple heterogeneous devices (such as a phones and slates) is to leverage a standards based approach like HTML5, JavaScript and CSS. Today we’re announcing HTML5/JavaScript client development support within LightSwitch to address these scenarios. LightSwitch continues to be the simplest way to create modern line of business applications for the enterprise. This support will be made available in a preview release, coming soon. Stay tuned to the Developer Center for updates. For more information on today’s announcements, please visit the LightSwitch team blog.

Team Foundation Service Public Preview

Today we announced that we’re removing the requirement for an invitation code to the Team Foundation Service. This means anyone can sign up to use the service with no friction. We’ve also introduced a new landing page so that you have a great welcome experience, as well as additional resources. Please visit Brian Harry’s blog for a complete overview of the Team Foundation Service updates we released today.

Global Service Monitoring coming in System Center 2012 SP1

Each release of our ALM tools, we’ve integrated additional roles to improve collaboration across the team, and decrease cycle time. This release (Visual Studio 2012), we’re including operations, which is increasingly important for today’s cloud-based services apps.

Many of you are already using System Center to monitor your applications in production. Today we’re announcing a new capability under the codename “Global Service Monitor”, which will be enabled with System Center 2012 SP1. Global Service Monitor (GSM) allows you to monitor your application’s functionality, performance, and uptime from multiple endpoints around the world.

Today I demonstrated how you can import your web tests created in Visual Studio, and schedule them to run against the production application. Operations can easily assign production issues to engineering, so that the data flows and both roles get the info they need. The engineer can also open those issues right in TFS, and review actionable data like IntelliTrace stack traces with method-level parameters:

Both operations and engineering get to work in tools they’re familiar with, and have easy access to the information that they need. Gone are the days of phone tag, and hours of iterations just trying to understand what the other team is seeing.

Conclusion

There’s lots of exciting news and announcements happening here at TechEd. I encourage you to watch the session videos to learn more about these topics.

Enjoy!

Follow me at http://twitter.com/jlzander.

Gartner Recognizes Microsoft as an ALM Leader

Jason Zander — Sun, 10 Jun 2012 13:30:00 GMT

Gartner recently issued its 2012 Magic Quadrant report for Application Lifecycle Management (ALM). Gartner, one of the world’s top IT research and advising companies, positioned Microsoft in the Leaders Quadrant in the ALM space. You can read more about the Magic Quadrant methodology here.

This graphic was published by Gartner, Inc. as part of a larger research document and should be evaluated in the context of the entire document. The Gartner document is available upon request from Microsoft.

*Gartner does not endorse any vendor, product or service depicted in its research publications, and does not advise technology users to select only those vendors with the highest ratings. Gartner research publications consist of the opinions of Gartner's research organization and should not be construed as statements of fact. Gartner disclaims all warranties, expressed or implied, with respect to this research, including any warranties of merchantability or fitness for a particular purpose.

We’re very excited to share this report, and for the industry recognition of our ALM tools!

Please note that the 2012 Magic Quadrant report is based on an evaluation of Visual Studio 2010. We believe Microsoft’s position as a leader will continue to grow in Visual Studio 2012, where we’re enabling stronger collaboration and reducing waste at each stage of the product delivery. You can find more information on Visual Studio 2012’s features for continuous value delivery in an earlier post.

In the 2012 Magic Quadrant report, Gartner mentions some trends driving companies that demand an integrated team approach, including enterprise agile and cloud computing . Both of these are core aspects of continuous value delivery, mentioned above. These trends are also present in how we’re building software ourselves in Visual Studio, which you can see with Team Foundation Service, the cloud component of TFS.

Success Stories

Beyond the feature lists and analyst reports, when I meet with customers and partners, I often find that people are interested to hear stories about how others have integrated our tools into their software lifecycle. In case you’re interested in the same, below are some recent case studies we’ve compiled with examples from a few companies who have realized the benefits of emerging ALM practices through adopting our ALM solutions:

Conclusion

I hope you find this information helpful as you evaluate our ALM solutions. For further reading, you can find the full independent report, “Gartner: Magic Quadrant for Application Life-cycle Management” at the following link:

http://www.gartner.com/technology/reprints.do?id=1-1ASCXON&ct=120606&st=sb

I also encourage you to visit our new ALM page with further product details at microsoft.com/alm.

Enjoy!

TechEd North America starts next week

Jason Zander — Sat, 09 Jun 2012 01:56:35 GMT

TechEd is our premier conference for developers and IT professionals, and our North America 2012 event starts next week. The event is sold out, and I’m looking forward to joining 10,000 others in Orlando, Florida. :-) I’ll be presenting as part of the Day One keynote on Monday June 11^th at 9am EST. If you’re unable to attend the event in person, you can also watch the live stream online: http://msft.it/LiveStream. Directly after the keynote (around 10:30am EST), I invite you to join me on Channel9 where I’ll be answering questions live onstage. Make sure to tweet your questions with hashtag #ch9live.

I look forward to hearing from you!

Announcing the June 2012 Release of Windows Azure SDK for .NET – Now with Support for Visual Studio 2012 RC

Jason Zander — Thu, 07 Jun 2012 20:01:00 GMT

I’m excited to announce the release of the Windows Azure SDK for .NET – June 2012, which is available for immediate download here. The SDK provides tools for both Visual Studio 2010 SP1 and Visual Studio 2012 RC. Visual Studio 2012 support for the Azure SDK has been a popular request and I’m happy to make this available today in coordination with the June 2012 release of Windows Azure. For more information on today’s platform release, I recommend visiting Scott Guthrie’s blog for the overall announcement, as well as the videos from today’s Meet Windows Azure event.

In Visual Studio, we focus on providing you with the best possible tools to develop your cloud services. There are two ways we go about doing this. One is the productivity tooling features for Windows Azure apps, which I’ll be covering in more detail in this post. The other is the application lifecycle management tools we provide, which help decrease cycle time and enable the team to deploy more quickly (see my previous post on continuous value delivery.) Today we announced new features for developing cloud based services, including continuous integration and continuous deployment. With these new features you can view your deployment history and have it integrated in a nice view:

I encourage you to visit Brian Harry’s blog for a more in-depth walkthrough demonstrating what’s new.

Latest Platform and Tools

Building on from last week’s blog post announcing Visual Studio 2012 Release Candidate, you can now natively build Windows Azure Cloud Services and Windows Azure Web Sites in VS 2012 RC. This follows our principle of delivering tools on a cadence that aligns with the platform. You can also develop solutions that combine Windows Azure projects along with your favorite client projects. You will also have a host of OS options for your developer machine including Windows 7, Windows 2008, Windows 2008 R2, Windows 8 RP and Windows Server 8 RP.

When you develop using Visual Studio 2012 RC you will notice a lighter weight install footprint of the Windows Azure SDK. On a 64bit machine the install package size is roughly 35mb. We were able to do this by enabling the Windows Azure SDK to work with the streamlined IIS Express and SQL 2012 LocalDB development servers that ship with VS2012RC (or chain in as a download for VS 2010 SP1). You will also notice that development with these services will work more seamlessly with little or no configuration and they can run as your signed-in user account. Currently admin-elevation is still a requirement in this release of the tools – this requirement is something we aim to eliminate in future versions. SQL Server Express and the full IIS Server continue to be supported options for local development as well.

In the past, in-place upgrades of the Azure SDKs and tools have been problematic. That’s why we made it a goal of the release to support side-by-side of the SDK starting with November 2011 and later SDKs. You can install SDKs for November 2011 and June 2012 on the same machine, and continue working using the appropriate SDK version for your project. Additionally cloud developers working in a team can use either Visual Studio 2010 SP1 or Visual Studio 2012 RC so long as the matching version(s) of the SDK are installed. These environments are compatible.

Projects

You will notice several updates across our projects. First the Windows Azure project has been renamed to Windows Azure Cloud Service, aligning with updated name of the compute container for our infinitely scalable, multi-tier services. You can also continue to add the Cloud Service to any existing web project using the “Add Windows Azure Cloud Service”. Web project front ends can also be natively published to the new Windows Azure Web Sites Preview compute container. For more information <see this post on WA Web Sites>.

As we create the Azure projects we now add the most common NuGet packages and binary references used in cloud development, namely runtime, diagnostics, storage and configuration. We add a NuGet package specifically for Windows Azure Storage and we add another package for the all new Windows Azure CloudConfigurationManager. CloudConfigurationManager makes it easy to read config settings using a smart algorithm that first checks your cloud configuration (.cscfg) and falls back to web.config/app.config if the config key or config system is not available. I’m excited about this new API because you can more easily access configuration in one line of code, and you will by default leverage a best practice that allows dev-ops to override the config settings in each target environment. NuGet is also a powerful mechanism for cloud developers because it allows you to search our servers for the most up-to-date versions of the Windows Azure client libraries and it also enables update notifications in the NuGet Package Manager.

There are a few new project template options. As I mentioned earlier we support new web template types such as MVC4 and MVC4 Web API. There are also new templates for Worker Role with Service Bus Queue and Cache Worker Role, which optimize your role for these Windows Azure services. Service Bus developers should check out the new Queues and Topics features of the Service Bus node in Server Explorer.

For more advanced situations we added a mechanism to include your custom files and folder structure to be installed into the role along with your cloud service. This allows enhanced customization of what gets packaged and deployed to your roles / VMs. Simply right click on roles in your Azure project and Add -> Item.. or Add -> Folder.

Windows Azure Virtual Machines Preview (IAAS)

Windows Azure Virtual Machines Preview provides a powerful new compute container to run persistent VM workloads. Effectively you can bring your own VM and customize it with the OS and applications of your choice to run your workload. Using the cloud tools in Visual Studio’s Server Explorer you can discover important information about the Virtual Machines that you need at development time. E.g. you can easily explore the names and status of all your virtual machines, you can get the DNS name, and expand to see all the endpoints exposed on specific ports like SQL servers or RDP access. Speaking of RDP, Remote Desktop is a common tool used to configure and troubleshoot environment specific behavior in the cloud environment. Now you can right-click on any Virtual Machine, Web or Worker role in Server Explorer and “Connect using Remote Desktop” if RDP is enabled on the role - without leaving Visual Studio at all.

Windows Azure Caching Preview

Another cool addition in this release is the ability to stand up your own distributed cache service in your roles and ultimately speed up the performance of your cloud service. This cache service will aggregate all instances in your deployment to provide a highly available distributed cache.

Visual Studio makes it incredibly easy to stand up the caching service. Simply open your role in the designer and check a box in the Caching tab to “Enable Caching”. Set a custom cache size value using the slider and customize any other behaviors. An exciting possibility this opens up is to leverage the unused memory and compute power of your existing role instances that you’re already paying for. Alternatively you can use the Dedicated Cache Worker Role template to stand up a role that is fully utilized for caching scenarios.

Leveraging the cache in your clients is easy using the Windows Azure Caching Preview NuGet package. When you add that package it adds the initial boiler plate web.config/app.config required to use Windows Azure instead of the in-memory provider. All you need to do is set the identifier name in the config to match the name of the role containing the cache. Then you can use the Microsoft.ApplicationServer.Caching.* APIs, or with a bit more standard config you can use ASP.NET caching, OutputCache, or SessionCache. More details are covered in this caching how-to guide.

Publishing

Building on improvements to publishing from the Nov 2011 SDK discussed in this Windows Azure Blog post, we added a few options based on developer feedback. First, there is a new deployment option for simultaneous update of instances. This is useful to speed up publishing times for multi-instance deployments if high availability of the service isn’t important (e.g. in a staging environment). This feature walks the instances manually in parallel rather using the default update mechanism that performs updates in one-by-one according to your update domain. Next we decided to have safer defaults for errors – e.g. if an update deployment fails the tool will no longer automatically retry with a delete and new deployment (however this is still an option in Advanced Settings). Last, there has been feedback suggesting that the automatic configuration of connection strings for Diagnostics and Caching at package build and publish time is too opaque, and instead developers would like this configuration to be more explicit and transparent in your project. Therefore we now do explicit one-time string token replacement of the storage connection string. This token replacement writes directly into the .cscfg file in your project giving you complete control and visibility into the change. You also have option to disable this behavior or change the connection string to something else at any time. All of your preferences for publishing and cloud config settings for the target environment can be saved into one or more config files.

For business application developers using Visual Studio LightSwitch, you will see an improved experience for publishing LightSwitch applications to Windows Azure. This includes a consistent experience for streamlined configuration by downloading your publish settings file and performing both your new deployments and deployment updates. Providing SDK tools for LightSwitch aligns with Visual Studio LightSwitch being a core part of Visual Studio Professional and higher editions. For more information please visit the LightSwitch team blog.

Summary

As you can see this is a significant update to the tools you use to develop your cloud applications. We look forward to you getting the SDK and hearing your feedback. For further details check out all the developer resources on the Windows Azure .NET Developer center.

Enjoy!

Follow me at http://twitter.com/jlzander

Announcing Microsoft “Roslyn” June 2012 CTP

Jason Zander — Tue, 05 Jun 2012 18:21:00 GMT

I’m happy to announce a new Microsoft “Roslyn” CTP release, which is available for immediate download here! Roslyn is our long-lead project to rebuild the entire C# and Visual Basic language compilers and Visual Studio language services from the ground up. Long lead projects like these allow us to make larger architectural changes in the product, and enable exciting innovation, while maintaining quality in the product along the way. You can learn more about the Roslyn project on the Visual Studio Developer Center or Soma’s blog. Roslyn is a significant endeavor with three key goals:

Build a cleaner architecture across the compilers and IDE experiences. By exposing a set of public APIs from the compilers that the language services build upon, we’ll no longer need to duplicate code across the compilers and IDEs. Moving forward, this will give us much more agility when introducing new language features.
Enable anyone to build tools or applications that deeply understand source code in the same way that the compilers and IDEs do. In the past, if you wanted to build a tool that works with C# or Visual Basic source code, you were pretty much on your own. Even creating something as simple as a tool to generate HTML for syntax highlighted code was hard. With Roslyn, building such a tool is significantly easier. In addition, Roslyn opens up new scenarios by providing APIs to enable application scripting, something that traditionally has been much more difficult.
Create richer C# and Visual Basic IDE experiences in Visual Studio. Roslyn introduces a stream-lined refactoring experience and several new IDE productivity enhancements that focus on making it easy to make modifications to your code. You can even create your own refactorings! Also, Roslyn introduces a brand new Interactive Window (i.e. REPL, or read-eval-print-loop) that allows users to type code and see it immediately evaluated. This is a powerful way to explore a new API, try out an idea, or even build up pieces of an application.

Ultimately, by providing developers with the infrastructure to build richer “code smart” tools, Roslyn allows us to take the C# and Visual Basic language experiences beyond the current state-of-the-art.

In addition to providing support for Visual Studio 2012 RC, the June CTP includes several new language features and API updates.

Support for Visual Studio 2012 RC

Replacing a compiler that is responsible for running a big chunk of the Internet and rich client applications is not something one does lightly. Our general approach for re-architecting the compilers is to complete them before entering a product cycle. That way, we can use them and ensure they have high quality throughout the cycle. Because of this, Roslyn is not shipping as part of Visual Studio 2012 and will ship in a future VS release instead. However, we want to enable anyone who has VS 2012 installed to explore the Roslyn APIs and use the C# Interactive Window. To allow this, the CTP refresh will install on both Visual Studio 2012 RC and Visual Studio 2010 SP1 (note that VS 11 Beta is not supported).

New Language Features

We haven’t been sitting still and the list of language features supported by C# and Visual Basic is only growing in Visual Studio 2012. However, the Roslyn team is catching up quickly and has been implementing the C# and Visual Basic languages at an extremely fast pace. As each language feature is implemented, we continue to prove the Roslyn architecture by ensuring that it not only compiles, but has great API and IDE tooling support, and works in C# Interactive Window (pictured below).

Since the last CTP, several language features have been implemented, such as query expressions, anonymous types, iterators, and many more!

Updated APIs

Since releasing the first Microsoft “Roslyn” CTP in October, we’ve received tons of great input and have made several positive changes in response to that feedback. A few highlights are listed below:

· New Code Formatting API to automatically format C# or Visual basic source code using the appropriate language formatting rules.

· New Find All References API to find references to symbols within a solution (pictured below).

· New Source Code Generation API to easily generate source code for C# and Visual Basic types and members.

· Numerous API clarifications, renames, and general improvements based on feedback received from the October 2011 CTP.

The following example shows using the new Find All References API to locate all of the references to System.String.

Please note that due to the number of changes, most projects created with the October 2011 CTP will need to be updated to the latest APIs in order to work with them in the new June 2012 CTP.

Conclusion

For more information on the Roslyn project and to download the new CTP, you can visit the Roslyn home page on the Visual Studio developer center. We also invite you to discuss with the team on the Roslyn forum.

Enjoy!

Follow me at twitter.com/jlzander.

June 4th What’s Happening Around Visual Studio

Jason Zander — Mon, 04 Jun 2012 22:37:00 GMT

It’s been a busy week since the RC announcements for Visual Studio 2012, .NET Framework 4.5, and Team Foundation Server 2012.

RC Announcements

In my last post I provided an overview of the latest enhancements across the product. Here’s a rollup of the announcement posts across the team, so that you can explore additional deep dives into the various areas.

Somasegar: Visual Studio 2012 and .NET 4.5 Release Candidates available now!
Brian Harry: Visual Studio/TFS 2012 Release Candidate Available Today
Visual Studio team blog: Visual Studio 2012 RC Available Now!
VS ALM + TFS team blog: Welcome to Visual Studio 2012 ALM Rangers Readiness RC “Wave”
VS ALM + TFS team blog: What's new for Microsoft Test Manager in VS 2012 RC
LightSwitch team blog: What's New in LightSwitch for Visual Studio 2012 RC?
.NET team blog: Introducing the .NET Framework 4.5 RC
BCL team blog: MEF and TPL Dataflow NuGet Packages for .NET Framework 4.5 RC [Nick]
Parallel Programming with .NET blog: What’s New for Parallelism in Visual Studio 2012 RC
Web Development Tools: New Features for Web Development in Visual Studio 2012 RC
Scott Hanselman: Visual Studio 2012 RC is released - The Big Web Rollup
Howard Dierking: Web Optimization in Visual Studio 2012 RC
BlendInsider: Designing Metro style Apps in Blend and VS: What’s New in the RC?
BlendInsider: The Nitty Gritty—Detailed List of what’s new in Blend for Visual Studio 2012 RC
Building Windows 8 blog: Delivering the Windows 8 Release Preview
Windows 8 app developer blog: What’s changed for app developers since the Consumer Preview
Windows Store blog: Windows Store for Release Preview

Developer Tools News Feed

You can also view these real-time in the news feed on the new Developer Tools blog network:

.NET Framework 4.5 Compatibility

I wanted to share a few notes about .NET Framework 4.5 RC, as you set out to evaluate the latest releases. .NET Framework 4.5 RC is part of Windows 8 Release Preview. It is also available as a standalone download for Windows 7, Windows Vista, Windows Server 2008 operating systems.

.NET 4.5 is an in-place update to .NET 4, with same underlying CLR version. This means that once .NET 4.5 is installed on a computer, all .NET 4 apps run automatically on .NET 4.5. We’ve put in a lot of effort to ensure compatibility of .NET 4 apps on .NET4.5 runtime by testing hundreds of apps in our compatibility lab and partnering with our top customers. We’d also like to ask you to test your .NET 4 apps with .NET Framework 4.5 RC and report any issues by using the Visual Studio Feedback Tool or emailing netfx45compat@microsoft.com.

Announcing the Release Candidate (RC) of Visual Studio 2012 and .NET Framework 4.5

Jason Zander — Thu, 31 May 2012 19:19:00 GMT

I’m happy to announce the Release Candidate of Visual Studio 2012, Team Foundation Server 2012, and .NET Framework 4.5. You can find these releases available for download on our Visual Studio product website.

In conjunction with today’s Visual Studio release, Windows has made available a Windows 8 Release Preview. Please visit the Building Windows 8 blog for the official announcement by Steven Sinofsky. You can download the Windows 8 Release Preview bits here.

The complete list of Visual Studio 2012 RC features is available on MSDN. In this post, I’ll summarize the updates we’ve made in Visual Studio 2012 RC, since the beta. Given where we are in the product cycle, these updates are primarily final touches on existing features, responses to beta customer feedback, and improvements to performance. I’ve recorded a video, so you can also see some of these updates in action.

What’s new in the RC since Beta

Logo & Branding

You’ll notice that we’ve updated our product branding from the “11” version number to the 2012 year. This means that the RTM version will release this calendar year!

You will also notice that we’ve updated our Visual Studio logo to the image below:

Setup

One of the first parts of the product you’ll experience is setup. We’ve enabled upgrade from beta to RC, so if you’re using the same product edition (e.g. Professional, Ultimate, etc.), you do not need to uninstall the beta first. Simply run the Visual Studio 2012 RC installer, which will uninstall the right Beta bits and lay down the RC bits, all at once. The only exception is if you’re running on Windows 8 – in that case, you need to first install the Windows 8 Release Preview and then install Visual Studio 2012 RC.

We’ve made some pretty significant investments in improving the setup experience in Visual Studio 2012 RC. Many of you have already seen the streamlined user interface in the beta. From beta to RC, we reduced the installation time by an additional 20%!

We also re-introduced customization into the product. We hope you’ll enjoy these improvements that should save you time and make it easier to get the right bits.

Visual Studio 2012 RC Setup customization UI

Performance

The performance work done between beta and RC was extensive and covers just about every aspect of the product. There were improvements in XAML (compiler, loading documents, and the design surface), debugging, editing large C++ files, Test Lab Management and the list goes on.

To give a few examples, we’ve put together some blog posts detailing the process in the team to identify, fix, and monitor these improvements. The first example we discussed was typing and editing responsiveness. I encourage you to read this post, where you can learn more about the internal performance tools, the product changes that were made, and the resulting impact on responsiveness. In the next post, we’ll cover performance improvements to the Toolbox.

User Interface

The RC includes a series of improvements to the overall UX, which were based on the beta user feedback. I encourage you to visit the Visual Studio team blog for a more comprehensive post with details on these changes.

Visual Studio 2012 RC light theme

After the Visual Studio team post on the above mentioned changes, we received requests for more information on the Visual Studio 2012 dark theme (a personal favorite). Earlier this week, we published a blog post with the roadmap for the dark theme, showing changes in the RC as well as others coming in RTM. I encourage you to take a look and see what’s in store ahead.

IDE

The IDE improvements in RC focus on responses to customer feedback, polishing features, and performance improvements.

We received feedback about the shared scope and options between Quick Find and Find-in-Files in the beta. Since then, we released an extension to help address this in the short term, and have now included that update in the RC release. With the RC, you can now perform a Quick Find without automatically changing the scope setting in Find-in-Files as well.

Solution Explorer is an example of an area where we made some tweaks to round out the experience and polish the feature in RC. We found that the Solution Explorer toolbar was overflowing, so we removed commands that already have other placements in the IDE (e.g. context menus, key bindings, menus) and don’t affect the solution view or project hierarchy.

For large solutions, it can be hard to find items in Solution Explorer. In the RC, we’ve introduced Solution Explorer filtering to help you scope to the relevant content and focus on whatever is important for your current task. This way, you can restrict Solution explorer to show just the files you're currently working with. The new filtering options include Pending Changes and Open Files, and can be found under the button shown below:

Finally, we improved the Quick Launch performance, so that search results are returned nearly instantaneously now.

Metro style apps

If you plan to build Metro style apps, make sure to install Visual Studio 2012 RC on a machine with the Windows 8 Release Preview. There are a number of enhancements for building Metro style apps in the RC release.

Metro style apps using XAML

First off, there are some new Metro style app templates, including a new Windows Runtime Component template for C# and VB developers, and a new DLL project template for C++ developers. There have also been improvements to the existing templates. For example, the templates now fully support keyboard and mouse navigation, in addition to touch. Furthermore, XAML support is now added to the Direct2D template. The XAML Blank App has also been simplified.

The Visual Studio XAML and Blend designers have been enhanced in the RC. You can now preview and edit the design of your Metro style app, for view states such as FullScreenLandscape, FullScreenPortrait, Filled, and Snapped. This is done through the Device panel, which automatically changes visual states when the View is changed. Below you can see an example of the Snapped visual state.

Selecting “Enable state recording” (above) will enable changes made on the Design Surface or Property Inspector to alter the currently selected visual state rather than always making changes to Base.

Adding theme animations from the Animation library in your app’s visual states, is now easy to do using Blend’s visual state design feature. The Animation library is a suite of Metro style animations that has been built specifically to take advantage of the platform’s animation capability. These animations are used throughout Windows UI and are also available for your Metro app. Select the desired state in the States pane, then the storyboard in the Objects & Timeline to see the state storyboard’s properties, including Theme Animations as shown in the screenshot below.

There have been a number of performance improvements for Metro style apps using XAML. Examples include better support for IRandomAccessStream from .NET, more aggressively reclaiming memory upon Metro app suspend, and the introduction of .NET performance testing in the Windows App Certification Kit. We also enabled Multi-Core JIT for Metro style apps and improved the algorithm by which Metro style apps are optimized for performance with NGEN.

Metro style apps using JavaScript

When it comes to editing Metro style Javascript applications, Blend has introduced a host of new features for the RC release. One of these features is a new way to organize Winning Rule in the styles pane, and is called “Arrange by: Source” mode. In this mode you can easily see where all of your element’s CSS properties come from.

We’ve also created editors for simplified editing of gradients and 2D transforms:

Finally, we put a lot of focus on productivity and refactoring gestures. This includes context menus to quickly and easily edit classnames and create CSS rules from an elements ID or classnames. It also includes the ability to cut, copy, paste and clear CSS properties in order to easily enable moving CSS properties in between CSS rules.

For more information on using the RC for Metro style app development, I recommend visiting the Windows 8 App developer blog for a summary of what’s new in the Windows 8 RP for developers, as well as BlendInsider for further details on Blend.

ASP.NET 4.5

ASP.NET Web Forms has been updated to fully support the new async “await” keyword. Page events and control events can now be marked as “async” and utilize the new async support added in .NET 4.5”.

MVC 4 projects now include Entity Framework 5 which has full support for “migrations” allowing developers to keep their code and databases in sync as changes are made.

Enabling Database Migrations in ASP.NET MVC 4 via NuGet Console

ASP.NET MVC now also renders HTML 5 by default so when displaying the Person model the following HTML will be emitted now: id="BirthDate" name="BirthDate" type="datetime" value="5/31/2012 12:00:00 AM"

Web tools

If you’re doing web development, you’ll notice a handful of updates in the RC. First off, we’ve updated some of the project templates. We made the MVC4 Empty template truly empty, and renamed the original empty template to now be called the “Basic” template. We also improved the performance of the New Project creation time.

You’ll also notice some IDE improvements. For example, we now support the ability to run an app from Visual Studio in multiple browsers, through a more discoverable UI.

There’s a host of additional web tooling improvements. For example, HTML and CSS editor enhancements, including updated HTML5 IntelliSense and SVG support. We also updated the publish UI to support incremental database schema preview. The Page Inspector experience has been improved, such that we no longer add web.config appSettings key VisualStudioDesignTime:Enabled, as page inspector will work with server side code as long as it’s in debug mode. For more information on these updates, as well as the complete list of web improvements in Visual Studio 2012 RC, please visit the Web Development Tools blog.

LightSwitch

For LightSwitch projects, there are several new features that we’ve lit up in RC. Last March, we published a preview of the LightSwitch Cosmopolitan Shell & Theme on the VS Gallery to give LightSwitch applications a more modern look-and-feel and corporate branding. Since then, we’ve fixed a significant number of community reported visual bugs and improving readability (such as adding data grid lines). Based on the positive feedback, we’ve now made the Cosmopolitan Shell & Theme the default UI for new projects (shown below).

Another change that we made based on customer feedback was to add the application logo to the login screen for applications using forms authentication. It will show up once you deploy the application. Furthermore, we have significantly improved the performance of core data operations, which in turn improves many application scenarios (querying, paging, loading data in a list/grid, etc.). You can find more information about LightSwitch updates in RC on the LightSwitch team blog and Developer Center.

Team Foundation Server

There were a few updates to TFS since the beta. The first is the ability to use SQL backups of existing Team Foundation Server instances to create (upgrade) a new Team Foundation instance during the initial setup. The second is the ability to automatically add new features to existing projects using older Team Project Templates when upgrading – this has been one of the most requested upgrade features for Team Foundation Server.

The Team Foundation Server team also improved the user interfaces with updates such as the ability to collapse/expand iterations in Team Web access and the addition of personal and favorite queries in pending changes – which makes it simple to drag and drop related work items to a pending checkin.

For more information on the TFS 2012 RC release, please visit Brian Harry’s blog.

Testing Tools

Most of the testing improvements in the RC focused around customer feedback on the beta, as well as a variety of performance and scalability improvements (for example, reducing the size of the output files from test runs and code coverage result).

Coded UI Features

Visual Studio 2012 RC includes a new feature for the analysis of Coded UI Test playback logs, which filters and logs important information for you in a more readable format. Using the actionable information in the Coded UI Test logs, you should able to debug issues more quickly. For example, here’s a picture of the new log, after running a Coded UI Test on a failure case:

Here, you can see a step by step view of all the actions and useful information that were captured by the new logger:

We’ve also made enhancements to the extensibility APIs for Coded UI, to better support integration of 3^rd party controls.

Microsoft Test Manager

To make it even easier to get up and running using Microsoft Test Manager, we’ve integrated a Media Foundation based Video Recorder so you no longer have to install the Expression Encoder to create video recordings of your test cases.

Architectural Tools

In RC the Architecture Tools include new facilities for understanding the structural relationships between elements of the code. You can now use contextual commands on selected code elements in a dependency graph to find, for example, all the types derived directly or indirectly from another type, or the methods that call a selected method:

You can also see what is causing a dependency link between higher level components (e.g. namespaces), by drilling into that link to see the contributing dependency links between subcomponents (e.g. types or methods):

On the UX side, it’s now possible to apply different layouts to the contents of individual group nodes, including a new “List View” compact layout:

“Go Live” License

As with the beta, Visual Studio 2012 RC ships with a “Go Live” license. This means that you can use the product to build apps that run in production. For more information on the “Go Live” terms and how to get support if you need it, please visit the Visual Studio 2012 RC website.

Related Resources

Here’s a list of related resources to help you get started with the RC:

Tell Us What You Think About the RC

As usual, we’re looking forward to hearing from you about your experience with the release. Please feel free to contact us through the following channels:

Ask a question on the Visual Studio or Windows forums
File a bug on the Visual Studio, LightSwitch, or Blend Connect sites (or with the Visual Studio Feedback Tool)
Submit a suggestion on UserVoice

Enjoy!

Follow me at twitter.com/jlzander.

Welcome to the new blog design

Jason Zander — Wed, 30 May 2012 21:30:00 GMT

Redesigning our blogs reminded me of painting the walls at home. It’s one of those things you never have the time to get around to, but are happy when you finally do!

(source)

Here’s a picture of my old blog theme, as a reminder:

We updated the design for a number of the developer tools blogs, and also created a network tying them together. (You can learn more about the new blog network on the Visual Studio team blog.) Beyond updating the style, there were a few things we wanted to do with the redesign. Of course we wanted to make it easy to read, comment on, and subscribe to posts. We also wanted to make it easy to share and discuss the posts with others, by adding social media buttons. Finally, we wanted to provide additional ways to connect with us, by including video and Twitter feeds.

I hope you enjoy this refresh, and the additional integration. I’m looking forward to continuing many more conversations here in the future.

Enjoy!

Follow me at twitter.com/jlzander.

My Favorite Features: Managing Projects with the Backlog, Sprint Planning and Taskboard Features in Team Foundation Server 11

Jason Zander — Tue, 29 May 2012 15:24:00 GMT

In my earlier post on Continuous Value Delivery, I talked about the role that features like the backlog, sprint planning, and taskboard play in tracking requirements and managing the development process. In this post, I’ll dive deeper into what this all looks like in action. I’ve been using these features in my personal coding projects against the new Team Foundation Service preview (http://www.tfspreview.com). However, they will ship as a part of Team Foundation Server 11 as well.

Backlog Management

Each one of my projects has a healthy list of items I need to work on. I use the Visual Studio 11 Scrum process template, so the work items in my list are called Product Backlog Items, or PBIs. If you’re using one of the other available templates, these work items would be known as User Stories, Requirements, or something different. Regardless of the name and definition of the work item, the Product Backlog features work exactly the same.

One of the first things you’ll notice is the new UI we’ve built in our Team Foundation Server web client. It’s designed to be very simple to use and optimized for common tasks like adding new PBIs, assigning PBIs to upcoming iterations, and even forecasting progress through the backlog.

Adding Work

Let’s start with adding and prioritizing work. First off, how do you add something new to the Product Backlog? At the top of the backlog is a small panel we call the “add panel”. You can turn this panel on or off using the view filters on the right side of the page.

Figure 1 – The Add Panel

When turned on, you simply select the work item type, enter a title, and click Add. The new work item is then added to your product backlog above the item you had selected.

Figure 2 - Adding a new PBI

The add panel has a set of defaults associated with it that automatically set work item field values for you. This is nice because it allows you to enter details in your work item forms that aren’t “in your face” each time you want to work with the backlog. (Please note, however, that we don’t allow work item customization on the Team Foundation Service Preview at this time.) Below is a screenshot after the PBI has been added.

Figure 3 - PBI Added

You can also open any work item quickly on the backlog to fill out additional details. In this case, let’s put an estimate on the new requirement we just added. As I’m sure many of you do, I’ve been using the Fibonacci sequence to do my estimating for items on my backlogs. In this case, we’ll add an estimate of three. You can also see in the form that I’m able to add a detailed description to the PBI as well as acceptance criteria that define when this PBI will be done.

Figure 4 - Adding an Effort Estimate

Prioritizing Work

Now that you’ve seen how easy it is to add new work, let’s talk about probably the most common use of the product backlog – prioritizing work. This is where things start to get really fun. Let’s now use our example above and move the new PBI we just added to the top of the backlog. To do this, we’ll just click and drag it up to the top (as pictured below). If we want to move it down, we do the same. It’s really simple.

Figure 5 - Reprioritizing the Backlog

We can also use these drag and drop features to assign work to an upcoming sprint. To place a PBI in an upcoming sprint we simply drag it over to the list of sprints on the left side of the screen, as shown below.

Figure 6 - Sprint Assignment

Once that’s done you’ll notice that the Iteration Path field is updated to reflect the sprint selected. Again, you can see how the UI has been designed to make common tasks like this simple.

Forecasting Progress

The final feature I want to highlight on the on Product Backlog is something called “forecast lines”. What are these forecast lines? Well, they’re simply a way to use your existing velocity (the amount of effort you’re able to complete in each sprint) and overlay that on top of your backlog. By doing this, you can start to forecast how the remaining backlog will lay out over future sprints. Let’s take a look.

I’m going to start by turning on the forecast lines by clicking the forecast toggle just above the backlog. You’ll then notice a set of horizontal lines drawn through your backlog at set intervals. In this example, my velocity is 15 units of effort.

Figure 7 - Forecast Lines

The forecast lines are showing me that based on a forecast of 15, I can complete the first four items on my backlog. The forecast is also telling me that item five on my backlog is too big for me to complete in the next sprint (sprint 5). If this is a problem, I can simply reprioritize by dragging and dropping. I can also change my estimated velocity, as shown below, to see how the forecast changes.

Figure 8 - Adjust Velocity Estimates

It’s important to note that forecast lines aren’t actually changing the plan. For example, you’ll see that the Iteration Path values remain unchanged when the forecast is turned on. Forecast lines are just another tool you can use to help you better understand the work your team is doing.

Planning and Running a Sprint

After your backlog is created and prioritized, the final step is to actually do some work! In our example we’ve already added a few items into Sprint 5. I’m going to now click on Sprint 5 to open the sprint planning view. Here, I can assign work to members of my team, load balance the work across the sprint, and break down each PBI into a set of actionable tasks. There are some options here to help you understand capacity per team member and capacity per activity. But I obviously don’t use those features much for my personal coding project, as I’m just a team of one. J That said, I’d encourage you to check them out as they are designed to help you make a strong commitment to your sprint.

Figure 9 - Planning a Sprint

After my plan is set, I use the taskboard to track progress on my work. The new taskboard is designed to make this really simple. You just drag and drop tasks from left to right as they move from “Not Started”, to “In Progress”, to “Done”. It’s easy to update hours on the board, and you can see your overall progress on the live burndown chart.

Figure 10 - Taskboard

We’re also using these tools ourselves, to develop the Visual Studio product. I’ve included a picture below of one of our own teams here in Redmond using the taskboard during a daily standup.

Figure 11 - Daily Standup

The icing on the cake is that all my tasks for the sprint show up directly in Visual Studio 11 in the My Work pane, as shown below. And when I check-in my changes, the tasks are automatically closed, and the hours zero’d out.

Figure 12 - My Work in Visual Studio 11

Conclusion

As you start using Team Foundation Server 11, I hope your teams find success managing your backlogs and executing sprints with these new features. To learn more, I recommend visiting MSDN. I’m looking forward to hearing your feedback and learning more about your experience with the new tools.

Enjoy!

Follow me at twitter.com/jlzander.

My Favorite Features: Creating Storyboards with PowerPoint

Jason Zander — Thu, 24 May 2012 17:51:00 GMT

In my last post on Continuous Value Delivery, I talked the importance of communication between the customer and the engineering team to arrive at a clear project definition. How many times have you built exactly what was asked for, but not what was wanted? Agile teams need the right communication tools to eliminate waste at this stage in the software lifecycle. In this post, I’d like to talk about PowerPoint Storyboarding, a new feature we built to help express and illustrate the intent of each item on the backlog. As the saying goes, “A picture is worth a thousand words”.

While working on my apps, I need a quick way to mockup UI and test different workflows before I start coding. I have PowerPoint on my machine, which I use all the time for presentations, so it’s quick and easy for me to mock things up there. In my case, these designs were primarily for my own review and brainstorming; however, this becomes even more valuable in a team environment where you can attach and link storyboards directly to items on the backlog.

Prerequisites

Here are the specific prerequisite versions that you’ll need to follow along with this post. [Added May 29, 2012]

To create and modify storyboards by using PowerPoint Storyboarding, you must have installed either Office PowerPoint 2007 or later, and one of the following versions: Microsoft Visual Studio 11 Test Professional Beta, Visual Studio 11 Premium Beta or Visual Studio 11 Ultimate Beta.
To view storyboards that were created using PowerPoint Storyboarding, you must have either Office PowerPoint 2007 or later installed.

Building the Storyboard

Once you have these components installed, just fire up PowerPoint and open up the Storyboarding tab. Click on the Storyboard Shapes button to open the new shapes toolbar (shown below). The shapes in the toolbar work just like traditional shapes in PowerPoint; however, we’ve added some magic to preserve aspect ratios and help make the process of building a Storyboard really easy.

Figure 1 - Storyboard Shapes

The first think you’ll often want to do is add a background. I’ll do this by double-clicking one of the backgrounds from the toolbar. In this case, we’re going to grab the Tablet (landscape) background. If you’re a more advanced PowerPoint user you can place the background on a Layout slide. Next I’ll add a few additional shapes from the toolbar to create the look and feel we’re after.

Figure 2 - Adding a Background

I’m not too concerned about the details on this first slide as I just want to convey intent (in fact we don’t want to make things look too perfect, or the customer might think it’s done ;). Next, I’ll add a slide that speaks more to the feature I’m designing. In this case, I’m building a feature for my app that allows the user to select from a list of options. First, I’ll add a charm bar to the page that I’ll use to access the options.

Figure 3 – Building the Flow

Next, I’ll build out the options page by grabbing a list object, resizing it to fit the screen, and then adding a few on/off toggle buttons, which you might recognize from tablet and phone applications.

Figure 4 – Designing the Options page

As you can see, in just a few slides, the storyboard is beginning to show my plan for the application.

Custom Shapes

I often find that I’m re-using the same group of shapes. I’ve found the “Add to My Shapes” feature very convenient for this. I can highlight all the shapes I added to my options slide and select “Add to My Shapes” from the ribbon (as shown below). This places this new shape into my shapes toolbar so I can re-use it on additional slides. You can even export the shapes to share with other members of your team.

Figure 4 - Custom Shapes

Gathering Feedback

Before you know it, as I continue adding more slides and inserting more shapes, I end up with a PowerPoint presentation that communicates what I’m planning to build. The real beauty here is that I can get things “right” before I invest too much time coding. A storyboard like this can be used to solicit feedback from stakeholders and can even be linked or attached directly to a backlog item. Your customers all have PowerPoint, so it’s a familiar tool that they can easily pick up and use.

One of the most powerful aspects of Storyboarding is that you can convey the flow of the app you’re building interactively, not just with a set of pictures. Because PowerPoint has built in presentation features like slide transitions, you can create a click-through storyboard, which allows customers to navigate between screens and even simulate the application gestures. Add a new slide for each screen, include a bit of animation, and you’ve got something that looks and feels like the real thing.

In fact, a good portion of Visual Studio 11 and Team Foundation Server 11 was spec’d using this tool. I’ve gotten really used to communicating my ideas in this way, and am using this feature all the time now.

Conclusion

I hope you have an opportunity to give PowerPoint Storyboarding a try, and save some time by communicating with these designs in your team. For more information, please read about Storyboarding on MSDN.

Enjoy!

Follow me at twitter.com/jlzander.

Continuous Value Delivery with Visual Studio 11 ALM

Jason Zander — Wed, 23 May 2012 22:30:00 GMT

In the next couple of posts, I’m going to dive into some of my favorite ALM features coming in Visual Studio 11. In this post, I’d like to first provide some framing on the larger context for the release, so you can see how these features fit in.

At each stage of the application lifecycle, it’s important to ensure that you’re accruing value to the customer. Any overhead or waste in the system detracts from this goal. By using the right development tools, you can create transparency between team members, reduce delivery cycle times, and accelerate the flow. With Visual Studio 11, we’re taking our Application Lifecycle Management solution to the next level by enabling stronger collaboration between functional teams and helping reduce waste at each stage of the product delivery. Let’s see what this means for each of the three stages below.

Define

The project starts with defining the requirements. But communicating requirements from the customer to the engineering team is not always easy. How many times have you built exactly what was asked for, but not what was wanted? Your software has to connect all members of the project, using tools that they’re comfortable with. PowerPoint storyboarding is a natural solution for this. (More details coming in the next post.)

Setting out to start the project, there’s a lot of planning required and decisions to make. You need to decide what core customer problems you want to solve and in what priority (product backlog). You also need to check how this fits with your resources (capacity planning) and schedule the work (sprint planning). Finally you need to track progress against the plan and make adjustments as you go (managing tasks). Team Foundation Server 11 provides tools to help with all of these activities, and keep the project on track. I’ll show how this all works in an upcoming post.

Develop

The next phase of the cycle is building the software. During development, we want to make sure we eliminate drift and make the cycle faster. The longer the time between a feature request and the team delivering, the more likely disconnects become. Rather than wait a long time, when it becomes expensive to fix, we want to get feedback early and often. To help with this, Visual Studio 11 introduces a new feedback tool which allows the customer to collect video and audio of the feedback session as well as the action logs. This kind of rich feedback done in a timely way keeps everyone in sync.

In order to deliver high quality products, we need to assess and monitor along the way. Unit testing is a great way to ensure quality in the final product. (You can see my previous post on enhancements to unit testing in the Visual Studio 11 release.) Once the software has been finished by the development team, you need to do your quality assurance passes. For this, you can use the manual and coded testing features from VS 2010, as well as the new Exploratory Testing tools in Visual Studio 11 to help look for additional issues.

Operate

Now we get to the final stage of operating software and delivering its business value. This is where the relationship between the application development and the IT operations teams becomes critical. You need to be able to diagnose issues as they occur in production, and deploy new builds quickly to respond to customer needs. And again, each team needs to be able to work with tools they’re familiar and comfortable with.

In Visual Studio 11, we’ve taken a first step towards adding tools to operate software better. We’ve integrated Preemptive Analytics into the product, which provides production telemetry such as your top crash reports. We’ve also introduced the new management pack, which allows critical production issues detected by System Center to be immediately assigned to the development team with high quality diagnostic information via TFS and Visual Studio. This allows developers and operators to use familiar purpose built tools that still manage to talk to each other seamlessly.

Video

I’ve included a video presentation below, where I talk about these concepts further. I recommend viewing to gain a deeper understanding of the themes discussed in this post, and our Microsoft vision for ALM.

Conclusion

The Visual Studio 11 ALM feature set marks an important step forward in enabling teams to work together more swiftly. However, we also know we’re on a journey. Continuous value delivery means the development cycle doesn’t end for us either. We’re going to be thinking of new features every day, shipping Ultimate Feature Packs, and delivering the same value to you that you deliver to your customers.

My Favorite Features: Unit Testing Enhancements in Visual Studio 11

Jason Zander — Tue, 22 May 2012 19:40:00 GMT

I’ve been writing a set of posts on some of my favorite Visual Studio 11 features that I’m using in my personal development. In my last post, I talked about JavaScript tooling enhancements. In this post, I’d like to talk about the new unit testing features. Unit testing is an important step in the development process, and is something we are doing throughout the team in Visual Studio. I’ve also been writing unit tests while working on my personal coding projects.

Third-Party Test Frameworks

Developers who are passionate about unit testing will often tell you why their favorite framework is the best. With Visual Studio 11, we wanted to give people a top-notch, developer-focused experience that let them use whatever framework they wanted. To add a unit testing framework to your development environment, just install the plugin from the Visual Studio Extension Manager (pictured below) or the Visual Studio Gallery online.

There are many test framework plugins available at this point, including:

NUnit
xUnit.net
MbUnit
QUnit
Jasmine

And of course we still have the built-in test “MS-Test” framework for .NET code, as well as a new framework for C++ code.

Writing Tests with NUnit

Let’s take a look at the example of NUnit. The NUnit team shipped an adapter for Visual Studio 11 Beta on the same day the beta was released and just recently released an update with some important bug fixes. Getting started is as easy as installing the NUnit Test Adapter for Visual Studio 11 Beta here.

In this example, I’m using a test project, which is a .NET Class Library with a reference to NUnit.Framework.dll. Here’s a quick NUnit test to show how this works.

Then click “Run All” in the Unit Test Explorer window and see the results.

This ability to use different third party unit testing frameworks, and even to mix them within a single solution, was a major ask from our customers over the years. Now you can easily extend your experience to let your team use the unit testing engine they prefer.

Running Tests Continuously

As you’re writing tests and code, and running the tests in-between each step, you may find it gets a bit tedious to constantly switch back and forth. In Visual Studio 11, you can now configure the Test Explorer to automatically run unit tests after each successful build. This is a real time-saver because it makes the test run feel like it’s part of the build.

Thinking about your unit tests as part of the build is a natural thing. For a long time, teams have used continuous integration servers to build and run tests for every check-in. Now you can get that same outcome on your local machine.

To turn it on, just toggle the “Run Tests After Build” option in the Test Explorer toolbar.

The nice thing about this feature is that it lets you focus on the code and not on the other tool windows in Visual Studio. Only when things fail do you stop to look around and see what happened.

Debugging a Test When Something Goes Wrong

When a test fails, there are a few ways to figure out what went wrong. First, you can check the test runner, which provides rich exception information. In cases when that’s not enough, it can be useful to view the test with the debugger. With Visual Studio 11, you can debug NUnit tests the same way you debug other managed tests. To do this, simply right click on the test in the Test Explorer and choose “Debug Selected Tests”.

Analyzing My Test Results

There are a number of analytics you may want to perform on your unit tests, and the most common one people use is code coverage. We significantly simplified the experience around collecting code coverage information for your unit tests, and enabled it to work with your 3^rd party unit test projects. As pictured below, let’s select “Analyze Code Coverage” in the Test Explorer.

Now when the run completes, it will open the Visual Studio Code Coverage Results window, and display editor highlighting so I can easily determine where more test coverage may be required.

You can also easily check the coverage for a test (or a set of tests) by right clicking on what you want to analyze and selecting “Analyze Code Coverage”. This can be very handy when adding tests to existing code. The in-editor coverage coloring let you see exactly what parts of your code were run by the tests you selected.

Unit Testing Browser-based Javascript

Part of my recent application was browser based, and used a lot of the new stuff shipping with ASP.NET MVC in Visual Studio 11. If you want to unit test Javascript, you can use QUnit (the unit testing framework used by JQuery) with the Chutzpah adapter available on the Visual Studio Gallery.

As you can see, the QUnit tests are discovered and executed in the same experience as other unit tests. The extensibility of VS 11 unit testing makes supporting additional unit test framework like QUnit as simple as getting (or writing) an appropriate plugin that supports that system.

Unit Testing Native C++ Applications

As mentioned earlier, we also have the ability in Visual Studio 11 to do native unit testing, with a new C++ unit testing framework shipping in the box. We’re really happy to enable this support for our C++ developers, so you no longer need to use the “/clr” flag or fall back to 3rd party frameworks.

Here’s a quick example:

For a full-fledged sample application, I recommend checking out the Hilo project, by the Patterns & Practices team, which now includes native C++ unit tests.

To learn more about native unit testing in Visual Studio 11, please visit MSDN.

Conclusion

In this post, we reviewed a range of new improvements for unit testing. These came about by the team focusing on a couple of key customer goals:

1. Flexibility – Use whatever test framework your team prefers

2. Simplicity & Consistency – Get a simple, consistent experience that lets developers focus on their work

I hope you will have an opportunity to try out the new Visual Studio 11 unit testing features. For more information, please visit MSDN.

Enjoy!

Follow me at twitter.com/jlzander.

My Favorite Features: Improved Tooling in Visual Studio 11 for JavaScript Developers

Jason Zander — Thu, 10 May 2012 19:02:00 GMT

I’ve been working on some coding projects lately, and spending a lot of time in Visual Studio 11. I wanted to start a series to share some of my favorite features that I’ve enjoyed using in the product. One feature that I ended up using a lot, while working with jquery and jquerymobile, is the new JavaScript tooling support.

IntelliSense

The first thing you’ll notice when doing JavaScript development in Visual Studio 11 is IntelliSense. After using it, you might forget that you’re working in a dynamic language! The JavaScript editor has been completely rewritten on top of the same Chakra runtime that ships in IE10, which means that IntelliSense is more responsive, accurate and scalable than ever before.

The engine was designed to accommodate the development of both web and Metro style apps, so that regardless which platform you’re targeting, you’ll get the same rich IntelliSense experience. You can see examples of this in the table below.

Host API	Sample Screenshot
WinRT
WinJS
JavaScript (ES5)
DOM
HTML5

Examples of using IntelliSense against various host-provided APIs

Third-Party Libraries

The JavaScript community is extremely active, and as a result, produces an almost constant flow of reusable components and libraries. This strong ecosystem makes it great to be a JavaScript developer, and we appreciate that everyone has their own favorite libraries. To ensure that a developer’s preferences don’t inhibit their IntelliSense experience, the JavaScript editor has been designed to recognize and support modern third-party libraries so that you get a “native”-like experience when consuming their APIs. You can see examples of this below.

Library

Sample Screenshot

jQuery

RequireJS

+ jQuery

Using the
RequireJS
extension

Examples of using IntelliSense against 3^rd party libraries

These examples highlight a couple of interesting new features that make the IntelliSense support so compelling in VS11:

1) IntelliSense is available for parameters within DOM event handlers

2) Any child scripts that a library requests will be automatically downloaded and made available for IntelliSense

In addition, library authors have the ability to augment the IntelliSense experience (as RequireJS has done in the example above). This way, when a library makes use of a pattern that the IntelliSense engine doesn’t understand the semantics about, the library can provide this information. This ensures that developers continue to get an amazing editing experience while library authors can be as expressive as they want when designing their API.

Enhancing IntelliSense with XML Doc Comments

Despite how accurate IntelliSense is, JavaScript is ultimately a dynamic language. Therefore, there are still times when the value of an object is too ambiguous for the editor to know what you expect to see when accessing it. For those instances, you can provide “hints”, in the form of XML doc comments, which explicitly declare your completion list expectations. This feature has been in Visual Studio for a few releases, and has been enhanced in Visual Studio 11 to make it easier to use.

One neat enhancement is the ability to annotate the value of an object, as opposed to its type (constructor function). Simply provide an example of what the object’s value could be and IntelliSense will take care of the rest. This allows you to define an IntelliSense-only “type” without having to modify your existing API.

options.settingOne being recognized as a Number because of the value annotation

The value attribute can be set to any JavaScript expression which allows you to get as creative as you want in order to ensure you get exactly the IntelliSense you’re looking for.

options.gameCanvas being set to an <canvas> due to the execution of a jQuery selector

Once you get the hang of using doc comments, they can help speed up your development. For more details about how to use them, make sure to read the documentation.

Debugging

Another place where I really felt the difference in Visual Studio 11 was with the JavaScript debugging. It saved me a couple of times!

When you begin debugging your app, you’ll immediately notice a couple of new tool windows: DOM Explorer and JavaScript Console. Both of these windows help you understand the browser’s interpretation of your app and perform quick and iterative updates without having to interrupt your debugging session.

DOM Explorer

Regardless whether you’re developing a web app or a Metro style app, you’re writing your UI in HTML and CSS. Trying to visualize a given page’s DOM, as well as the exact CSS properties needed to style it in the way you want, can become a daunting task for any non-trivial application. With the DOM Explorer, you can easily find an element in the DOM tree (by clicking the Select Element button), view the CSS properties that are applied to it, and tweak them on the fly. I’ve found this makes it a lot easier to perform “guess-and-check” operations on my HTML and CSS that would otherwise have taken a lot of time if I had to keep modifying my code and restarting the debugger.

Viewing a <p> element in the DOM along with the CSS styles that are applied to it

Any change you make will be immediately reflected in your running application. For example, if I change the color property (shown in the Trace Styles tab) of the currently selected <p> tag to “red” and then switch back to my Metro style app, all of the headers will be red.

I can continue to try different colors, experiment with various fonts, or make any other change to my app and get immediate visual feedback on how it would look. Pretty easy!

You can find more information on the DOM Explorer on MSDN.

JavaScript Console

While the DOM Explorer allows visual interaction with your app, the JavaScript Console allows you programmatic access. You can use it to execute any JavaScript expression, which provides a REPL for testing out arbitrary code.

I commonly find myself using the console to test code before adding it to my source. This iterative approach allows me to quickly validate some logic without having to worry about restarting the debugger in between revisions. Like the DOM Explorer, the console’s effects are reflected immediately, so you can view your changes in the running app as you make them.

For more information on the JavaScript Console, including custom console commands, please visit MSDN.

I also recommend visiting the Visual Studio blog for a great post on additional JavaScript debugging enhancements.

Conclusion

Whether you’re a seasoned JavaScript expert, or newly interested in the language, I hope you’ll have an opportunity to try out the new JavaScript tools in Visual Studio 11. Between the rich IntelliSense and the debugging capabilities of the DOM Explorer and the JavaScript Console, there are a lot of new features to explore.

Enjoy!

Follow me at twitter.com/jlzander.

Find out what’s in store for the Visual Studio 11 UI in the RC release

Jason Zander — Tue, 08 May 2012 17:02:00 GMT

After announcing the Visual Studio 11 Beta developer experience, we received considerable feedback on the UI. I want to thank you for all the comments you provided on this topic, and for taking the time to evaluate the beta release. At this point in the product cycle, we’ve been reviewing all of the beta feedback, and working on product updates for RC. Today we’re excited to share what these updates will look like for the UI. I encourage you to read more on the Visual Studio blog, where we’ve summarized the feedback we received on the beta, and showed the UI changes we have in store for RC.

April 27th What’s Happening Around Visual Studio

Jason Zander — Fri, 27 Apr 2012 22:33:00 GMT

Here’s a quick recap of what’s happening around the team.

The “Await” is Over: Async Targeting Pack for Visual Studio 11 now available with .NET Framework 4.0 and Silverlight 5 support

One of the requests we received after shipping Visual Studio 11 Beta (which I discussed in my Frequently Asked Questions post) was async support for projects targeting .NET Framework 4.0 or Silverlight 5. Unfortunately there was a breaking change that caused this to stop working in the Visual Studio 11 Beta. However, yesterday we released an Async Targeting Pack for Visual Studio 11 which fixes this issue. If you’re using Visual Studio 11 Beta and developing a project which targets .NET Framework 4.0 or Silverlight 5, I recommend installing the targeting pack. You can also view the release notes here. Please note that this targeting pack is not required for projects targeting .NET Framework 4.5 or .NET for Metro style apps (just .NET Framework 4.0 or Silverlight 5).

Spring Reading List: March & April Blog Roll

I’ve put together a rollup with some of the top blogs around the team from the past month or two. I hope you’ll find a few that interest you and dive in! Here’s a list of posts on Visual Studio 11:

- Async in .NET 4.5

- .NET Versioning and Multi-Targeting - .NET 4.5 is an in-place upgrade to .NET 4.0

- F# IntelliSense Improvements in Visual Studio 11 Beta

- Round-tripping with Visual Studio 11

- XAML authoring in Blend and VS: Workflow, Tools, and Tasks

- LightSwitch Architecture: OData

- Tips on Upgrading Your LightSwitch Applications to Visual Studio 11 Beta

- SharePoint Developer Tools in Visual Studio 11 Beta – Part III: Tips and Tricks in SharePoint List Designer

- Automatic requirement traceability with Exploratory Testing

- Branching Guide BETA release

We also published quite a few posts on Metro style app development. If you’re developing a Metro style app for Windows 8, these are for you!

- .NET for Metro style apps

- Keeping apps fast and fluid with asynchrony in the Windows Runtime

- Diving deep with WinRT and await

- How to improve performance in your Metro style app

- Tackling performance killers: Common performance problems with Metro style apps

- Managing app lifecycle so your apps feel "always alive"

- Creating a great tile experience (part 1)

- Deploying Metro style apps to businesses

- Build apps with the experts at Windows 8 Dev Camps

Channel9 videos are another good resource to check out, especially the Visual Studio Toolbox series.

Calling all Testers: STAREAST Videos Online

Last week, we participated in a conference for testers called STAREAST. Nearly 1,000 testers from around the world came to learn about the latest testing tools, technologies, and solutions. We delivered two sessions, which are available on-demand on the conference website until July 19, 2012. You can access them for free by registering here. Here are the sessions:

- “Continuous Quality Enablement with Microsoft Visual Studio”, by Matt Nunn (Microsoft)

- “7 Things You Don't Know About Visual Studio for Testers”, by Charles Sterling (Microsoft) & Theresa Lanowitz (voke, inc.)

Testers are an important part of our engineering teams here at Microsoft, and a key audience for our software tools. In each Visual Studio release we’ve added tooling for more roles in the engineering team, helping everyone work together better. For testers using Visual Studio 2010, we added Microsoft Test Manager, coded UI tests, and manual test recording. In Visual Studio 11, we further expanded our support for testers with exploratory testing, and enhancements to Microsoft Test Manager and Lab Management such as support for Metro style applications. Together, these features enable the team to better ensure quality throughout the software lifecycle.

I encourage you to check out the sessions to learn more and see these features in action.

Enjoy!

Follow me at twitter.com/jlzander.

Better Together: TFS 2010 and System Center 2012

Jason Zander — Tue, 17 Apr 2012 16:50:00 GMT

This week, we’re celebrating the launch of System Center 2012 at the Microsoft Management Summit (MMS) in Las Vegas. As part of the launch wave, we released a final version of the System Center Management Pack for TFS Work Item Synchronization, which is available for download here. This version of the management pack works with the current RTM versions of both products: TFS 2010 and the Operations Manager component of System Center 2012. (TFS 11 support will be coming in the future.)

Last year at the TechEd North America keynote I announced the first management pack CTP, and also talked about it in this interview on DotNetRocks. The management pack is designed for enterprises who want tighter collaboration between their development and operations teams. It takes alerts raised by the Application Performance Monitoring (APM) capability within the Operations Manager component of System Center 2012, and synchronizes them with TFS work items. Using the management pack, operations teams can easily forward the APM information directly into TFS as operational work items, and enable engineering teams to more quickly identify the root cause and develop a fix. This dramatically reduces the mean time to repair (MTTR) and helps the DevOps cycle.

Here are a few screenshots, so you can see how this all works. First, the operations staff sees an APM alert from a running application and sends it as a bug directly to the development team:

The fact that the issue goes directly into TFS (and not into email, for example) means that it will be going through the same process as the other bugs that the development team is already tracking and prioritizing. Next, after fixing the bug, the developers can quickly queue up a build for the operations team to deploy to production.

One of the great things about this solution is that the software automatically captures the relevant details that the developer needs to debug the issue. The support engineer doesn’t need to think about what information to collect, or even know what a callstack is. By capturing all this actionable data for the developer, the management pack bridges the worlds of operations and development, makes communication more simple and effective, and reduces friction between the two teams.

The management pack also includes two-way sync between TFS and Operations Manager. This enables visibility into the status of a work item from either product, and allows the operations team to keep track of when a fix might be available.

I’m really happy about our partnership with System Center and the value we’ve created across the two products. The combined strengths of the Visual Studio team in development and the System Center team in operations gives us the assets we need to provide great support for DevOps scenarios. Stay tuned for more news in the future.

If you missed the MMS keynote today, you can watch it on demand here. And don’t forget to download the System Center Management Pack for TFS!

Enjoy!

Follow me at twitter.com/jlzander.

April 12th What’s Happening Around Visual Studio

Jason Zander — Thu, 12 Apr 2012 18:55:00 GMT

Here’s a quick recap of what’s happening around the team.

Releases:

We’ve released some updates for the Visual Studio 11 and TFS 11 betas:

- Visual Studio 11 Beta: VS Update Service

- Team Foundation Server 11 Beta Power Tools (TFS 2010 users might also want to visit Brian’s blog for the latest list of TFS 2010 updates)

If you haven’t downloaded the betas yet, here are a couple of good resources that make it easy to get started:

- Visual Studio 11 Beta ALM Virtual Machine and Hands-on-Labs / Demo Scripts / DemoMates

- Visual Studio 11 Beta Readiness Materials by the ALM Rangers

We’ve had quite a bit of news lately around the work we’re doing to support open source communities. We announced new Git support on CodePlex (in addition to the current TFS and Mercurial support):

- Brian Harry: The Future of CodePlex is Bright

- CodePlex Blog: git commit –m “CodePlex now supports Git!”

We also shared news at DevConnections about open sourcing ASP.NET MVC 4, ASP.NET Web API, and ASP.NET Web Pages (Razor):

- Scott Guthrie: ASP.NET MVC, Web API, Razor and Open Source

- Scott Hanselman: ASP.NET MVC 4, ASP.NET Web API and ASP.NET Web Pages v2 (Razor) now all open source with contributions

For those doing mobile development, an additional release to note is the Windows Phone SDK 7.1.1 Update. This update provides support to use the SDK on Windows 8 Consumer Preview machines, and to develop apps for the new Windows Phone 7.5 256 MB devices:

- Windows Phone Developer Blog: Windows Phone SDK 7.1.1 Update Now Available

Events:

I recently blogged about my keynote at DevConnections, and also about Lang.NEXT which took place on Microsoft campus last week.

This summer, I will be keynoting TechEd North America (June 11-14) and TechEd Europe (June 26-29). We have an extensive content lineup in store, as well as lots of opportunities for networking and product team interaction. I’ve spoken at many TechEd conferences around the world, and I always enjoy connecting with customers and partners at these events. I hope you can join us.

Another event I’m currently involved in is ImagineCup, Microsoft’s student technology competition. ImagineCup is a great opportunity for students to practice their programming skills, and work together in a team to implement new ideas. This year’s ImagineCup competition includes a new Windows Metro Style App challenge, which I will help judge. I look forward to seeing what the students create!

Follow me at twitter.com/jlzander.