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 https://twitter.com/jlzander.

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 https://twitter.com/jlzander.

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 https://twitter.com/jlzander.

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>

    <add name="TourismContext"
         connectionString="Data Source=(localdb)\v11.0; Initial Catalog=TourismContext-20120618160809; Integrated Security=True; MultipleActiveResultSets=True; AttachDbFilename=|DataDirectory|TourismContext-20120618160809.mdf"
         providerName="System.Data.SqlClient" />

  </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">

<html lang="en">

<head>

    <title>Find Nearest Attraction</title>

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

    <script charset="UTF-8" type="text/javascript"

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

    </script>

    <script src="../../Scripts/jquery-1.6.2.min.js" type="text/javascript"></script>

    <script type="text/javascript">

        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>

        <input type="text" id="longitude" size="10" />

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

        <input type="text" id="latitude" size="10" />

        <input type="button" value="Search" onclick="search();" />

    </div>

    <p id="attractionName"></p>

    <div id='myMap' style="position: absolute; width: 400px; height: 400px;"></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 https://twitter.com/jlzander.

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 https://twitter.com/jlzander.

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.

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.

[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 https://twitter.com/jlzander.

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:

• ING DIRECT accelerates innovation with one-click provisioning copies of the bank
• Artizone Artisan Food-Delivery Website Satisfies Changing Tastes with Flexible Development
• QuestionMark: Software Company Boosts Productivity 67 Percent with Virtual Test Labs

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!