May 8th, the Scotia Bank Theatre in Toronto was the scene of ObjectSharp’s annual “At the Movies” event. The event was recorded and over the next few Fridays, you’ll be able to watch the sessions again and ask the questions you may not have been able to previously ask. If you do have a question, ask away – on Twitter using the hashtag #msdev or on Facebook on the Microsoft Developer Facebook page.

This is the second session that is available on demand, with a summary below from the presenter, Canadian MVP Colin Bowern.


image

One of the joys of having an MSDN subscription is being able to keep current with the tooling. With the recent release of Visual Studio 2013 there are a lot of smaller reasons to keep current, and that story keeps getting more compelling with each Update released. In the video below, recorded live at ObjectSharp’s “At the Movies”, I highlighted some of the smaller aspects of the new release that make it compelling to upgrade.

Backwards Compatibility

If you use Visual Studio 2012 today you should be able to jump right into Visual Studio 2013 while the rest of the team upgrades. With backwards compatibility in solution and project format you can get all the goodness in the tools update while the rest of the team catches up. There are still some cases where things were not carried over, but if you are one of the two people still using FrontPage Web Sites it is time to check out ASP.NET Web Pages.

Settings Sync

Whether you get a new workstation or need to rebuild yours one of the time consuming tasks is getting everything setup just the way you want. Now you can optionally sign in with your Microsoft Account to Visual Studio and have key settings synchronize with the cloud including:

  • Development environment settings (the dialog you see on first launch)
  • Theme settings
  • Fonts and colors
  • Keyboard shortcuts
  • Startup options
  • Text Editor options
  • User-defined command aliases

Browser Link

As a web developer we tinker a lot in the browser with markup and styles. The nature of the user agent rendering differences requires the real-time editing to build pixel perfect layouts. The web tooling team knows this all too well and using the power of SignalR created a bi-directional pipeline between the browser and source code called Browser Link. During the session I highlighted:

  • Matching elements in the browser and source code using an Inspect tool
  • Changing element content in the browser and having it reflect in the source using the Design mode
  • Changing CSS (and LESS!) in the browser developer tools and having it Auto-sync with the source code

There was not enough time to show off the ability to identify unused CSS classes, but if you are designing bandwidth sensitive apps then this is a great insight to your stylesheets.

Edit and Continue

With a shift towards 64-bit computing well underway the desire to edit-and-continue during debug sessions regardless of bitness. This change required an underlying CLR change which is one reasons, among others, for .NET Framework 4.5.1. With that in place we can move forward with editing on the fly as we debug. It would be great to see lambda support added now that we have this, so be sure to add your support to see this investment continue.

Return Value Inspection

When trying to inline functions there are times where you want to see the individual return values during debugging:

static void Main()
{
    var result = Multiply(Five(), Six());
}
private static int Multiply(int num1, int num2)
{
    return (num1 * num2);
}
private static int Five()
{
    return 5;
}
private static int Six()
{
    return 6;
}

Next time just pop open the Debug > Window > Autos window and look for the return value there:

Performance and Diagnostics Hub - JavaScript included too!

We have come full circle where performance matters again. The tooling to profile our applications has been built into the IDE for a while now, but it has not always been the easiest to use. With so much emphasis on performance in the mobile and web space the way in which we start profiling apps has had a rethink. The Performance and Diagnostics Hub builds on the investments in Visual Studio 2012 and the subsequent updates to make it easy to understand how your app is performing. As someone who spends a lot of the time in the web one aspect that delighted me was being able to see the ability to trace memory, responsiveness, and CPU usage across the server and browser in the same view.

The release cadence for Visual Studio is speeding up - get the most out of your tools by grabbing the latest today and watch out for exciting updates shipping soon!