I fundamentally believe that there has never been a better time to be a software developer.  In our emerging world where every company is a software company, developers have the awesome role and responsibility of driving forward all kinds of innovation across many different industries.  Whether building apps for enterprises or consumers, whether harnessing the mobility and intimacy afforded by devices or the scale and economy enabled by the cloud, whether pursuing the art of development as a hobby or as a profession, and whether new to the game or a seasoned veteran, developers everywhere have the potential to build creative and compelling solutions that delight and transform the world.  We at Microsoft strive to ensure developers have the tools they need to thrive while doing so.

In that context, we have our Build 2013 developer conference this week in San Francisco, where approximately 5000 developers have gathered in person (with many thousands more watching virtually) from around the world to discuss the next generation of software development with platforms and tools from Microsoft.  These developers have built, are building, and will build amazing and innovative experiences for Windows, from the client to the cloud, doing so productively using the latest suite of development tools and services available in Visual Studio.

I’m excited to share several announcements we’re making today.

Visual Studio 2012 Update 3 Now Available

We launched Visual Studio 2012 in September 2012, and at that time we promised we’d provide more frequent updates to Visual Studio than we had in the past.  Since then, in November we released Visual Studio 2012 Update 1 (VS2012.1), and in April we released Visual Studio 2012 Update 2 (VS2012.2).  Both of these cumulative updates contained significant new features sets, spanning areas such as Windows desktop development, Windows Store development, line-of-business app development, SharePoint development, agile planning and teams, quality enablement, and more.

I’m happy today to announce that this morning we released the third update for Visual Studio 2012: Visual Studio 2012 Update 3 (VS2012.3).  VS2012.3 is an incrementally smaller update than its two predecessors: it includes a few new capabilities, but is focused primarily on bug fixes.  You can find a detailed list of included fixes in the associated Support article.  If you’ve already installed VS2012.2, this update will install on top of it, and if you haven’t, this update includes all of the features from VS2012.1 and VS2012.2, so you can install it on top of either of those or on the RTM release and still get all of the value from those previous updates.  Note that it’s important to install this update if you need to be able to "round-trip" projects between Visual Studio 2012 and Visual Studio 2013, or if you want to run Visual Studio 2012 on the Windows 8.1 Preview.

Visual Studio 2013 Preview and .NET 4.5.1 Preview Now Available

At TechEd North America 2013 a few weeks ago, we announced the next version of Visual Studio, and shared some of the progress we’ve made with Visual Studio 2013 and Team Foundation Server/Service in enabling the modern application lifecycle and DevOps.  We highlighted a few of the many new capabilities in the release, such as support for agile portfolio management, cloud-based load testing, a team room integrated with TFS, code comments integration with TFS, and Git support.

Continuing on that journey, today at Build 2013 we’re unveiling some of the significant advances we’ve made around building stunning apps for Windows.  And in that light, along with Windows 8.1 Preview being released, I’m excited to announce that Visual Studio 2013 Preview and .NET 4.5.1 Preview are now available for download, and as “go-live” releases.

Some of the improvements Visual Studio 2013 contains expand on capabilities introduced in the three Visual Studio Updates we’ve released since Visual Studio 2012 was launched, while many of them are brand new experiences designed with modern, connected, robust, and high-performance applications as a focal point.  While we’ll be exploring many of these improvements this week at Build, I want to highlight a smattering of the capabilities about which I’m personally excited.

.NET

Along with Visual Studio 2013, today we’re announcing .NET 4.5.1.  .NET 4.5.1 is a highly-compatible, in-place update for .NET 4.5 that ships as part of Windows 8.1. The .NET 4.5.1 Preview installs as part of Visual Studio 2013 Preview, is included in all installations of Windows 8.1 Preview, and is also available for separate installation into Windows 8, Windows 7, Windows Vista, and the corresponding Windows Server releases.

Much of our work in this release of .NET is on improving the debugging and general diagnostics experience for developers.  As just one example, .NET developers have been asking for a feature that’s been available to C++ developers for a while: viewing method return values in the debugger, even if those values are never stored into any declared variable.  With .NET 4.5.1 and Visual Studio 2013, this capability is now built-in.  This is particularly useful when you write method invocations inline as parameters to other invocations:

As a more impactful example, one of the long-standing requests we’ve had from developers (who have provided thousands of requests on UserVoice) is to enable “Edit and Continue” for 64-bit; with .NET 4.5.1, this is now available, enabling you to change your running .NET code (whether in a 32-bit or 64-bit process) while stopped at a breakpoint in the debugger, without having to stop and restart the process and with it the debugging experience.

With all of the work we did for C# and Visual Basic in .NET 4.5 and Visual Studio 2012 to enable more productive asynchronous programming, I’m particularly excited about improvements we’ve made in this release to support async debugging (you need to be using Visual Studio 2013 on Windows 8.1 to get this capability, as the debugger relies in part on some new operating system support to enable it).  Previously, it could be very difficult for a developer stopped at a breakpoint to know the asynchronous sequence of calls that brought them to the current location.  Now in Visual Studio 2013, the Call Stack window surfaces this information, factoring in new diagnostics information provided by the runtime.  Further, when an application stops making visible forward progress, it’s often difficult to diagnose and to understand what asynchronous operations are currently in flight such that their lack of completion might be causing the app to hang.  In Visual Studio 2013, the Tasks window (formerly called Parallel Tasks in Visual Studio 2010 and Visual Studio 2012) now includes details on these async operations so that you can break into your app in the debugger and easily see and navigate to everything that’s in flight.

For those of you who develop with JavaScript or C++ and who are eyeing this jealously, you’ll be happy to know that we’ve enabled similar async debugging experiences for both languages!

Beyond diagnostics support, .NET 4.5.1 includes performance improvements, such as support for on-demand compaction of the GC’s large object heap, and faster startup of apps when running on multicore machines.  It also includes support that will enable us to be more agile in how we deliver core capabilities for the .NET development experience in the future.

For more information, I'd recommend starting with Habib Heydarian’s Build talk “What's new in .NET Development”.  Build 2013 sessions will be available for viewing from Channel 9 within a day or so of the session.

C++

One of the biggest requests we’ve had from C++ developers is for more C++11 standard support.  We initially released a CTP of such capabilities in November, and I’m happy to say that those capabilities are now included in Visual Studio 2013 (this is also an area in which we plan to continue investing beyond this release).  This includes C++11 features like delegating constructors, raw string literals, explicit conversion operators, and variadic templates:

This is only one of multiple improvements specific to C++ developers in Visual Studio 2013 (many of the improvements discussed throughout this blog post apply regardless of language).  For example, .NET developers have benefited from the debugger’s “Just My Code” feature for several releases; now in Visual Studio 2013, C++ developers have the option of “Just My Code” support as well, such that the debugger will hide information not relevant to the developer’s code (e.g. in the call stacks window, hiding frames in methods from the CRT), making it easier for the developers to focus in on areas that are most relevant to their debugging needs:

(Left: Without "Just My Code".  Right: With "Just My Code")

The Visual Studio editor includes several improvements specifically for C++, such as support for easily navigating back and forth between code files and their associated header files, and much improved capabilities around the formatting of C++ code:

Other improvements for C++ in Visual Studio 2013 include performance improvements to C++ AMP and the C++ auto-vectorizer; the C++ REST SDK, which is both included in Visual Studio 2013 and available as an open source project on CodePlex; debugging improvements, including mixed-mode debugging between JavaScript and C++ as well as the async debugging support I previously mentioned; improvements around Profile Guided Optimization; and more.

For more information, I'd recommend Tarek Madkour’s Build talk “What’s New in Visual Studio 2013 for C++ Developers”.  And if you’re interested in where things are headed, see Herb Sutter’s Build talk “The Future of C++”.

XAML

Whether using .NET or C++, we’ve improved the development experience for using XAML in Windows Store apps. In addition to some significant performance improvements for the XAML designers in Visual Studio and Blend, we’ve made many improvements to the XAML editor experiences in Visual Studio, including IntelliSense for data binding and resources, “Go To Definition” support for navigating styles, and code snippets. The design experience in Blend now sports guides that allow you to achieve pixel-perfect layouts, and Blend’s improved style editing experience allows you to edit styles and templates in the context of their usages. We’ve also have added design-time experiences for all of the new Windows 8.1 XAML controls like AppBar, Hub, and Flyout, and we’ve updated the Device panel to support authoring for the new view states.

As someone who really values snappy and responsive apps on my devices, one of my favorite new capabilities related to XAML is the XAML UI Responsiveness tool.  In VS2012.2, we introduced the HTML UI Responsiveness tool, focused on profiling the responsiveness of Windows Store apps implemented with HTML and JavaScript; now with Visual Studio 2013, the new XAML UI Responsiveness tool provides similar support for Windows Store apps implemented with XAML, so you can easily track down and fix glitches, freezes, and other performance anomalies in your modern UIs:

And for improved quality of your Windows Store apps, Visual Studio 2013 now also supports coded UI testing with XAML:

For more information about such improvements, the following Build talks should be helpful:

JavaScript and HTML

As with Visual Studio 2012, a lot of effort has gone into support for HTML and JavaScript in this release, in particular around building Windows Store apps (I’ll look at some developer tooling improvements we’ve made for web apps and sites in a subsequent post).  I’ve already mentioned some capabilities, such as the much improved support for async debugging of JavaScript, but the improvements go well beyond that.

To start, the core Visual Studio experienced around JavaScript has been enhanced.  For example, “Go to Definition” now supports navigating namespaces, IntelliSense includes notes about deprecated APIs, and the editor both supports identifier highlighting and includes a navigation bar that makes it easy to quickly jump around in the source.

We’ve also made notable improvements to the DOM Explorer and the JavaScript Console.  For example, the DOM Explorer now supports IntelliSense, search, direct editing, and inline styles, while the JavaScript Console has been augmented to support IntelliSense, object preview and visualization, and multiline function support.

Blend for HTML has also been enhanced this release.  For example, in addition to updates referenced previously when discussing XAML (e.g. rulers and guides for better laying out content), Blend now includes a timeline for animating changes to CSS:

We’ve also made big improvements around diagnostics for Windows Store apps, including but not limited to those implemented with HTML and JavaScript.

For more information on building Windows Store apps with HTML and JavaScript, the following Build talks should be helpful:

Diagnostics

I’ve already mentioned multiple improvements to the diagnostics capabilities of Visual Studio, such as support for async debugging, the new XAML UI Responsiveness tool, 64-bit “Edit and Continue”, and “Just My Code” for C++.  Visual Studio 2013 also now sports a brand new Performance and Diagnostics hub, which makes it easy to find performance and diagnostics tools in one convenient location.

A new tool available from the hub is the Energy Consumption tool.  Battery life is of primary importance to device users, and just as resource consumption of an app in the cloud has an impact of the cost of running that application, so too does the resource consumption of an app on a device have an impact on the battery life of that device.  To assist with this, Visual Studio 2013 includes a new Energy Consumption profiler, which enables developers to estimate how much power their app will cause the device to consume, and why, e.g. a particular region of code utilizing more CPU time than was expected, or a particular pattern of network calls resulting in the device’s radio needing to turn on more frequently than was expected.

Another area of investment has been around managed memory analysis.  Often, developers have an application running in production, and they want to understand what .NET objects exist in the process; this is particularly important when trying to track down a possible memory leak.  Visual Studio 2013 now includes support for analyzing managed heaps, such that a .dmp file can be loaded into Visual Studio, enabling the developer to “Debug Managed Memory”:

The developer is then able to explore the .NET objects in the process, and even compare two different dumps of the same app:

For more information, I suggest the following Build talks:

Connected IDE and Connected Apps

In the past, I’ve talked on this blog about connected apps, with native front-ends that connect up to back-end services in the cloud.  Visual Studio 2013 is one such application, a connected IDE that, for example, knows your identity and will roam/synchronize your settings (e.g. UI theme, keyboard shortcuts, text editor configuration, etc.) from one installation to another via backend cloud services.

Visual Studio 2013 also makes it much easier for you as a developer to create your own connected applications. One key area of investment in this release is around Windows Azure Mobile Services and making it easy to provision, configure, develop, and deliver back-end services for your mobile apps.  From within Visual Studio, you can now easily create new Mobile Services and edit them using the full power of the Visual Studio IDE:

 For more information, I'd suggest starting with the following Build talks:

Developer Experience

We’re continually examining how developers work and what improvements we could make to the core developer experience in the Visual Studio IDE to improve productivity.  Visual Studio 2013 includes several such enhancements.

One such feature is the CodeLens (Code Information Indicators) capability we introduced at TechEd.  This feature brings useful information about types and type members directly into the editor, information such as the references to a particular method, how many tests are referencing a method and how many of them are passing, who last checked in a change that modified a method, and how many changesets impact a method.

Another such feature meant to streamline a developer’s productivity is “Peek Definition.”  Visual Studio already supports “Go To Definition,” which opens a new document window to host the file containing the definition for the referenced symbol, and as of Visual Studio 2012 supports opening this in a “preview” window.  Now in Visual Studio 2013, Peek Definition gives developers the option of viewing inline as part of the current document the file defining the target symbol.

As another example, based on one of the Productivity Power Tools we previously released, the scrollbar for the editor has also been enhanced to show information at a glance about where edits in the file are currently pending, where the last save to the file made changes, where breakpoints are defined, where bookmarks are set, and the like.

I'd recommend Cathy Sullivan’s Build talk “What’s New in the Visual Studio 2013 IDE” for more information about such improvements.

Start Exploring

Beyond the new Visual Studio 2013 application lifecycle management capabilities outlined at TechEd a few weeks back, this post only scratches the surface of what’s new in Visual Studio 2013 Preview.  From new Windows Store app templates, to Python support in Visual Studio, to F# support for portable libraries, to enhancements to ASP.NET (such as the new “One ASP.NET” unified experience), to the latest Office Developer Tools, to significant performance improvements across the IDE… there is a lot more to explore.  And there are many great Build 2013 sessions to help you do so.

You can download the Visual Studio 2013 Preview today, start learning about what it has to offer, and provide feedback to the team about the direction we’re heading and the experiences enabled.  I'd also suggest following the developer tools blogs at http://blogs.msdn.com/b/developer-tools/ for more details about these releases.

Namaste!

Follow me on Twitter at http://twitter.com/ssomasegar.