As an industry trend, advancement in heterogeneous hardware has progressed at a rapid pace. This in turn has fueled developer desire to target such hardware for accelerated computation, necessitating a significant step forward in programming models to enable such practices.
C++ Accelerated Massive Parallelism (C++ AMP) is a new technology implemented in Visual Studio 11 that helps C++ developers use accelerators such as the GPU for parallel programming. I’ve blogged about it since its initial disclosure, including discussing our intention to share the C++ AMP specification so as to help bring general purpose GPU programming to all C++ developers, regardless of whether they’re using Visual C++. I am excited today to deliver on that commitment.
Today at the GoingNative 2012 event, Microsoft announced publication, under the Microsoft Community Promise license, of the C++ AMP open specification. This release means compiler developers and vendors now have the ability to implement C++ AMP in their compilers, just as Microsoft has done, broadening access for C++ developers everywhere to the possibilities offered by heterogeneous hardware.
Please send any feedback you have on this to the C++ AMP team via their blog.
Namaste!
Happy new year.
Over the last several months since //BUILD/, I’ve published multiple blog posts outlining advancements made in Visual Studio 11, from languages to the .NET Framework to IDE productivity to platform-specific tooling. I’m concluding this five-post series with a look at some of the work that’s gone into making Visual Studio 11 a premier system for Application Lifecycle Management (ALM). Since many of these features were first announced at TechEd North America 2011, many individuals from my division have spoken and blogged quite eloquently about the new capabilities, so I’ll use this opportunity simply to highlight a few of these new features and to point you to the other resources they’ve created to describe them in more depth.
The ALM offering in Visual Studio 11 was designed to enable improved collaboration amongst team members, accelerate the adoption of agile processes, and improve the cycle that links development and operations. I’ll take a look at a few examples of how Visual Studio 11 achieves this.
Collaboration
A good example how Visual Studio 11 improves collaboration between developers is the new code review support. Visual Studio 11 includes a significantly overhauled Team Explorer tool window, which includes the new My Work pane that provides a central location for you to see what work you currently have in progress and what other work is assigned to you. As part of this experience, developers are able to request code reviews from teammates (easily shelving the current state of their work), respond to others’ requests, dialog with teammates about reviews, annotate “diffs” for requested code reviews within the Visual Studio editor, and much more.
Collaboration isn’t just about communications between developers, of course. There are many other roles in a software team, and Visual Studio supports collaboration with and between all of those roles. For example, Visual Studio 11 includes a new exploratory testing experience. With formal testing practices, you author your test cases up front and then execute them against your iterative builds. Sometimes, however, you can find additional problems while going “off road” with unscripted testing, problems for which you wouldn’t necessarily have thought to write test cases. In those instances, you still want to be able to capture rich, actionable bug reports – possibly featuring video, audio annotations, screenshots, and the like. And when you do find a bug, you want to be able to automatically turn the repro steps into a test case so that you can formally test it moving forward. This is at the heart of the exploratory testing experience.
Agile Processes
This exploratory testing example also serves as a glimpse into the aforementioned work we’ve done to better enable agile processes in Visual Studio 11. Another such area of investment is our work to improve agile project management. This has been a big focus for Visual Studio 11, and in particular for Team Foundation Server 11. Some of the experiences that are enabled include:
Work in Visual Studio on agile processes goes beyond product management and testing; support has also been added to improve requirements and feedback gathering. For example, the new PowerPoint Storyboarding tool helps you to quickly prototype interfaces:
And the new feedback client makes it easy to get critical input from your stakeholders on your iterative builds:
What’s Next
As I mentioned at the beginning of this post, I’ve only scratched the surface of what is coming in Visual Studio 11 for ALM, and there’s a whole slew of advancements I’ve not touched on, such as support for IntelliTrace use in production, support for continuous testing, and of course the Windows Azure-based Visual Studio Team Foundation Service. I’ve simply highlighted a few features that are more fully explored in other posts, articles, and videos. Here are a few I recommend:
Of course, all of this discussion, and in general everything I’ve covered in this series, is based on the Visual Studio 11 Developer Preview. Since the Developer Preview release at //BUILD/, we’ve been working on further improvements to Visual Studio 11 that we hope to share with you in the near future.
Through my last several blog posts, I’ve highlighted some of the new features in Visual Studio 11 Developer Preview released in September. All of these posts have concentrated on various advancements that span multiple application types: whether you’re building apps for the client or cloud, such language, framework, and IDE productivity improvements are all applicable.
There is a class of improvements we’ve made to Visual Studio, however, that are specific to particular platform technologies. Whether you’re building apps for Windows 8, Windows Phone, Windows Azure, Microsoft Office, or beyond, Visual Studio provides platform-specific tooling to build best-in-class experiences. In this post, I want to highlight just a few of the many such improvements that have come in Visual Studio 11 Developer Preview. We’ve previously talked at length about building apps for Windows 8 and the facilities Visual Studio provides in support of that. Here I’ll help bring to light a few areas we’ve not covered as much: DirectX and SharePoint.
DirectX
It will come as no surprise to many readers that video games are a huge industry, and on Microsoft platforms, DirectX is the foundation for building games. In Visual Studio 11, we worked on improving the game development experience, specifically in three areas: shaders, assets, and debugging.
The first area of improvement centers around making it easier for developers to build “shaders.” A shader is a piece of code that runs on the GPU to calculate rendering effects, and with DirectX, shaders are typically written in High-Level Shader Language (HLSL). Visual Studio 11 includes much improved support for HLSL, from writing and compiling code, to colorization, indenting, and outlining in the editor, to build integration:
Beyond the textual experience, however, is a visual designer that allows you to graphically create effects without having to write the pixel shader code explicitly. This enables experimentation, such that you can see at each stage of the graph what the output is. Here, I’ve graphically created a very simple shader that just takes two constant color values and adds them together:
Visual Studio then supports exporting this graph into HLSL:
You can build some very sophisticated effects in this editor, which also supports a real-time mode that enables viewing effects that change over time. Here’s an example that this feature’s development team used as a test case. While you can’t tell from this still screenshot, many of the nodes in this graph are animating based on the “Time” nodes I’ve highlighted that feed into the graph.
The second area of improvement is around game assets. One of the differentiating factors between developing games and developing many other kinds of apps is that games typically have large numbers of assets that aren’t code. Historically, these files have been largely opaque to developers. If a developer wanted to inspect an image, or tweak a model, the developer would typically need to switch to a completely different toolset or enlist the assistance of the artist/designer. Now with Visual Studio 11, many of these assets (such as .FBX 3D models or .DDS images) can be viewed and manipulated directly in the IDE. While Visual Studio is not meant to be a robust asset creation tool, this support can aid developers in understanding how these assets fit into their games.
The third area of improvement is around debugging. When developing applications with DirectX, traditional CPU-oriented debuggers are often insufficient, as developers need tools to understand the behavior of the GPU rendering pipeline. For example, developers may need to understand why a particular entity is being obscured from view, or why a particular pixel rendered with the wrong color. Visual Studio 11 comes with a set of tools to help debug such errors in code that uses DirectX, tools that enable capturing DirectX frames, getting a history of all of the commands sent to the GPU, seeing all of the events that occurred as part of a specific pixel's rendering, and more.
You can learn more about this debugging experience from the Visual C++ team’s blog.
All in all, game developers should find that Visual Studio 11 Developer Preview provides them with a powerful toolset for improving their time-to-solution and the quality of their results.
SharePoint
SharePoint is a very successful business at Microsoft. As was stated in the keynote of the Microsoft SharePoint Conference 2011 in October, Microsoft has sold over 125 million licenses for SharePoint. Moreover, whereas previously SharePoint was often viewed as a departmental solution, now over 67% of enterprise customers have deployed it for use by everyone in their organizations. Given SharePoint’s success, we strive to ensure that Visual Studio provides a premier experience for developers building custom solutions for the platform.
Visual Studio 2010 saw the introduction of many features that significantly improved development with SharePoint: “F5 debugging” for SharePoint applications, support for IntelliTrace, templates for projects and project items, integration of SharePoint into Server Explorer, and more. Visual Studio 11 keeps this trend going by further enabling this important platform.
One of the more common tasks in SharePoint development is creating lists to store information. In Visual Studio 2010, creating a new list definition involves manually editing XML files to define the details of the list, including its fields, how the list should appear in various views, and so on. In Visual Studio 11 Developer Preview, you can still edit these files manually if you choose to, but that’s no longer required. Instead, the release includes a new List Designer that makes it trivial to define and configure these lists. Here I’m defining an example that would help me track my gift-purchasing for my family and friends this holiday season:
After creating my list from the Add New Item dialog, the new list is added to my solution, and I’m able to configure it with the designer.
Of course, debugging my solution from Visual Studio allows me to see the result of my effort in SharePoint:
Now that I have my solution the way I want it, I can take advantage of another new feature in Visual Studio 11: the ability to publish to remote SharePoint sites (including SharePoint Online in Office 365), and a wizard that makes it easy to do so.
Once published, my solution is available for activation in my SharePoint Online account:
This is just a glimpse into some of the new SharePoint development functionality included in Visual Studio 11. With support for developing web parts in a sandboxed environment, performance and reliability improvements, simplified templates, improved JavaScript Intellisense, and more, Sharepoint development in Visual Studio 11 is that much easier and more enjoyable.
Over my last few posts, I’ve blogged about some of the advances we’ve made for the Visual Studio 11 Developer Preview - improvements to programming languages that enable developers to better express their intents while building efficient solutions, and improvements to the .NET Framework that yield faster, more connected, and more integrated apps.
In this post, I’ll switch gears and take a look at some of the advances we’ve made for developer productivity right within the Visual Studio IDE. This includes enabling improved navigation and code understanding in order to help developers complete their work faster.
Search
One of the more prominent advances in the Visual Studio environment enables developers to quickly discover that key piece of information or functionality they need. Previously, developers would navigate through tool windows, lists, documents, and dialogs looking for a particular file, or a particular option, or a particular assembly to reference, or the right control, or a myriad of other targets. With Visual Studio 11, search is now integrated throughout the IDE via a set of features we affectionately refer to as “Search Everywhere.”
Want to quickly find the right assembly to reference? Search is now integrated into the Add Reference… dialog:
Want to quickly find that important command or option you’ve been seeking? The new Quick Launch feature enables you to search through the thousands of capabilities available in Visual Studio. Not only does Quick Launch help you to discover commands or options, but as you can see in the screenshot below, it also helps you to learn the keyboard shortcuts for the results.
Want to quickly find a particular file somewhere in your solution? The new Solution Explorer search feature enables you to filter by file name. Moreover, Solution Explorer has been augmented to enable peering into the classes and members contained in files, and the tool window’s search capabilities apply to such entries as well.
Have a lot of compilation errors and want to quickly find those matching particular criteria? Search is also available in the Errors tool window:
Some tool windows not only provide search capabilities, but also deeply integrate them with other components of Visual Studio. For example, the new Parallel Watch windows provide a “Filter by Boolean expression” box:
When a Boolean expression is supplied, the debugger will evaluate that criteria for each thread, and only those threads for which the expression evaluates to true will be shown:
As you can see, "search" has become an integral part of the development experience in Visual Studio 11. For more detailed information on what's available, I recommend this blog post from the Visual Studio team.
Find
Closely related to this "Search Everywhere" experience is that of searching the text within your documents. Referred to as “Find,” this experience has been streamlined in Visual Studio 11 to minimize the number of dialogs that developers must deal with, and to minimize the amount of time developers spend away from their code. In Visual Studio 2010, typing ‘ctrl+F’ would bring up the Find and Replace dialog:
Now in Visual Studio 11, the Find experience instead starts with a control integrated directly into the code window:
As shown in this screenshot, I no longer needed to manage a separate dialog, or deal with multiple clicks or separate result windows in order to see the text I was seeking; instead, as I typed into the Find control, matching text in my document got highlighted. In fact, for those of you who know and love .NET regular expressions, you can get such real-time highlighted results as you type in your regex:
The Visual Studio team has posted more detailed information on this new Find experience.
Preview Tab
How many times have you found that your document tab well overflows with open documents? Every time you “Go To Definition” or open a search result in another file, that file will be opened. And that file will remain open until it’s explicitly closed in the editor by the developer. This is true even when the need for that file was temporary, when it was only needed in order to preview the target content.
Enter the Visual Studio 11 Preview Tab. The Preview Tab sits on the right-hand side of the document window and is used over and over again anytime such a preview is needed:
This greatly helps to reduce the clutter we’ve all experienced in the Visual Studio document windows. If you do want previewed content to be more permanent, with a single click you can “promote” the current file from the preview tab into a full-fledged code window.
For a more detailed look at the new Preview Tab, see this blog post from the Visual Studio team.
Project Round-Tripping
Working in a team environment that includes team members using different versions of Visual Studio often requires some finesse. Once one member of the team uses a newer version of Visual Studio to work on a project, that project gets upgraded, and previous versions of Visual Studio aren’t able to use it again. This forces teams to maintain multiple project files in order to support multiple versions of Visual Studio.
With Visual Studio 11, project round-tripping is a first-class feature. Projects created with Visual Studio 2010 can be opened and edited with Visual Studio 11, and most importantly, can then be used again by Visual Studio 2010 (SP1 is required). As long as the projects aren’t modified to use new project capabilities only supported by Visual Studio 11 (e.g. explicitly upgrading a C# application to target the .NET Framework 4.5 instead of the .NET Framework 4), teams don’t have to upgrade all of their Visual Studio installations at once, but instead can have some members of the team using Visual Studio 2010 and some using Visual Studio 11, all running together in harmony.
The Visual Studio Tips and Tricks blog provides more detail on project round-tripping.
And more…
Improvements for code understanding and navigation go well beyond searching, previewing, and project round-tripping.
For example, in Visual Studio 2010, C# and Visual Basic gained a feature known as “reference highlighting,” where clicking on a token in the editor caused the editor to highlight all other uses of that token. In Visual Studio 11, this feature now exists for Visual C++ as well:
In this screenshot, I’ve clicked on one instance of “multiplyBy2”, and all three uses of that token have been highlighted by the IDE. This screenshot also demonstrates the semantic-based code coloring that’s new to Visual C++ in Visual Studio 11. Visual C++ also includes support for code snippets, as well as IntelliSense for C++/CLI. For a good exploration of new IDE productivity features in Visual C++, see this blog post from the Visual C++ team.
IDE support for F# has also been improved in Visual Studio 11. For example, F# developers will enjoy much improved parameter help, such that when typing a function or method call, information on each parameter now appears as you type:
Additionally, developers using Visual Basic will now be able to utilize the Call Hierarchy window. This tool window analyzes a solution for all calls to and from methods, enabling developers to more easily understand how a particular method fits into their design (the new Solution Explorer in Visual Studio 11 also provides some of these capabilities):
For more information on the Call Hierarchy window and its support for Visual Basic, see this blog post from the Visual Basic team.
All in all, the Visual Studio IDE has seen some great improvements in this release. I encourage you to download the Developer Preview and experiment with the IDE, trying out the features I’ve discussed in this post, and seeing what other new gems await you. As always, we’re looking forward to your feedback.
In my first post of this Visual Studio 11 series, I discussed some of the language-level innovation in the Visual Studio 11 Developer Preview. In this second post, I’ll take a look at some of the improvements that have gone into the .NET Framework 4.5 Developer Preview.
Languages enable developers to express their intentions for the behavior of their programs. To be as productive as possible, however, developers rely on runtimes and libraries to encapsulate commonly needed functionality. Our teams have augmented.NET 4.5 significantly to enable developers to be as productive as possible while building out rich, reliable, and high-performance software in managed code. My goal here is not to detail every new feature that’s been included (such an endeavor would warrant an entire book), or even to touch on every area of the Framework that’s been improved. Instead, I simply want to highlight a few additions that I believe are representative of the forward strides we’re making. For a broader look at what’s new in .NET 4.5, I recommend Joshua Goodman’s talk from //BUILD/ as well as the MSDN documentation on the topic.
Performance
For the .NET Framework 4.5, a lot of effort has gone into improving performance, both in terms of improving the performance of existing code as well as into providing new support for writing code that just runs faster, that’s more responsive, and that’s more scalable.
The Common Language Runtime (CLR) team has focused heavily on improving the performance of the runtime environment itself. With additions like background server garbage collection, multi-core background JIT compilation, and profile-guided optimization, managed applications (especially those on the server) can now start faster and run with better throughput and lower latency.
Performance improvements extend beyond the runtime execution environment, as core components throughout the Framework have been rewritten internally to provide improved performance in key scenarios. For example, the Stream class in .NET sits at the heart of most I/O-related operations, and asynchronously reading and writing with Stream is extremely common; these operations now have significantly less overhead in .NET 4.5. As another example, ItemsControl in Windows Presentation Foundation (WPF) has been made much faster at handling certain kinds of data.
This work in streams is part of a larger focus on asynchrony in this release. As I mentioned in my previous post on languages, C# and Visual Basic have both been extended with first-class language support for writing asynchronous code. That support extends well beyond the languages and into the libraries in the .NET Framework. New task-based APIs have been added across the Framework, including in core Base Class Library (BCL) types, throughout the networking and Web services stacks, in the System.Xml and System.Data libraries, and more.
For more information, I recommend the following talks from //BUILD/:
Networking
It’s relatively rare these days to see an isolated application, one that doesn’t communicate in one way or another. .NET has historically been rich with high-quality networking libraries, whether for low-level socket-based programming or for high-level communication via Web services. .NET 4.5 builds upon that foundational support to enable the development of increasingly connected applications. While there are a multitude of interesting networking-related improvements in the .NET Framework 4.5, I want to call attention to three in particular.
WebSockets is a new bidirectional communication protocol that supports low-latency communications between client and server. It's great for implementing interactive applications, such as online games, that benefit from server to client "push," and .NET 4.5 includes support for WebSockets both in ASP.NET and in Windows Communication Foundation (WCF). This release of .NET also sports the new HttpClient class, which enables clients and servers to easily and efficiently consume existing web APIs.
The other advance I want to call attention to is the integration of Tasks with WCF. With the aforementioned language support, asynchronous APIs across the Framework are being exposed via tasks. Beyond these APIs included in .NET, however, there are also APIs generated for you by Visual Studio. One significant source of such APIs is for WCF Web service endpoints, as created by the Add Service Reference… dialog. In previous releases, this tool by default only generated synchronous operations, and you could use the advanced configuration dialog to opt-in to having asynchronous operations exposed. Now in Visual Studio 11 Developer Preview, by default the tool will not only generate asynchronous operations, it will do so using the task-based asynchronous pattern.
This means that all Web services to which you add service references will immediately support being awaited in asynchronous methods. Here’s an example of using one such generated proxy to make asynchronous calls to search Bing:
For more information on the networking improvements in .NET 4.5, I recommend the following talks from //BUILD/:
Interop
A look at advancements in the .NET Framework would not be complete without an acknowledgement that the Framework itself contains only one of the sets of libraries your applications use. In addition to all of the libraries from the .NET Framework that you rely upon, you also rely upon libraries of your own creation and of those created by 3rd-parties. Historically, many of the libraries used in your applications have been thin wrappers on top of operating system functionality exposed by Windows… accessing the file system, accessing audio and video devices, and more. Since the first release of .NET, the CLR has provided the ability to interop with such capabilities, but doing so has rarely been a trivial exercise.
With .NET 4.5 and with the advent of the Windows Runtime (WinRT), the need to create such interop wrappers becomes a thing of the past. Through advancements in the CLR, your .NET applications can reference the metadata files for these components, and the CLR takes care of the interop details necessary to enable you to use these components as you would other .NET libraries. This is a terrific productivity boon for developers.
For more information on the interop improvements in .NET 4.5, I recommend the following talks from //BUILD/:
There is a huge amount of functionality I’ve skipped past and glossed over in this post. The BCL, the Managed Extensibility Framework (MEF), System.Xml, System.Net, WPF, ADO.NET, ASP.NET, WCF, Windows Workflow Foundation, Parallel Computing, and on… they’ve all received good attention in this release, and I’d encourage you to explore on your own to learn more about the work the teams have delivered.
In my last few blog posts, I’ve highlighted significant advancements our teams have made as part of the Visual Studio 11 Developer Preview released at //BUILD/, and I’ll continue that series in future posts. Today, however, I want to highlight some innovative work our teams have been doing that is even more forward looking.
I’m excited to announce that we’ve just released the Microsoft “Roslyn” CTP, which enables the C# and Visual Basic compilers to be used as a service. While we’ve been busy working on C# 5 and Visual Basic 11, via Roslyn we’ve been working concurrently on a complete rewrite of the C# and Visual Basic compilers. Whereas today’s compilers are implemented in native C++, in Roslyn we’ve rewritten the compilers from the ground up, implementing the C# compiler in C# and the Visual Basic compiler in Visual Basic. That in and of itself isn’t entirely noteworthy, as it’s long been a tradition for a language compiler to be implemented in its target language, something that’s been true of both our F# and Visual C++ compilers. What’s quite noteworthy are the scenarios and services this work enables.
Historically, the managed compilers we’ve shipped in Visual Studio have been opaque boxes: you provide source files, and they churn those files into output assemblies. Developers haven’t been privy to the intermediate knowledge that the compiler itself generates as part of the compilation process, and yet such rich data is incredibly valuable for building the kinds of higher-level services and tools we’ve come to expect in modern day development environments like Visual Studio.
With these compiler rewrites, the Roslyn compilers become services exposed for general consumption, with all of that internal compiler-discovered knowledge made available for developers and their tools to harness. The stages of the compiler for parsing, for doing semantic analysis, for binding, and for IL emitting are all exposed to developers via rich managed APIs. As an example, in the following screenshot I’m taking advantage of the Roslyn APIs to parse some code and display the tree of syntax nodes.
The Visual Studio language services for C# and Visual Basic have been rewritten to use these new APIs. And new tools have been introduced to take advantage of all of these services. For example, the new C# Interactive window enables scripting and exploration in C#:
Roslyn represents an exciting opportunity for developers to build richer tools, such as refactorings and deep visualizations, utilizing the same support that Visual Studio and its compilers would use for their work. It should be noted, however, that this is an early look at this compilation infrastructure, as the Roslyn work is focused towards a post-Visual Studio 11 release. This CTP will help to illuminate the kinds of exciting end-to-end experiences that are possible with such technology, but at the same time this particular release only supports a subset of each language and is intended for exploration and to enable us to gather feedback from you on the direction.
For more information on Roslyn, to download the CTP, and to let us know what you think, visit http://www.msdn.com/roslyn.
At the BUILD conference in September, we unveiled developer previews of Visual Studio 11, Expression Blend 5, Team Foundation Server 11, and the .NET Framework 4.5.
We’ve been working on these technologies in earnest since we shipped the previous wave of these development tools last year, and we've had the opportunity to make significant enhancements, across the IDE, frameworks, libraries, languages, and services. Over my next several blog posts, I’ll be sharing with you some of my thoughts on big steps forward we’ve made in various areas of this development tooling, innovations that help to make developers, testers, and anyone involved in the software application lifecycle far more productive in their daily lives.
For this initial post, I’ll be focusing on programming languages and on the enhancements we’ve made both to their expressivity and supporting tooling. Languages exist at the center of everything developers do. Developers often pride themselves on the quality, style, maintainability, and efficiency of the code they write, and they achieve their goals using one or more of many supported languages. As we build our development tools, we keep this mindset front and center, investing heavily in advancing the state of the art for language tooling and expressivity, and enabling developers to achieve their needs with the best code possible.
JavaScript and Interactivity
In Visual Studio 11, JavaScript becomes a first-class language for building Windows and Web applications, all supported by Visual Studio’s best-in-class tooling. In addition to full language support for ECMAScript 5, significantly improved IntelliSense (including much better performance on large JavaScript files and much improved accuracy), editor support for operations like “Go To Definition,” and the full range of debugger support provided for Visual Studio’s other supported languages, Visual Studio now also provides new integrated debugging windows for interacting with the HTML/JavaScript application being debugged.
The new DOM Explorer window enables digging through the HTML Document Object Model (DOM) to explore and manipulate elements, styles, and more.
And the new JavaScript Console window provides a read-evaluate-print loop (REPL) for JavaScript, integrated directly into Visual Studio. This provides a live window into the running application, supporting the evaluation of any JavaScript expression. The results also support visualizers, as shown in the following screenshot:
As the evaluated expressions apply to the current application’s context, you can even define new functions and use those functions directly from the console window:
Of course, in addition to all the work focused on JavaScript in Visual Studio, as I previously blogged about there is a wealth of new support for designing Windows Metro style applications using HTML and JavaScript in Expression Blend 5 Developer Preview.
For more information on these new debugging windows for JavaScript, I recommend Erik Saltwell and Jeff Fisher’s BUILD talk: “Debugging your Metro style apps using HTML”.
C#, Visual Basic, and Asynchrony
Almost a year ago, I blogged about some work done in Developer Division to explore integration of asynchronous programming directly with C# and Visual Basic. I’m excited to say that in the Visual Studio 11 Developer Preview, this is now a part of C# 5 and Visual Basic 11.
It’s long been known that asynchronous programming is how one achieves responsive user interfaces and scalable applications, but such techniques have also been difficult to implement. Such systems remain relatively simple when each operation involves just one asynchronous call, but as our world evolves towards one in which everything is exposed asynchronously, such operations are becoming rare. Instead, developers are forced to write callback after callback of convoluted code in order to navigate even the most trivial of patterns, like one call being made sequentially after another. For years, modern languages have provided us with control flow constructs that were largely unusable when writing asynchronous code. Now, with these new async language features of C# and Visual Basic, developers are able to write asynchronous code as if it were synchronous, all the while using the myriad of control flow constructs provided by these languages, including support for loops, conditionals, short-circuiting, and more.
With these features, we’ve been able to bring Visual Studio’s debugger capabilities along for the ride. For example, when in the debugger we “step over” (F10) a statement containing an await:
it behaves just as you’d expect it to, moving to the subsequent line in the logical control flow, even though that code is likely part of a continuation callback scheduled asynchronously under the covers.
For more information on asynchronous programming support in C# and Visual Basic, I recommend the following talks from BUILD:
C++ and Parallelism
Our teams have spent considerable energy in this release improving C++ support in Visual Studio. This includes not only full support for the C++11 standard libraries, improved IDE support (such as reference highlighting and semantic colorization), and support for building fully-native Windows Metro style applications, but also rich new language and library support for parallelism.
I previously blogged about our efforts around C++ AMP. This is an innovative technology new to Visual C++ in Visual Studio 11 that enables C++ developers to easily write code that leverages massively parallel accelerators (mainly GPUs) as part of their C++ projects. In regular C++ code, a developer can use the parallel_for_each method to invoke a lambda that’s been annotated with “restrict(direct3d)”, which will cause the compiler to generate for that lambda code that targets a DirectX accelerator. In the following example, the parallel_for_each is used to iterate through all indices of the output matrix in order to compute the product of the two input matrices
void MatrixMultiply( std::vector<float>& vC, const std::vector<float>& vA, const std::vector<float>& vB, int M, int N, int W){ array_view<const float,2> a(M, W, vA); array_view<const float,2> b(W, N, vB); array_view<writeonly<float>,2> c(M, N, vC);
parallel_for_each(c.grid, [=](index<2> idx) restrict(direct3d) { int row = idx[0]; int col = idx[1]; float sum = 0.0f; for(int i = 0; i < W; i++) sum += a(row, i) * b(i, col); c[idx] = sum; });}
Not only are the C++ AMP sections of code directly integrated into the source files and expressed using standard C++ syntax, Visual Studio also provides complete debugging support for these kernels, enabling basics like breakpoints and stepping, but also full support across debugger windows like Watch, Locals, and Parallel Stacks, along with the new GPU Threads and Parallel Watch windows.
C++ AMP isn’t the only parallelism-focused effort for native code in Visual Studio 11. The C++ compiler now also automatically vectorizes loops when it determines doing so is valuable. For example, for the following code, the compiler will attempt to utilize SSE instructions on the CPU to run multiple iterations of the for loop as part of a single operation, significantly speeding up the computation:
float a[1000], b[1000], c[1000];…for(int i=0; i<1000; i++) c[i] = a[i] + b[i];
The C++ compiler now also features some auto-parallelization in addition to auto-vectorization. And the parallelism libraries included with Visual C++ have been significantly expanded, including additional concurrent data structures, parallel algorithms, and an updated tasking model similar to that used by the Task Parallel Library (TPL) in the .NET Framework.
For more information on GPU computing support in Visual C++, I recommend Daniel Moth’s BUILD talk: “Taming GPU compute with C++ AMP”. And for a look at some of the other innovation in Visual C++, I recommend Herb Sutter’s BUILD talks “Using the Windows Runtime from C++” and “Writing modern C++ code: how C++ has evolved over the years”.
F# and Data Access
Not all languages need to support every domain and every use case equally: if they did so, there would be little need for more than one language. Often languages end up catering to specific domains and specific styles of development, and I’m particularly excited about our investments in a language that’s a great example of this principle: F#. With F# 2.0 in Visual Studio 2010, we provided a language focused on accelerating solutions for computationally-complex problems. With F# 3.0 in Visual Studio 11, we continue the trend of focusing on a particular problem domain by directly integrating support for solving data-complex problems.
F# is a statically-typed language, just as are C# and Visual Basic, and this static typing provides many advantages. It supports an improved development experience by enabling features such as accurate IntelliSense. It can yield better performance due to more optimizations available at compile-time. It can also reduce development and testing costs by eliminating some common categories of bugs.
However, there are also times when static typing leads to needing more code than its dynamic counterpart. As a prime example, the world is extremely information rich, something that we’re experiencing more and more in our daily software lives. All of this data typically enters our programs in a non-strongly-typed way, and it first needs to be parsed and massaged into strongly-typed objects before it’s exposed to the rest of the program. Rather than a developer coding such import routines manually, this problem has been addressed historically by design-time code generation (e.g. a design-time tool to import a Web service description and generate the necessary proxy code). Unfortunately, there are problems with this approach. It interacts poorly with the evolving nature of data sources, such as those on the web. It can lead to very bloated client proxies (types are generated to represent the entire schema and metadata, regardless of whether or not the client program uses them). And it does not have a smooth integration with scripting environments, such as the F# Interactive window in Visual Studio.
With the new Type Provider mechanism in F# 3.0, such data access becomes trivial for F# programs and components. Also, because F# targets the .NET Framework, applications written in C# or Visual Basic (or any other managed language) can utilize this new functionality via an F# component. Using an extensibility mechanism of the F# compiler, type providers in effect provide data access libraries on demand, yielding a computed space of types and methods at design-time and compile-time in a manner that supports IntelliSense and that is extensible. F# 3.0’s libraries include type providers for OData, WSDL, and SQL (via both LINQ to SQL and LINQ to Entities), but custom type providers may also be written to target arbitrary data sources, such as SharePoint lists and WMI providers.
As an example, consider a desire to search the Netflix catalogue for a handful of people that share my “S.” moniker. Netflix exposes an OData feed, which can then be used with the OData type provider:
open Microsoft.FSharp.Data.TypeProviders[<Generate>]type netflixCatalog = ODataService<"http://odata.netflix.com/Catalog/">let netflix = netflixCatalog.GetDataContext()
query { for person in netflix.People do where (person.Name.StartsWith "S. ") sortBy person.Name take 5} |> Seq.iter(fun result -> printfn "%s" result.Name)
Not only are we able to concisely import the relevant metadata and express the query, but we’re also able to see IntelliSense throughout the experience:
And such code can be written not only in an F# application, but also directly in the F# Interactive window:
For more information on type providers, I recommend Don Syme’s BUILD talk: “F# 3.0: data, services, web, cloud, at your fingertips”.
Next Time
As is evident from this glimpse into some of the new language features and associated tooling support in Visual Studio 11, a lot of work has gone into pushing the state of the art for what’s possible in modern development. In future posts, we’ll explore advances in Visual Studio beyond languages, such as in the Visual Studio environment itself.
In my previous post, I highlighted how Windows Metro style apps can be developed utilizing the HTML, CSS, and JavaScript skills you already have. If your world is code, Visual Studio offers a great environment in which to write, edit, test, debug, and deploy these apps. Of course, great apps need great user interfaces. And when you need a visual, design-centric way to build your UIs, we have a brand new flavor of Expression Blend for you, built from the ground up for the visual authoring of Windows Metro style apps written with HTML5 and CSS. Unlike most other HTML editors, Blend for HTML is focused on app design, not on Web sites, with an unmatched ability to work on AJAX-style, JavaScript-centric UI.
Blend for HTML provides a rich toolset for authoring HTML and CSS-based user experiences, helping you to create, layout, and style visually on a high-fidelity design surface. In particular, Blend for HTML makes working with CSS a lot more enjoyable: you can focus on concepts rather than on syntax, and you get immediate visual feedback on anything you do. Building great user experiences is usually a multi-disciplinary effort, spanning development and design. Therefore, Blend for HTML is built on the same philosophy as our previous releases of Expression Blend for XAML: a rich, design-centric visual authoring environment paired with great developer-designer workflow. Where Blend for HTML takes a design-centric view, Visual Studio gives you the code-centric complement. Expression Blend and Visual Studio share the same project files, and they can be used simultaneously by a single person or across a team of people with specialized skills.
Here are a few highlights of the first preview of Blend for HTML:
Along with the Visual Studio 11 Express for Windows Developer Preview, we have also made available a developer preview of Blend for HTML (look for the Expression Blend 5 Developer Preview). This is just the beginning, and the team and I are looking forward to hearing your feedback.
From students participating in the Imagine Cup, to the next hot start-up in Silicon Valley, to enterprises delivering modern efficiencies into mature businesses, developers today all have three things in common: they are transforming and improving society through the software they envision, they have invested in themselves by obtaining deep knowledge and skill sets, and they require great tools to accomplish their goals.
At Microsoft, we’re passionate about delivering the best tools to help make developers successful. That’s why I’m excited to be here in Anaheim, California, attending the BUILD conference, where Steven Sinofsky has just finished delivering a keynote address in which he unveiled Windows 8 and Visual Studio 11 Express for Windows Developer Preview. We see it as our responsibility to empower you as developers to productively create groundbreaking solutions, which is why we aim to help you to capitalize on the skill sets you already have. Whether your skills center around HTML and JavaScript or around C#, Visual Basic, or C++, Windows 8 and Visual Studio 11 represent exciting opportunities.
One of the most notable advances in these Windows and Visual Studio releases is the ability to create consumer-focused, Windows Metro style apps using HTML. Many of you have invested heavily in learning to create compelling Web experiences, and you can now apply your knowledge of HTML, JavaScript, and CSS towards building rich client apps for Windows 8. Visual Studio 11 provides end-to-end support for these efforts, spanning the development, debugging, and deployment lifecycle. To complement this code-centric perspective, with Expression Blend 5 Developer Preview we are also introducing a unique new visual authoring tool for designing Metro style apps using HTML. Blend delivers high-fidelity visual HTML authoring and CSS styling, and works effectively with the dynamically generated UI that is so prevalent in client-side apps.
HTML and JavaScript only represent one piece of the Microsoft client story. For developers whose skill sets revolve around C#, Visual Basic, or C++, we’ve innovated across both managed and native technologies, spanning their runtimes, libraries, compilers, and UI layers. Investments developers have made in learning XAML move forward to Windows 8, where Metro style apps can be written using XAML along with C#, Visual Basic, and C++. Windows 8 also supports running existing XAML-based applications with the Windows desktop, and such applications further benefit from underlying feature and performance improvements made in these releases.
Such skill sets also translate to the server, and with significant investments across the Base Class Libraries, ASP.NET, Windows Communication Foundation, ADO.NET, and more, developers with C# and Visual Basic skills can be more impactful than ever. ASP.NET harnesses both managed code and HTML, enabling you to create broad-reaching Web experiences that span a myriad of device types, all via the same diverse set of development skills, and all via Visual Studio.
Whether developing new experiences or bringing forward existing ones, new and updated capabilities of Visual Studio will make you more productive and impactful. If you’re here in Anaheim attending the conference, you’ll have access to these previews today so that you can get started immediately building the next great app for Windows 8. And whether you’re here at BUILD or reading and viewing remotely, stay tuned… there are many exciting things to come.
Today, I’m excited to announce the release of Python Tools for Visual Studio (PTVS), which is now available for download from CodePlex.
The Python ecosystem has been enjoying tremendous growth over the past few years, attracting all types of programmers from scientists to web developers to hobbyists. To support this growing community, we’ve released PTVS, an extension to Visual Studio that provides for Python the wealth of features developers desire in a modern and mature IDE. PTVS is aimed at enthusiast and professional Python developers alike. PTVS also includes features specialized for technical computing. Over the past several months, I’ve blogged about multiple projects related to our technical computing initiative, including Solver Foundation, Dryad, and TPL Dataflow. PTVS is another unique and exciting project in this area. It's a free extension to Visual Studio that can be used with the Visual Studio Integrated Shell (available for free download) as well as with Visual Studio Professional and higher.
Key PTVS features include:
Visual Studio has a great editing experience, and with PTVS this experience now extends to the Python language. Capabilities begin with basics like syntax highlighting and extend to support for the navigation bar and object browser. It provides IntelliSense for your Python code based on a deep analysis of either your project or a directory of files, including understanding your classes and methods and peering into how you’re using core Python data structures like lists, tuples, and dicts. Additionally, based upon the same analysis used for IntelliSense, PTVS provides “Find all References” and “Go to Definition” features, which allow you to quickly navigate your code. You can get a sense for the editing experience from this screencast.
PTVS also includes refactoring support to make you more productive. This release automates two commonly needed refactoring patterns: “Extract Method” and “Rename Variable”. Extract method enables you to quickly excerpt a code snippet into a new method, making your code more readable and enabling better reuse. “Rename Variable” will rename all usage of a specified symbol in your code, supporting locals, module globals, and classes.
One of the most important aspects of Python development is interactivity, and PTVS integrates a Python REPL directly into Visual Studio. The REPL window will work for all of the aforementioned Python variants and supports auto-completion, syntax highlighting, and visualizations. For users accustomed to the enhanced REPL provided by IPython, PTVS supports IPython 0.11. For developers using IronPython, the REPL supports Sho.
One of the main focuses of our technical computing efforts has been parallel and distributed computing, and this PTVS release includes multiple features targeted at this area. In addition to standard debugging support, PTVS enables MPI cluster debugging. With this you can create a Python application and easily debug it on your Windows HPC cluster. Press 'F5', and your application will be deployed to the cluster and launched with debugging support. You’ll then be able to debug across all of the relevant processes across all of the involved nodes. This provides a great development experience when doing high performance computation in Python.
Beyond debugging, with PTVS integrated into Visual Studio Premium or higher, you also get a great profiling experience similar to that provided for C#, Visual Basic, C++, and JavaScript. After running with the profiler enabled, you’ll be presented with graphs and charts that help you to quickly find the hot spots in your program.
I'm also excited to inform you of the availability of the NumPy and SciPy Libraries for .NET. This port to .NET by Enthought, Inc. enables IronPython and other .NET languages to take advantage of these important technical computing libraries which support mathematical, engineering, and scientific domains.
Finally, I’d like to highlight that PTVS is open source, released under the Apache 2.0 license. I encourage your participation in this exciting Python project, and we look forward to hearing your feedback on the effort.
Today, Microsoft Visual Studio LightSwitch 2011 is available for download for MSDN subscribers. Non-MSDN subscribers can get LightSwitch starting Thursday, July 28th, or download a free trial today.
LightSwitch, the newest member of our Visual Studio product family, is a development tool that enables developers of all skill levels to build line of business applications for the desktop, web, and cloud quickly and easily. LightSwitch applications can be up and running in minutes with templates and intuitive tools that reduce the complexity building data-driven applications, including tools for UI design and publishing to the desktop or to the cloud with Windows Azure. LightSwitch enables you to focus on your business needs rather than details when building your application.
I encourage you to try LightSwitch 2011 and see how it can help you build applications. For details on how to use LightSwitch to build data-driven applications, check out Jason Zander’s blog.
The Imagine Cup brings together students from all walks of life from around the world and tasks them with a big challenge: solve the world’s toughest problems through technology.
I have been involved in the competition for all of its nine years, and each year, I am astounded by the caliber of the projects. The creators aren’t just innovators, but busy students. And yet, they manage to develop projects that could make a difference in the lives of many.
As I look at the project list, I can’t help but notice a couple of overwhelming trends that reflect students’ role at the cutting edge of technology. First, 75% of all software design projects utilize Windows Phone 7 in new ways, such as diagnosing disease and enhancing healthcare. Half of the software design projects use Windows Azure as a way to scale and share data in their solutions. And, we have ten projects utilizing Kinect.
The Imagine Cup 2011 Worldwide Finals will be held July 8-13 in New York City. This year, more than 400 international students, made up of 124 student teams from 73 countries, will gather to compete for top honors. Beginning today, everyone can get involved in the excitement by voting for the Imagine Cup 2011 Worldwide People’s Choice.
The People’s Choice competition allows the public to review many of the projects that will be a part of the worldwide finals and select their favorite. You can vote once per day. Pick a project that addresses an issue that is important to you, or show your pride by voting for your national team. I invite you to watch the videos, and prepare to be impressed.
To learn more about Imagine Cup and vote, please visit the People’s Choice site. Congratulations to all of this year’s finalists!
Previously, I blogged about key trends in software development starting with concurrency/parallelism, and indeed today multi-core systems are everywhere. You can target multi-core systems from many mainstream programming languages, and with Visual Studio 2010 we delivered market leading tooling for parallel development and debugging. You can see my post on our concurrency enhancements to C++ for VS2010 and here for a walkthrough of our parallel debugging tools.
In the last few years, we have been seeing an additional trend of heterogeneous hardware where, for example, developers take advantage of the GPU for computational purposes for their data parallel algorithms. This has been successful in narrow verticals using niche programing models. Microsoft wants to bring to the mainstream the ability to write code that takes advantage of heterogeneous hardware like GPUs. So like we’ve done with multi-core before, we are bringing this ability to the next version of Visual Studio.
I’m excited to announce that we are introducing a new technology that helps C++ developers use the GPU for parallel programming. Today at the AMD Fusion Developer Summit, we announced C++ Accelerated Massive Parallelism (C++ AMP). Additionally, I’m happy to say that we intend to make the C++ AMP specification an open specification.
By building on the Windows DirectX platform, our implementation of C++ AMP allows you to target hardware from all the major hardware vendors. We expect that it will be part of the next Visual C++ compiler and fully integrated in the next release of Visual Studio experience.
In addition, there is more work that we are doing on parallel computing. We also announced new enhancements to the next version of Parallel Patterns Library (PPL) and the C++ Concurrency Runtime. You can find easy-to-use C++ templates and runtime support to express algorithms for your domain expertise which scale on any provided hardware with PPL, Agent and the C++ Concurrency Runtime. With C++ AMP and PPL, we aim to make the next version of Visual Studio the most productive environment for targeting heterogeneous hardware available.
We will be making the session recording from Herb Sutter’s keynote session and Daniel Moth’s break-out session from the AMD Fusion conference available shortly. Please check the Visual C++ Team Blog or Channel 9 for those videos.
Today, we’re releasing Debugger Canvas on DevLabs.
Debugger Canvas is a new user experience for stepping through code in the debugger in Visual Studio Ultimate. It displays the code of each of the methods you step into on a canvas with call lines between them, helping you keep track of the bigger picture as well as the details.
Debugger Canvas pulls together all the code along a call path into a single display for browsing and even editing. Instead of having to keep all the code in your head while you look at one file tab at a time, now you can see the entire path on the canvas, enabling you to more easily track the flow of control and data through your application. Below, you can see an example where we have stepped into the execution of the Add Item function of a website shopping cart. The functionality requires the coordination of several methods, and the canvas lets you see them side by side so that you can more easily find and fix bugs.
Of course, the idea of showing related code together on a canvas can be useful in many scenarios. For this release, we started with debugging, since this task often involves looking at methods from many files at the same time. However, with the right options turned on, you can also navigate and edit your code from Debugger Canvas.
Debugger Canvas also highlights the potential of several of the technologies we introduced in Visual Studio 2010 Pro and Ultimate. It takes advantage of the flexibility of the new code editor to show fragments of files as bubbles on the canvas with a fully functioning editor in each. We built Debugger Canvas on top of Visual Studio Ultimate so that we could also use the underlying technology for the Dependency Diagrams to identify and display the right fragments on the canvas. This let us support both C# and VB in this release and will help us support other languages in the future. Building on VS Ultimate also allowed us to provide a new user experience for IntelliTrace, enabling some interesting scenarios, such as “show me what code ran when I clicked here”.
Debugger Canvas is the result of collaboration with Brown University and Microsoft Research, incorporating innovative ideas from Brown’s Code Bubbles and Microsoft Research’s Code Canvas. Cutting edge research is being done at Brown and at other universities around the world to help improve development team productivity and software quality. Through Microsoft Research, we collaborate with academic efforts like this one to bring innovative ideas to Visual Studio.
Take Debugger Canvas for a Spin
Our goal with DevLabs projects to get early feedback and insight and to help drive these ideas in the right direction. Try out Debugger Canvas, then bring your bugs, questions and ideas to the forum. We look forward to hearing from you!
Today, Steven Sinofsky and Julie Larson-Green announced that we’ll be starting a dialog with developers about the next generation of Windows, internally codenamed “Windows 8". We’re very excited to invite you to be a part of the conversation at BUILD, our new developer conference taking place September 13-16 in Anaheim, California. Registration is now open at buildwindows.com.
BUILD is the event for developers who want a front row seat at the industry’s first deep dive on Windows 8. It is where the full spectrum of developers - from startups and entrepreneurs to those who work for the world’s biggest enterprises – will come together to get a deeper understanding of Microsoft’s roadmap. At BUILD, Microsoft will show off the new app model that enables the creation of web-connected and services-powered apps that have access to the full power of the PC.
The conference name, BUILD, reflects a call to action for the more than one hundred million developers driving the pace of technology: build experiences with the next version of Windows that will transform the computing experience for billions of people across the globe. Follow us on Twitter for more information over the coming months.
Today, everyone can be a developer; the most tech-savvy generation we’ve ever seen is fueling demand for new tools and technologies. Many of the developers building web sites and apps that make an impact have no formal education in computer science or engineering. BUILD will be a gateway to new opportunity for all developers.
The professional developer community continues to be a vital part of the Microsoft ecosystem. We value the longstanding and deep relationship with this group and will continue to engage with this important audience in a way that best meets its needs. For these developers, BUILD connects Microsoft’s past to Microsoft’s future.
Please join us in Anaheim in September for a future we can all BUILD together.
More than 18 months ago, Microsoft helped sponsor the creation of the Outercurve Foundation (previously known as the Codeplex Foundation) to contribute ideas and projects to the open source community. The goal was to work with you to exchange ideas and build great things that other developers could adapt and learn from. I’m happy to say that the collaboration between our Developer Division and Outercurve has allowed us work closely with a number of open source software communities and seed some promising projects.
The Outercurve Foundation is platform agnostic. The Foundation organizes projects according to a museum model, into different galleries focused on specific topics or technologies. Currently there are three galleries: ASP.NET (focused on open source projects around .NET), Systems Infrastructure and Integration (focused on interoperability), and Research Accelerators (focused on technologies that support academic researchers and scientists).
Each of the galleries has a growing number of open source projects being created and communities of open source developers contributing to them. The ASP.NET Gallery, the first gallery Microsoft created as the founding sponsor of the Foundation, is home to five projects today: Orchard, ASP.NET Ajax Library, MVC Contrib, Web Form MVP, and NuGet, two of which were created by external developers. There is already a thriving ecosystem of both Microsoft and external developers contributing to these projects.
I want to highlight a couple of those projects today.
Orchard
Orchard is a free, open source, community-focused project aimed at delivering applications and reusable components on the ASP.NET platform. Orchard is focused on delivering a .NET-based content management system (CMS) that will allow users to rapidly create content-driven web sites and an extensibility framework that will allow developers and customizers to provide additional functionality through extensions and themes. Below, you can see an example of a site built using Orchard.
NuGet
NuGet is a free, open source, package management system that lets developers easily acquire and make use of open source libraries and their dependencies within their Visual Studio projects - typically the domain of a package manager. NuGet enables .NET developers to quickly discover, download, install and update packages into Visual Studio projects including any dependencies the packages may have through an ATOM-based feed. A package can consist of source code, compiled code, files, configuration and more.
Developers inside and outside Microsoft joined forces to create the joint NuGet project at the Foundation. As a result of their joint efforts and the support of the Outercurve Foundation, the NuGet project continues to grow and thrive. Black Duck Software recently placed the NuGet project at number five on the “Top Rookie” list of open source projects to watch in 2011. Thousands of projects launched in 2010 were evaluated using a weighted scoring system that awarded points for commit activity, the number of developers involved, and the number of web sites linked to the project.
Find out more and contribute
Together with the help of the open source community, we can build great things. We are committed to contributing to, and work closely with the Outercurve Foundation and open source communities, and we’ll continue to seed that with promising projects.
I hope you take a look at what Outercurve has today, and perhaps you’ll decide to contribute some of your coding talents too either to an existing project or in creating new projects.
More and more applications that are being built today touch the cloud in some way, shape or form. It could be as simple as consuming a service or some data that resides on the cloud. It could be writing parts of the app logic on the cloud. In a world where we believe in a set of connected experiences across a variety of devices, the cloud plays an integral role.
I have been talking for a while now about Windows Azure as a great back-end for application experiences that span multiple platforms and devices. Putting data and logic within Azure services means each device application you write has less unique code so you can reach more consumers, faster.
Today, we’re introducing a set of toolkits to further enable developers to build device applications that take advantage of Windows Azure with the Windows Azure Toolkits for Devices. Windows Azure Toolkits for Devices includes native libraries, samples, and documentation for Windows Phone, iOS, and, coming this summer, Android.
Earlier this year we released Windows Azure Toolkit for Windows Phone 7 to make it easier to build Windows Phone 7 applications that leverage services running in Windows Azure. We continue to iterate on this, and the next release of the toolkit will be available in the coming weeks at TechEd North America 2011. You can learn more about the future plans.
Released today, the Windows Azure Toolkit for iOS is designed to help developers targeting iOS to use Windows Azure services. It includes an open source Objective-C library to interface with Windows Azure services, documentation, and a sample application using the library. You can download the samples and documentation from github, along with the library and its source, or learn more about the details.
Android developers will have their own version of the toolkit available in preview form later this summer.
All the toolkits are free and open source.
Today we're adding Solver Foundation to DevLabs.
Solver Foundation is a .NET library for mathematical programming, modeling, and optimization. Mathematical programming is all about decision making, and decision problems are everywhere: from supply chain management, project scheduling, logic puzzles like Sudoku, building sports schedules, or laying out UI controls. Solver Foundation provides superior functionality and usability for .NET developers seeking to use optimization in their solutions, making it possible for non-experts to define and solve models in their applications.
Solver Foundation uses a declarative programming model consisting of simple building blocks, applying solvers that employ operations research, metaheuristic, and combinatorial optimization techniques. Building a model in Solver Foundation is as easy as specifying the decisions to be made, constraints to be respected, the goals to be used to evaluate candidate solutions, and the historical or projected parameter data to be processed by the model. This can be done from any .NET language without having to worry about the details of solver technologies or search strategies.
Here's the C# code for the famous four color map problem:
Solver Foundation allows you to build, analyze, and solve a wide variety of optimization models. The Solver Foundation Services object model provides many built-in functions and figures out which solver to call so you don't have to. It's also easy to connect models to almost any data source using LINQ and Solver Foundation's data binding APIs. Solver Foundation includes a broad range of solvers, including a powerful constraint solver developed in conjunction with the Constraint Reasoning group in MSR Cambridge UK. Solver Foundation's extensibility APIs enable many commercial and open source solvers to be plugged in without code changes.
SolverContext context = SolverContext.GetContext(); Model model = context.CreateModel(); Domain colors = Domain.Enum("blue ", "white ", "red ", "green "); Decision belgium = new Decision(colors, "Belgium"); Decision france = new Decision(colors, "France"); Decision denmark = new Decision(colors, "Denmark"); Decision germany = new Decision(colors, "Germany"); Decision netherlands = new Decision(colors, "Netherlands"); Decision luxembourg = new Decision(colors, "Luxembourg"); model.AddDecisions(belgium, france, denmark, germany, netherlands, luxembourg); model.AddConstraints("map", Model.AllDifferent(france, belgium, germany, luxembourg), Model.AllDifferent(netherlands, belgium, germany), Model.AllDifferent(germany, denmark)); Solution solution = context.Solve(); Console.WriteLine(solution.GetReport());
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
Domain colors = Domain.Enum("blue ", "white ", "red ", "green ");
Decision belgium = new Decision(colors, "Belgium");
Decision france = new Decision(colors, "France");
Decision denmark = new Decision(colors, "Denmark");
Decision germany = new Decision(colors, "Germany");
Decision netherlands = new Decision(colors, "Netherlands");
Decision luxembourg = new Decision(colors, "Luxembourg");
model.AddDecisions(belgium, france, denmark, germany, netherlands, luxembourg);
model.AddConstraints("map",
Model.AllDifferent(france, belgium, germany, luxembourg),
Model.AllDifferent(netherlands, belgium, germany),
Model.AllDifferent(germany, denmark));
Solution solution = context.Solve();
Console.WriteLine(solution.GetReport());
The Excel add-in for Solver Foundation makes it easy to build and solve models using spreadsheet data, and you can export models to C# with the click of a button. The following screenshot shows the Excel add-in being used to find the least expensive set of unit tests that ensure full test coverage.
Solver Foundation powers the Sho optimization library, also available through DevLabs. Together, Sho and Solver Foundation provide a great environment for solving and visualizing decision-based models. For example, the following Sho code solves the eight queens puzzle and displays the placement in a figure:
def queens(count): m = model() q = [m.int(0, count - 1) for i in range(0, count)] m.alldifferent(q) m.alldifferent([q[i] + const(i) for i in range(0, count)]) m.alldifferent([q[i] - const(i) for i in range(0, count)]) m.solve() b = zeros(count, count) for i in range(0, count): b[i, q[i].GetDouble()] = 1 return b imageview(queens(8))
def queens(count):
m = model()
q = [m.int(0, count - 1) for i in range(0, count)]
m.alldifferent(q)
m.alldifferent([q[i] + const(i) for i in range(0, count)])
m.alldifferent([q[i] - const(i) for i in range(0, count)])
m.solve()
b = zeros(count, count)
for i in range(0, count): b[i, q[i].GetDouble()] = 1
return b
imageview(queens(8))
Using Solver Foundation in F# support is elegant and fun. The F# ODSL provides the ability to define models in standard mathematical form, including units of measure. The following F# code defines a production planning model:
[<Measure>] type Dollar [<Measure>] type Barrel [<Measure>] type Day [<Measure>] type ProductionRate = Barrel/Day let ProductionPlanning() = let dailyOutput = 9000.0<Barrel/Day> let price = 140.0<Dollar/Barrel> let dailyCost = dailyOutput * price let a = 20.0<Dollar/Barrel> let b = 15.0<Dollar/Barrel> let sa = var<Barrel/Day>() let vz = var<_>() minimize (a * sa + b * vz) where [ 0.3 * sa + 0.4 * vz >= 2000.<_>; 0.4 * sa + 0.2 * vz >= 1500.<_>; 0.2 * sa + 0.3 * vz >= 500.<_>; sa <= 9000.<_>; vz <= 6000.<_>; sa >= 0.<_>; vz >= 0.<_> ]
[<Measure>] type Dollar
[<Measure>] type Barrel
[<Measure>] type Day
[<Measure>] type ProductionRate = Barrel/Day
let ProductionPlanning() =
let dailyOutput = 9000.0<Barrel/Day>
let price = 140.0<Dollar/Barrel>
let dailyCost = dailyOutput * price
let a = 20.0<Dollar/Barrel>
let b = 15.0<Dollar/Barrel>
let sa = var<Barrel/Day>()
let vz = var<_>()
minimize (a * sa + b * vz)
where
[
0.3 * sa + 0.4 * vz >= 2000.<_>;
0.4 * sa + 0.2 * vz >= 1500.<_>;
0.2 * sa + 0.3 * vz >= 500.<_>;
sa <= 9000.<_>;
vz <= 6000.<_>;
sa >= 0.<_>;
vz >= 0.<_>
]
Try Solver Foundation for yourself. The Solver Foundation installation includes over 50 samples and full MSDN documentation. We would love to hear your feedback on this in the Solver Foundation forum.
Today marks the one year birthday of Visual Studio 2010!
It seems not long ago that we had the world-wide launch celebrating the largest developer tool release from Microsoft in many years. I spoke then about the ability to target platforms like Windows 7, Windows Azure, and Windows Phone 7, about features and updates that enable developers to be more productive, and about the strong improvements we made in Application Lifecycle Management tools for teams. You responded, and within six months of launch, Visual Studio 2010 usage had surpassed all previous versions. Now, one year later, I'm proud to say that we didn't stop there and continued to add more value to the product. Today, seven million downloads later, here is a brief history highlighting some of our developer tool updates since April 2010 for both our MSDN subscribers and non-MSDN users. These are just some of the highlights of what we've made available for Visual Studio users since its launch a year ago.
Although we've been busy over the past year, it seems you, our partners and users, have been busier! More than 1,600 Visual Studio 2010 extensions have been submitted to the Visual Studio Gallery, with over 4 million extension downloads by users. Our partners continue to be able to build businesses around Visual Studio, and over the past year, partners have generated over $400 million in revenue from Visual Studio-based extensions. And many customers have been using Visual Studio 2010 to meet their business goals. Today there are nearly 200 examples of real customers involving Visual Studio 2010 on the Microsoft Case Studies site. Learn more about our Visual Studio partners (including how to become one) here, and read some of the Visual Studio 2010 case studies on the Microsoft Case Studies site.
Thank you as you customer and partner for being a part of Visual Studio's success. Looking forward to more great things.
With IE9's recent release, I wanted to share with you a little about some of our development tools that support HTML5, ECMAScript 5, and CSS3 development.
Throughout its release cycle, IE9 has blogged about ongoing improvement around standards support, particularly around support for the HTML5, CSS3, DOM, and JavaScript standards. From a developer perspective, we wanted to ensure that developers had the tools to work with IE9's new capabilities.
F12 Tools
A web client developer's first line of defense when something goes wrong will be to use the browser's built-in toolset. IE9's F12 tools include updated DOM and CSS inspectors, a script debugger and profiler, and tools that help developers preview their sites in IE's different browser and document modes, quickly clear the browser cache, and validate HTML.
In IE9, we added a new network analysis tab that enables developers to quickly and easily visualize where their pages are spending network time and bandwidth and where there may be possible network errors (such as malformed headers) to help them track down and debug their sites. Below, you can see how the Network Inspector displays information on a website request.
In addition to adding some major features to the F12 tools, we also addressed some of the top customer requests. A few examples of customer-requested features:
Before:
After:
Expression Web 4
Expression Web is an authoring tool that combines a visual web site creation experience with code editor-based page authoring capabilities. We coordinated the introduction of SP1 with the release of IE9 to enable Expression Web to support the latest web standards and to support them particularly well with Internet Explorer 9.
Like IE9, Expression Web 4 SP1 now supports HTML5 (you can see a demo in this video) including IntelliSense for the complete HTML5 draft specification, support for the CSS3 draft spec in the CSS Properties palette, and support for common CSS properties in the Style dialogs, including support for Border Radius in IE9 (pictured below). Semantic HTML5 tags that IE9 supports such as <canvas>, <section>, <hgroup>, and <footer> are now recognized and usable in Expression Web's Design View.
Expression Web's Snapshot feature has also been updated to integrate support for IE9. Snapshot is an Expression Web panel that shows how your page will render in versions 6-9 of Internet Explorer as you are authoring it. It's ideal for helping you upgrade your pages from earlier browser versions to the latest and greatest.
You can download Expression Web SP1 or get a trial version of Expression Web.
Expression SuperPreview
Expression SuperPreview is a tool for simplifying the process of testing and debugging layout issues across different web browsers. With SuperPreview, you can view your pages in multiple browsers simultaneously or view how a page renders in a browser and compare it to a comp or mock-up image of a page. SuperPreview helps web site authors address an important aspect of authoring-namely, how to identify and fix cross-browser layout issues. It can render pages in IE6, IE7, IE8, IE9, Safari 4 & 5 (on Macintosh), Chrome, and Firefox, and lets you easily compare and interrogate those renderings.
SuperPreview takes advantage of your locally-installed browsers and browsers hosted in a cloud service to generate its page renderings. It displays element information such as size and applied styles, as well as DOM tree information. SuperPreview works with both local and remote sites. You can see a demo video of SuperPreview in action. SuperPreview is a great tool for letting authors take advantage of HTML5 features while ensuring that pages still render nicely on down-level browsers.
SuperPreview will work with any web authoring tool, but is nicely integrated (and ships) with Expression Web.
Recently, Expression SuperPreview has been updated to support IE9. With that update, we've also made a trial version of SuperPreview available. The trial provides unlimited support for IE6, IE7, IE8 and IE9 and 60-day trial support for other browsers, including all those supported by the SuperPreview online service.
Visual Studio 2010 SP1
Visual Studio 2010 SP1 includes improved support for HTML5 and CSS3 IntelliSense and validation as you're typing. New tags such as <footer>, <canvas>, <audio>, and <video> are supported, as well as new attribute values such as <intput type="email">. SP1 contains improvements in CSS3 support as well. For example, the editor now supports the more advanced selectors such as div:nth-child(2n+1) without giving validation errors. The new color values rgba, hsl, hsla and 8 digit hex values are also supported.
Other Useful Tools
F12 tools, Visual Studio, Expression Web, and SuperPreview are just some of the useful tools for developers focused on building HTML5, JavaScript, and CSS3 websites. I already mentioned one other tool - AjaxMin - that you can use to boost the performance of your site, but there are many others. For example, the Jscript Editor Extensions add features like brace matching to JavaScript IntelliSense in VS. And last year we shipped the Visual Studio AJAX Profiling Extensions (formerly AjaxView) as a Power Tool that will help developers get a much better sense of the performance characteristics of their client web code. We have done quite a bit to improve support for jQuery as well, including ongoing updates to insure that Visual Studio supports IntelliSense for the latest version of jQuery, jQuery templates and globalization contributions, and a collection of snippets. Last, but not least, is Fiddler, the popular web debugging proxy.
These tools provide a taste of some our tools work as it relates to HTML5, CSS3 and JavaScript. To learn more about developing in HTML5, CSS3 and JScript please visit ScriptJunkie.
Last week at TechEd Middle East in Dubai, I announced that LightSwitch beta 2 would be available in the coming weeks.
I'm happy to report that today, we have made LightSwitch beta 2 available to MSDN subscribers. If you're not an MSDN subscriber, the download will be publicly available on Thursday, March 17 here.
I've talked about LightSwitch in the past as the latest addition to our Visual Studio product family.
LightSwitch enables professional and non-professional developers alike to build high-quality line-of-business applications. Beta 2 introduces new functionality for deploying business applications to the cloud with a Microsoft Windows Azure Cloud Hosting option and a built-in Publish to Azure feature. Also new in beta 2 are extensibility features such as themes, screen templates, shells, and new data sources, business types and controls. And, of course, since beta 1 we've also factored in some of the feedback you submitted through Microsoft Connect.
I encourage you to download LightSwitch beta 2 and try it out.
For more about using LightSwitch beta 2, also check out Jason Zander's blog.
Today, I have the privilege of keynoting TechEd Middle East in Dubai for the second year in a row.
TechEd Middle East debuted last year, and this year the event has grown significantly. TechEd provides a nice opportunity to show off some of the cool work that teams at Microsoft do. I love connecting with customers and hearing how they're using our products, and for me, TechEd is a great way to get that.
I'm sharing several pieces of news with the live audience in Dubai that I want to share with you as well.
Visual Studio 2010 shipped about 11 months ago, and we continue to work on it and respond to customer feedback received through Visual Studio Connect. This feedback has guided our focus to improve several areas, including IntelliTrace, unit testing, and Silverlight profiling.
You can learn more about how we're improving Visual Studio 2010 on Jason Zander's blog later today. On March 8th, MSDN subscribers will be able to download and install Visual Studio 2010 SP1 from their subscriber downloads. If you're not an MSDN subscriber, you can get the update on Thursday, March 10th.
TFS-Project Server Integration Feature Pack
Also available for Visual Studio Ultimate with MSDN subscribers via Download Center today is the TFS-Project Server Integration Feature Pack. Integration between Project Server and Team Foundation Server enables teams to work more effectively together using Visual Studio, Project, and SharePoint and coordinates development between teams using disparate methodologies, such as waterfall and agile, via common data and metrics.
Visual Studio Load Test Feature Pack
We know that ensuring your applications perform continuously at peak levels at all times is central to your success. Yet load and performance testing often happen late in the application lifecycle. And fixing defects and detecting architectural and design issues later in the application lifecycle is more expensive than defects caught earlier in development. This is why we've built load and performance testing capabilities into the Visual Studio IDE itself.
Today, we're introducing a new benefit - Visual Studio 2010 Load Test Feature Pack - available to all Visual Studio 2010 Ultimate with MSDN subscribers. With this feature pack, you can simulate as many virtual users as you need without having to purchase additional Visual Studio Load Test Virtual User Pack 2010 licenses. For more information regarding this new Visual Studio 2010 Ultimate with MSDN benefit, visit the Visual Studio Load Test Virtual User Pack 2010 page.
Visual Studio LightSwitch Beta 2
Visual Studio LightSwitch offers a simple way to develop line of business applications for the desktop and cloud. Since the launch of Visual Studio LightSwitch Beta 1, we have seen over 100,000 downloads of the tool and a lot of developer excitement. In the coming weeks, we will make available Visual Studio LightSwitch Beta 2. With this second beta, we will also enable you to build line of business applications that target Windows Azure and SQL Azure.
In the meantime you can learn more about LightSwitch and follow the @VisualStudio Twitter account for announcements.
Today we're launching several new Technical Computing (TC) projects on DevLabs. These projects give you a chance to learn about some of the technologies being developed as part of the Technical Computing initiative, to gain early access to code, and to provide feedback for several TC-related innovative projects.
Last May, I blogged about the Technical Computing initiative at Microsoft, an initiative that's leading to technologies which will empower the world's most important problem solvers to best utilize computing resources. These domain specialists often either develop code themselves as a necessary aspect of their work, or they rely on other developers to build the software that makes their work possible. The TC initiative gives those developers and domain specialists ground-breaking developer tools and infrastructure to do their best work.
The TC initiative has made some important first steps since its inception. Visual Studio 2010 includes built-in support for developing, debugging, and tuning multi-core and manycore applications and has seen impressive adoption within a wide-variety of industries and domains. In November, we announced Service Pack 1 for HPC Server 2008 R2, which integrates Windows Azure compute cycles, allowing massively parallel applications to easily scale from the cluster to the cloud. And this is just the beginning. The teams involved in the TC initiative are working hard on impressive new solutions to bring all that modern and future computing has to offer to developers, domain specialists, and IT professionals alike.
Today's new TC projects take the next steps in this journey.
TPL Dataflow - Enabling parallel and concurrent .NET applications
.NET 4 saw the introduction of the Task Parallel Library (TPL), parallel loops, concurrent data structures, Parallel LINQ (PLINQ), and more, all of which were collectively referred to as Parallel Extensions to the .NET Framework. TPL Dataflow is a new member of that family, layering on top of tasks, concurrent collections, and more to enable the development of powerful and efficient .NET-based concurrent systems built using dataflow concepts. The technology relies on techniques based on in-process message passing and asynchronous pipelines and is heavily inspired by the Visual C++ 2010 Asynchronous Agents Library and DevLab's Axum language. TPL Dataflow provides solutions for buffering and processing data, building systems that need high-throughput and low-latency processing of data, and building agent/actor-based systems. TPL Dataflow was also designed to smoothly integrate with the new asynchronous language functionality in C# and Visual Basic I previously blogged about.
Below, you can see an example of an "agent" using dataflow blocks in C# to safely, asynchronously, and efficiently process incoming requests.
Dryad - Supporting data-intensive computing applications
Pioneered in Microsoft Research, Dryad, DSC, and DryadLINQ are a set of technologies that support data-intensive computing applications on Windows HPC Server 2008 R2 Service Pack 1. These technologies enable efficient processing of large volumes of data in many types of applications, including data-mining applications, image and stream processing, and various kinds of intense scientific computations. Dryad and DSC run on the cluster to support data-intensive computing and manage data that is partitioned across the cluster, while DryadLINQ allows developers to build data- and compute-intensive .NET applications using the familiar LINQ programming model.
Here you can see the code to loading textual log data using Dryad. That data is merged and processed on a cluster, and then the results are streamed back to the client for display.
public static IEnumerable<string> GeoIp(string logStream, string geoStream){ DistributedData<string> logLinesTable = DistributedData.OpenAsText(logStream); DistributedData<string> geoIpTable = DistributedData.OpenAsText(geoStream); // Join the two tables on the common key (IP Address) IEnumerable<string> joined = logLinesTable.Join(geoIpTable, l1 => l1.Split(' ').First(), l2 => l2.Split(' ').First(), (l1, l2) => l2).AsEnumerable(); return joined;} public static void Main(){ // Load log and geo data into DSC Console.WriteLine("Loading data"); File.ReadLines("log.txt").AsDistributed().ExecuteAsText("hpcdsc://localhost/Samples/log"); File.ReadLines("geo.txt").AsDistributed().ExecuteAsText("hpcdsc://localhost/Samples/geo"); // Run the query Console.WriteLine("Running query"); IEnumerable<string> results = GeoIp("hpcdsc://localhost/Samples/log", "hpcdsc://localhost/Samples/geo"); // Print out the results Console.WriteLine("Displaying results");
foreach (var entry in results) Console.WriteLine(entry);
}
Also begun in Microsoft Research, Sho provides those who are working on technical computing workloads an interactive environment for data analysis and scientific computing. It lets you seamlessly connect scripts written in IronPython with .NET libraries, enabling fast and flexible prototyping. The environment includes powerful and efficient libraries for linear algebra and data visualization, both of which can be used from any .NET language, as well as a feature-rich interactive shell for rapid development. Sho comes with packages for large-scale parallel computing (via Windows HPC Server and Windows Azure), statistics, and optimization, as well as an extensible package mechanism that makes it easy for you to create and share your own packages.
As you can see in the below screenshot, Sho provides an interactive REPL (read/execute/print loop) that allows you to write code and see results textually and graphically immediately.
Try Them Out
Our goal moving forward is to add additional Technical Computing projects in pre-beta states to DevLabs in order to get your early feedback and insight and to help drive these technologies in the right direction. We look forward to hearing from you.
As the year comes to an end, I find myself reflecting on the progress we've made at Microsoft and how it's made an impact on my life.
I'm always impressed with the work we do here at Microsoft (you can see how unbiased I am :)), but this year I'm especially proud to see some of the work having a real impact in my house and with my family members.
Windows Phone 7
Several weeks ago, my family became Windows Phone 7 users. We got Samsung Focuses (Foci?) for my wife and two daughters, and I can tell you that they're very happy with their new phones. The Focus is light with a bright AMOLED screen, and I love the simple Metro theme. You can see how we've personalized each of our phones below. I want to highlight a few of my favorite features on the phone:
Also, I'm excited to tell you the Windows Phone Marketplace now has over 4000 applications, and the number is growing daily thanks to developers like you! Keep up the great work.
Xbox Kinect
We have an Xbox Kinect at home, and I was amazed at how fast my daughters got the hang of controlling the Xbox and playing games using motion and gestures. Dance Central is popular at my house, but for all my years of software experience, this is one place where my wife and daughters have me beaten hands-down. The ESPN application lets me view games on demand that would be hard to find on American television. They even have Cricket, and I can pause, rewind, and fast forward (which is particularly important for those multi-day Test matches). The Kinect camera also makes for a very smooth instant messaging experience. You can video chat with either another Kinect or a PC running Live Messenger with a webcam. Kinect will lock into the speaker and track their movements around the room automatically so you can focus on your conversation. IE9 You've been telling us we have some catching up to do to make IE a great browser for the future, and while it's not done quite yet, I'm happy to say that IE9 is well on its way to delivering on those requests. I've been using the IE9 beta for months now, and I really like the new cleaner interface. It just feels snappier too. IE9 also offers HTML5 support for rich interactive standards-based web applications. Kinect, Windows Phone 7, and IE9 are some examples of how the work we do at Microsoft has had a positive impact in my household. Kudos to the Xbox, Phone, and IE teams! Wish you all peaceful and safe holidays and a happy new year! -somasegar
We have an Xbox Kinect at home, and I was amazed at how fast my daughters got the hang of controlling the Xbox and playing games using motion and gestures. Dance Central is popular at my house, but for all my years of software experience, this is one place where my wife and daughters have me beaten hands-down. The ESPN application lets me view games on demand that would be hard to find on American television. They even have Cricket, and I can pause, rewind, and fast forward (which is particularly important for those multi-day Test matches).
The Kinect camera also makes for a very smooth instant messaging experience. You can video chat with either another Kinect or a PC running Live Messenger with a webcam. Kinect will lock into the speaker and track their movements around the room automatically so you can focus on your conversation.
IE9
You've been telling us we have some catching up to do to make IE a great browser for the future, and while it's not done quite yet, I'm happy to say that IE9 is well on its way to delivering on those requests. I've been using the IE9 beta for months now, and I really like the new cleaner interface. It just feels snappier too. IE9 also offers HTML5 support for rich interactive standards-based web applications.
Kinect, Windows Phone 7, and IE9 are some examples of how the work we do at Microsoft has had a positive impact in my household. Kudos to the Xbox, Phone, and IE teams!
Wish you all peaceful and safe holidays and a happy new year!
-somasegar
Since we launched Visual Studio 2010 and .NET 4 on April 12th of this year, it has been exciting to see the extremely positive response to the product. Within six months of the launch date, Visual Studio 2010 usage surpassed all other previous versions of Visual Studio based on usage data collected from customers who opted into sharing their usage data with us. This is the fastest adoption of a new release of Visual Studio ever, and we are seeing continued strength in the adoption of Visual Studio 2010. Visual Studio 2010 SP1 Beta Since the release of Visual Studio 2010, we've been working to address high priority issues you've brought to our attention through forums like Visual Studio Connect. We've also focused on improving the overall experience in a few important areas, such as unit testing, support for GPU acceleration in C++ applications, and offline help. You can learn more about the work we've done in SP1 on Jason Zander's blog. Today, MSDN subscribers can download and install the beta of Visual Studio 2010 Service Pack 1 from this site. If you're not an MSDN subscriber, the download will be available on Thursday, December 9th here. I encourage you to download it and try it out. Your feedback on this release will help us improve the final release. Please report any issues you come across in the SP1 Beta to Visual Studio Connect. Once you've had a chance to use Visual Studio 2010 Service Pack 1, please also give us your feedback by taking the Service Pack 1 Beta Survey. The results from this survey inform our work so we build an even better SP1 RTM. Team Foundation Server 2010 and Project Server Integration Feature Pack Beta Also available today for MSDN subscribers is Visual Studio Team Foundation Server 2010 and Project Server Integration Feature Pack Beta. This feature pack enables sharing project status and resource availability between team members using TFS and Project Server. The feature pack beta's "go-live" license allows customers to deploy it in their production environments. You can learn more about the feature pack on Brian Harry's blog or download the feature pack beta from MSDN. Namaste!
Since we launched Visual Studio 2010 and .NET 4 on April 12th of this year, it has been exciting to see the extremely positive response to the product. Within six months of the launch date, Visual Studio 2010 usage surpassed all other previous versions of Visual Studio based on usage data collected from customers who opted into sharing their usage data with us. This is the fastest adoption of a new release of Visual Studio ever, and we are seeing continued strength in the adoption of Visual Studio 2010.
Visual Studio 2010 SP1 Beta
Since the release of Visual Studio 2010, we've been working to address high priority issues you've brought to our attention through forums like Visual Studio Connect. We've also focused on improving the overall experience in a few important areas, such as unit testing, support for GPU acceleration in C++ applications, and offline help. You can learn more about the work we've done in SP1 on Jason Zander's blog.
Today, MSDN subscribers can download and install the beta of Visual Studio 2010 Service Pack 1 from this site. If you're not an MSDN subscriber, the download will be available on Thursday, December 9th here. I encourage you to download it and try it out.
Your feedback on this release will help us improve the final release. Please report any issues you come across in the SP1 Beta to Visual Studio Connect. Once you've had a chance to use Visual Studio 2010 Service Pack 1, please also give us your feedback by taking the Service Pack 1 Beta Survey. The results from this survey inform our work so we build an even better SP1 RTM.
Team Foundation Server 2010 and Project Server Integration Feature Pack Beta
Also available today for MSDN subscribers is Visual Studio Team Foundation Server 2010 and Project Server Integration Feature Pack Beta. This feature pack enables sharing project status and resource availability between team members using TFS and Project Server. The feature pack beta's "go-live" license allows customers to deploy it in their production environments. You can learn more about the feature pack on Brian Harry's blog or download the feature pack beta from MSDN.