Jason Zander's WebLog

Distinguished T-Shirt Engineer Best Hits

2009-06-17T14:55:06Z

One of the fun things I used to do while running the CLR team was help pick out the final design for our t-shirts (not that picking out code generation strategies wasn’t also fun). Fortunately Sonja Keserovic on our team is a master at designing awesome shirts (while not doing her day job designing engines and languages). She just sent me the “best of” shirts from over the years:

“Enter the Core”

You’ll notice a big movie inspiration in the designs. The matrix style green text is actually the MSIL for “Hello World” run through ildasm. You can read through the PE file header and string table in addition to the IL instructions themselves.

“Roll Call”

Always the analytical bunch, this shirt has every email name for everyone on the team. Colors denote discipline (I’m white for ‘pointy hair’), font size denotes how long you’d been on the CLR team. The island behind the front logo is Whidbey island, the code name for V2.0.

“One Runtime to Run them All”

Around the time of LOTR, this text that makes up the ring is actually the source control root for every Microsoft project using the CLR at the time (with a nice Elvish style font).

“Don’t Panic”

The final build number for the V2.0 product was V2.0.50727.42, just around the time the Hitchhiker’s Guide movie came out. Did I mention we like geeky stuff?

Sonja is now a SDE on the languages team in VS and is creating an awesome new VS design involving pi calculus, can’t wait to see it!

MVC 1.1 for VS2010 Beta 1 Released

2009-06-12T18:43:11Z

The MVC framework for ASP.NET allows you to create applications that follow the model/view/controller architecture. VS2010 Beta 1 did not have MVC built-in to the product but you can now download it here. MVC will be included in the final release of the product.

After installation you will have MVC templates installed for both VB and C#:

Scott Guthrie has a fantastic walk through on MVC using the VS2008 product which is also be relevant to V2010 (modulo a few dialog changes here and there).

Enjoy!

VS2010 Tutorial: Building VS Extensions with the Beta 1 SDK

2009-06-01T15:00:00Z

The SDK is used to create extensions to Visual Studio itself like those you can find on VS Gallery. You can download it here. The installation is done on top of an existing install of VS 2010 and gives you a set of build tools, templates, and a short cut for debugging devenv.exe (VS) that can be used for testing your new extensions.

Once you get the SDK installed, you will find a new set of templates. Let’s start by doing File, New Project. Type ‘editor’ in the search box to find example editor extensions:

Select the ‘Editor Text Adornment’ template and click OK. This sample template extends the editor with a Text Adornment which basically gives you the ability to change how text is displayed. By default this adornment finds all instances of the character ‘a’ and highlights them.

Build the solution (Ctrl+Shift+B). The template automatically packages the new .dll into a .vsix file (basically a zip with some dialogs, the code, and other data required to extend VS). It then copies the new package into the Extensions directory for the test instance of VS:

Now hit F5 to debug the new extension. Because you are extending Visual Studio itself, the test instance of VS is launched:

This is a separate instance of devenv.exe as shown by tlist:

Notice the key difference is devenv.exe is launched with a special /rootsuffix flag which gives it a different instance for the extension location:

In the experimental instance of VS, open a text file (such as the one generated for this add-in). When it loads, you’ll notice the editor extension is in effect and has drawn a red box around every ‘a’ in the file:

The code is pretty straightforward. The constructor sets up a event handler for layout changed, whenever the change happens every line is scanned, within each line when an ‘a’ is found a red box is placed around it.

If you open the .vsixmanifest file you will get an editor for all the settings an extension needs:

This includes things like the images you will see when you browse / install the extension, the description, etc.

Extensions can be easily shared with your friends. To install an extension, either double click the VSIX file to install it or copy the unzipped extension contents to your extensions directory.

In addition to local usage, you can also publish (or acquire) extensions from the VS Gallery. This is easy to do from inside VS by choosing Tools, Extension Manager:

If you select the Online Gallery, you will find all the controls, templates, and tools from the public site:

You can easily download and install an extension by selecting it and hitting the Download button. In this case I’ll download the Demo Dashboard which is one of our samples:

After you download the file (assuming you accept the license), you will be prompted to restart VS so the extension can be loaded:

If you select Restart Now, VS will start again and restore your state. The new extension is now in place:

Once you have written an extension you really like and you think others may want, you can use the VS Gallery site to upload your item:

You can update, delete, etc your extension after it is uploaded.

As you can see, loading new items, creating new items, etc is very straightforward. I’m looking forward to seeing what you come up with.

Enjoy!

Azure: New Support for the Cloud, New Skills Not Required

2009-05-28T10:00:00Z

Last October at PDC, the Windows Azure team released the first CTP of Windows Azure along with the first SDK for developers who are interested in pushing their apps to the cloud. The team committed to releasing regular SDK updates, and today we are announcing an update to Windows Azure Tools for Visual Studio. This release includes:

Visual Studio 2010 Beta 1 support
Update for Visual Studio 2008 support
Improved Visual Studio integration with Development Fabric and Development Storage

This is in addition to the current Windows Azure Tools for Visual Studio, which includes:

C# and VB Project Templates for building Cloud Services
Tools to change the Service Role configuration
Integrated local development via Development Fabric and Development Storage services
Debugging Cloud Service Roles running in the Development Fabric
Building and packaging of Cloud Service Packages
Browsing to the Azure Services Developer Portal

One of our key goals is to make your skills as a developer easily transferrable to new domains. If you learn .NET, pick a favorite language (like VB or C#), and learn Visual Studio, then you can easily use your skills to target the ASP.NET, Silverlight, SharePoint, Windows Mobile, and even the Xbox. The tooling support for Azure brings your same skill set forward into the Cloud.

You can download the latest SDK for Windows Azure here. If you’re interested in the cloud, check out the Windows Azure CTP and the SDK. Make sure to check out the how to videos here.

Enjoy!

VS2010 Tutorial: Testing Tutorial (Step 2)

2009-05-26T07:00:00Z

Last week I posted the Step 1 tutorial for creating a WPF application from scratch using Visual Studio 2010. In this post, I’m going to create a test plan and test case for the application using the new Visual Studio Test and Lab Manager project.

For this tutorial, I’m using Visual Studio Team Suite 2010 (which includes all of the roles and TFS access). I’ve already added the demo to TFS so I have full source control. For the sake of demonstration, I’ve commented out the final fix from the walk through so the label does not update:

When I run the application, the label is not updated:

The Tester

To create my test, I’m going to run the Test and Lab Manager tool from the start menu:

The main page has tabs for test plans, tests, and for tracking work items:

First I need to connect to my TFS server by click Add. My server is VLM13267036 (auto generated name by our internal Hyper-V testing tools):

I’ve already got a collection with my code stored in the Projects folder:

Next I’ll select Projects and choose the Connect option. This prompts me to set a context:

I’ll choose “Set context” which brings up the editor for my new context:

I’ll select New:

I can now edit all of the properties:

After all data has been entered, click Save and Close. The new item is now in our list:

Double clicking the item allows me to add a new test case to this test suite:

Here you can fill out all details for the test case:

Steps can now be added by clicking on the “Click here to add a step”:

I’ve added a few steps including launching the application, hitting the buttons, etc:

Now hit Save and Close to go back to the test case list. The Plan is now complete. We can run it any time a new build is produced, for each flavor of build, for different configurations, etc. To execute the test, change focus to the Test tab:

Our test plan and test case are already in the list. Right click the test case and select Run:

This will launch the test case. The manual test runner window docks itself to the left side of my desktop so I can see both the steps I want to run and the full Windows desktop:

The “Start test and record” option allows me to not only do the testing steps, but it will also allow recording a WMV of all the steps I do as well as recording my steps to help me author coded UI tests (big helper with automation). This is really handy if you want someone to see exactly what you did to produce a bug and automate testing in the future.

In this case I will select “Start test”. Notice the Test Runner now shows the steps I created above:

The first step is to “Launch the PicViewer application” which I’ll do by running the application. Since that worked, I’ll press the combo box status item behind the step and select ‘Pass’ from the drop down:

The item is now marked as passing:

I’ll repeat the process for the next two steps, so far so good:

When I get to my last step, I discover the file path isn’t actually set. That makes this item a failure. Select the drop down box and choose ‘Fail’ from the list. I’m automatically asked for comments on the failure:

Since I didn’t record a video of my steps, I would like to give the developer a screen shot of what went wrong. Select the camera tool bar button:

This will bring up a capture tool turning the cursor into a cross hair that allows me to select a region of the screen. I’ll select the top of the application to demonstrate the busted label:

Notice that the failed test now has a .png file added with the image:

I’ve got enough supporting data now so I’ll create a new bug using the toolbar:

I’m now prompted to create my bug with a description, etc:

Notice the detailed test steps I’ve taken have already been added to the bug:

As has my screen shot (the .png file):

I’ll now do a Save and Close which will commit the bug to TFS as a Work Item. Finally I’ll do End Test then Save and Close the test runner. This will return us to Test and Lab Manager.

as a tester, I could now double click the test case and see all of the same data I just saved for the failure:

I can also select My Bugs and see the bug filed for this issue (since I conveniently assigned it to me):

And just to show how everything is wired together, I can open Visual Studio, Team Explorer and look for bugs assigned to me there as well:

At this point my job as a tester is now done.

The Developer

As a developer, I can now open the bug and read through the issue. If I select Other Links I’ll find the .png which I can open to see the issue:

Sure enough, the label is not updated. If a WMV had been recorded, I could have actually watched the testing steps in action. Because the bug is quite simple to find and fix (some idiot commented out the update line!) I can simply make my fix and test it.

Now that things are fixed, I want to check in the bug fix and resolve the work item at the same time. Click on the Pending Changes tab in VS and select the correct work item:

Now we can Check In the fix:

I can now verify the bug has been Resolved:

In Summary

A key goal for Visual Studio Team System 2010 was to reduce the number of times a tester and developer wind up in a ‘no-repro’ situation. There are several things I’ve demonstrated in this tutorial which help:

Test case steps are documented and set up for repeatable execution
Pass/Fail steps are outlined and stored in bugs automatically
Video capture is allowed to see all steps taken, and screen snapshots are easy to acquire and file with a bug
System information including build number, OS, etc are recorded for you (System Info tab)
Although not shown, I could also have collected all of the historical debugging traces from the run as well
All data from test cases, results, work items, and source code are kept in TFS and can be shared by test and dev

I hope you’ll pick up Beta 1 and try this set of tutorials for yourself. Let us know how well it works for you and if you have any suggestions. I should also point out the work item tracking, auto resolve, etc are all part of VS 2008 so a great way to get prepared for the new version is to get TFS deployed today and get your projects into the system.

Enjoy!

VS2010 Tutorial: Build a WPF App (Step 1)

2009-05-22T07:00:00Z

For this post I’m going to build a WPF application from scratch using VS2010 Beta 1. Along the way I’m going to show off a few new features of the product. I built this demo using the Beta 1 build on Windows 7 RC, but it should work fine on other systems as well.

If you haven’t already downloaded the software, you can find a great walk through of how to do that on Channel 9 from Brian Keller. Brian explains how to install the entire product, including TFS. TFS is not required for Step 1 (this tutorial), but will be for Step 2.

First we’ll start off in Visual Studio 2010 and do a File, New Project. I’m going to select “WPF Application” and call my application PicViewer (this is the new Beta 1 dialog):

This will give us the default project template including a Window with a Grid and my default C# project code:

To start, I’m going to drag the Window out to be larger which you can do by dragging the actual window in the designer or you can edit the XAML Width=”” tag. I’ll make mine 700:

At the top of the application we want a button to display the Previous and Next pictures in the list. We also want to display the full path so we’ll need a label. Step 1 is to add a row to the grid. In this case I’ll select the <Grid> label and move the cursor to where I want the row:

When I make the row, it also adjusts the XAML for this page as follows:

Let’s adjust the first row Height to “35” instead of “29*” just to make sure my buttons are of reasonable size. The aesthetics are really up to you.

We want WPF to do the layout of the buttons and the label. To do this, create a <StackPanel> bound to Grid.Row=”0”. The StackPanel by default flows items vertically so let’s change the Orientation to “Horizontal”. You can do this either by using the XAML editor or by dragging the items from the ToolBox. Your final markup should look like the following:

Let’s drag a button onto the Row from the Toolbox:

I want this to be the Previous button. I’ll do this by editing the settings in the Properties window:

First change the Name field to “buttonPrev” and then change the Content setting to “Prev”. Repeat this process by dragging another button to the right of the Prev button and edit that item to Name “buttonNext” and Content “Next”. You should see the following:

This is functional, but doesn’t look good. We can add some white space around the buttons in the StackPanel by setting the margin which defines how much space should be around an item. Select the Prev button and change this setting:

which will give the button a Margin of 5 on all sides (you can independently set left|right|top|bottom as well). Repeat the same for the Next button. At this point you’ll see the following:

Finally drag a label to the right of the Next button making the Name “labelPath” and set the Width to “400”. When you are done, your XAML markup should look as follows (you can edit the text if it isn’t just right):

To display our pictures, we will need to have an Image control in the bottom. To do this, drag an Image control from the ToolBox to the bottom of the grid. This will do the following:

This is a case where having the Smart Tag feature of Windows Forms would be really handy. This is on the feature list but not yet in the WPF Designer. In this case I’m going to edit the XAML itself to remove everything the designer added except the Grid.Row, Margin, and Name settings. Make your settings look like the following and the image control will now fill the bottom of the grid with a nice white space border:

Now the look of the application is coming along and we need to add some code to make it work. To start, double click on the title bar of the Window to create a load handler:

Repeat this process by double clicking on the Prev and Next buttons. This will give you the following code outline:

For this picture viewer, I’m going to get a list of jpg files from my Windows 7 user directory and display those. What I’d really like to do is write the view code in Window1.xaml.cs in a way that makes sense to me, then go write the underlying logic. To get started, I’m going to declare a new instance of a class that doesn’t exist yet:

Because the class doesn’t exist yet, I am getting the red squiggles under the type. That’s ok, we’ll create the class in a minute.

The next step is to stub out all the view code in this file. We’ll start with the Window_Loaded() method. Notice that even though the class has not been defined, Intellisense will include the type after the new keyword so you can use it:

We want to initialize the list and display the first picture when the application starts. The code is as follows:

Once again I have parse errors for items which don’t exist which is ok. Move on to the Previous button handler and start typing in that method. When I get to the DisplayPicture function call, you’ll notice the function doesn’t show up in the IntelliSense window because it doesn’t exist yet.

If you hit <Ctrl>+<Alt>+Space you’ll change the mode into “consume first” which means I want the editor to give me these names while I’m typing. Now when I start typing, my new (and undeclared) function shows up in the list so IntelliSense doesn’t auto-complete on items already in the completion list:

My code then looks like the following:

I’m happy with this basic view logic. Now I need to actually create the support class that finds my pictures. Let’s start by placing the cursor on the PictureList class declaration then press the <Ctrl> key and the period (<Ctrl>+.) at the same time to expand the smart tag. You’ll get the following pop up:

Select the first menu item, “Generate class for ‘PictureList’”. This will add a new file, PictureList.cs, to the project and generate the class PictureList in that file. Now that the class has been defined, the squiggles go away:

You will then notice all the methods you have invoked on the class are showing up as syntax errors. Put your cursor in the Init() method and press <Ctrl>+. to get the following:

Select the menu item so the code is generated for you. Repeat this process for the Peek(), Prev(), and Next() methods. If we then open PictureList.cs file, you will find the following code stubbed out for you:

Notice that because the code we wrote to consume methods like _PicList.Peek() expect a string back, the editor has automatically given the methods a return type of ‘string’.

Now I’ll add the logic to retrieve a list of jpg’s from the Windows install and give me the ability to walk through them:

The last step is to write the DisplayPicture method in Window1.xaml.cs. I can do this once again by selecting the method name and hitting <Ctrl>+. and then fill out the code as follows:

This code will take the jpg and convert it into a BitmapImage that can be displayed. The next line of code sets the Source of our XAML image contorl to this bitmap so it can be displayed on the screen.

The program now builds cleanly. I will set a breakpoint in the Peek() method as well as the DisplayPicture method. Do this by placing the cursor on those functions and hitting the F9 button (notice the red breakpoint circle in the margin):

Now let’s run the application by hitting the F5 button. Our first breakpoint in the Peek() method is now hit:

You’ll find your breakpoint marked in yellow where we stopped. In addition you’ll find the traditional Call Stack view in the lower right. Because I’m using Visual Studio Team System, I also have the “Debug History” view on by default:

The default settings have captured interesting information about the execution of my program so far including all of the Registry accesses my program has made (either by me or the underlying system) and system events (like breakpoints, exceptions, etc).

If I hover my cursor over the _PicList variable in the editor, I get a pop up watch window. If I hover my cursor over the little square at the end and click:

then you will get a sticky DataTips window in the editor (the arrow is just to demonstrate the result, it isn’t in the editor):

This is a simple example of using the new WPF editor. The sticky DataTips window is a WPF adornment to the text buffer tied into the debugger. You can use it like a normal watch window by expanding the array contents, etc.

Let’s hit F5 and continue the program. My application now works including the Prev and Next buttons:

The only issue is the name of the file is not being updated. Click the Next button again to our break point in DisplayPicture(). There is no code to update the label in this method:

To fix this, let’s add a new line of code:

With the Edit & Continue feature you can make new code changes while the application is running. Update the code to the following:

Now press F5 to continue and the path is updated:

There are a couple of fit and finish things I’d like to change. Let’s stretch the image to fit by adding Stretch=”Fill”:

Next let’s add a rectangle to frame the picture:

You can then select the rectangle and set the Fill property to give it a color. This brings up the new inline color palate:

I chose a blue/black color and you get the following:

The final XAML markup then looks like the following:

This sample could be improved in a number of ways, including using data bound controls to enumerator classes, adding all the proper try/catch logic, etc. But my main goal here was to show off some editor / designer features so I’ll leave that as an exercise to the user.

Enjoy!

General Download of VS2010 / .NET Framework 4.0 Beta 1

2009-05-20T02:54:35Z

On Monday I posted a detailed walk through of Beta 1 here. Beta 1 has been available to MSDN subscribers since Monday and will be available to everyone as of 10 AM PST today (Wednesday May 20). I’m about to catch a plane from JFK to Seattle so I’m posting the links now:) They will be live after 10 AM PST:

This beta does have full setup available so you can provision it yourself. The product is designed to work cleanly with VS2008, however like any pre-release software you should be careful about using the product on your main machine. We are not (yet) opening the product up for general ‘go live’ usage; our goal is to get your feedback on the feature set and direction we are headed.

I really want to hear your feedback! I will definitely follow blog comments, but the best way to give us that feedback is through the Visual Studio 2010 / .NET Framework 4 Beta 1 site. You can get your issues and suggestions routed to the teams directly by going through this route.

Over the next week I’ll be posting a couple of tutorials that you can use to try out new functionality. Stay tuned…

Announcing VS2010 / .NET Framework 4.0 Beta 1!

2009-05-18T20:50:30Z

I’ve mentioned a couple of times that Beta 1 was imminent and now it is ready for download for all MSDN subscribers! You can download the beta here. General downloads will be available on Wednesday, stay tuned here for the formal announcement.

We’ve added a lot of great functionality for VS2010 and .NET Framework 4.0. the rest of this blog, I want to highlight a few areas you should give a try as you kick the tires on the beta.

Shell / Editor

The New Project Dialog supports multi-targeting (including the new 4.0 framework) and a new online access to VS Gallery:

We’ve added the new Tools Extension Manager which allows you to download new templates and other materials from VS Gallery directly from within VS. For Beta 1 we’ve posted a few demo examples for you to try out. Look for more as we get the ecosystem going:

Code focused work

We’ve added a lot of “code focused” features which basically makes the editing experience much nicer. For example:

Consume first, fault in
Writing test cases using the system
Quick search (Ctrl + ,): works across VB & C# & C++
Call Hierarchy

If you like the TDD approach, you should enjoy the new support.

Office Programmability

To make Office programming easier with C# and VB, we’ve added the new ‘dynamic’ keyword, named parameters, and optional parameters. In addition, you can build your application with the ‘No PIA’ support which means you no longer need to actually deploy a PIA.

In the following example, the first shows how you write code today and the second shows you the one line of code you would prefer to write and now can with VS2010:

much better:

This simple application now creates a new Word document and adds some text:

Language Improvements

We’ve made several improvements to our languages for this release including working on our parity efforts between C# and VB. As an example, VB now has automatic properties which removes the verbose syntax for get/set:

In this case VB has a unique feature of initialization as well. The next big change in this release for VB is to remove the dreaded ‘_’ at the end of continuing statements:

VB also gets statement lambdas (the ability to write inline subroutines):

And finally collection initializers:

C# also has a set of new features including the dynamic keyword shown above for better Office programming.

F# now ships with VS2010 which means you can start using the language as soon as you install (no separate download).

The following code example shows the class sum of squares method written both in F# and in C# for comparison (|> is the pipeline operator which means it sends results from one operation to the next, just like | on the command line):

F# allows you to execute code directly in the interactive console:

WPF Designer

The WPF designer has been updated to include key features like data binding. If you are Windows Forms programming trying out WPF you will definitely be happy with this new set of features:

Master / detail forms are easy using the foreign key:

Silverlight

Silverlight tooling is also built into the product:

Web Tools

Web tooling has been updated with this version including the addition of HTML snippets. This feature is incredibly handy if you are like me and spend more time in text than in UI designers:

JavaScript IntelliSense has also been updated for performance and accuracy. As you start to type new code, the editor will infer what you meant and update as you go:

This work also tracks namespaces you might create and handles inline comments for a better editing experience:

JQuery now ships with VS with great IntelliSense support:

C++

We’ve made a significant number of improvements to the C++ support in VS2010. Among them:

Build support has been moved to MSBUILD to enable better scaling, diagnostics, extensibility, and easier customization
New project editors can be used to create your own build lab scripts
C runtime multi-targeting (makes it easier to move to new versions of VS)
Improved code focused work including quick search, improved IntelliSense, etc

Creating build lab scripts:

Including easy use of relative paths:

Example of multi-targeting (V9 == 2008, V10 == 2010). You can also create your own extensions for other configurations:

binds to the right set of lib paths.

Quick search is indexed using a local database making it fast and easy to find things:

IntelliSense has also been improved to understand macros and #ifdef’s for more accurate editing.

Team Arch

Visual Studio Team Architecture has been updated to support standard UML (V2.1.1). With this support you can do architecture diagrams, sequence diagrams, etc:

Adding an artifact using the designer:

activity diagram:

Activity editor:

Integration with TFS including documents:

structural diagrams:

The Architectural Explorer allows you to browse through your namespaces and explore the structure of your application:

Once you find the code you want, you can create a sequence diagram to understand the code flow better:

You can view you entire system at the block level as well (handy for checking layering):

Test and Lab Manager

The new Test and Lab Manager tool (which is written using WPF and does not require the full Visual Studio install) allows you to manage both test cases as well as lab (virtualization) configurations:

Test plans are easy to create, execute, and track:

I will be posting a tutorial walk through of doing manual testing using the tool soon.

TFS

TFS includes several new features including branch visualization and easier tracking of changes through the system:

visualize your source hierarchy:

Source annotations now track back through branching operations so you no longer just see the person who made the branch operation. In addition, you can visualize a changeset and see where it has been applied:

Another changeset view:

Drag and drop can move a changeset from one branch to another:

change moved:

Build automation now targets the new Workflow support in .NET Framework 4.0. You can use the new designer to outline your builds:

TFS Reporting

Hierarchical work items are now supported:

Same in Excel:

As well as MS Project:

Rich text editing was common request for work item tracking. Turns out I had a dentist appointment during the Beta 1 demo walk through :)

TFS is the backing store for all work items and can be accessed via Visual Studio, Test and Lab Manager, as well as Office. Here you can see the same query run in Visual Studio as well as Test and Lab Manager:

TFS Web Access was added with VS2008. We’ve made upgrades to these features with VS2010 including integration with MOSS:

You can edit your main portal as a user and add your own webparts:

You can also create/edit webparts using Excel server:

And then publish them back:

Summary

Wow, that’s a lot of features! What’s amazing is that I haven’t actually covered everything in the release. We also have a number of advanced parallel computing advances, SharePoint tooling, new WorkFlow features, etc.

You can find instructions for downloading the feedback and sharing your feed back here. The best way to get prepared for VS2010 is to get VS2008 deployed today. You can find everything you need on our home page here.

Enjoy!

VS2010: On Triangles and Performance

2009-05-12T17:55:37Z

In February I blogged about the new look for VS2010. You gave us a huge amount of feedback which I really appreciate. I wanted to follow up on a couple of the themes that popped: the outlining mode with triangles and performance.

Outlining
You spoke loudly and clearly that you didn’t like the triangle outline mode. Based on this feedback, the team actually changed this feature in mid-flight during Beta 1 to reflect your feedback: no more triangles!! Here are some updated screen shots:

Hovering the cursor anywhere on the line highlights that region, double clicking the line will collapse it:

Once collapsed you can hover over the […] region to see a preview of the underlying buffer:

The region can then be expanded again either by clicking on the ellipses or the [+].

I want to thank everyone for weighing in on the new design. Your feedback directly led to changes in the product and as a result you’ll never see the original design in a public build.

Performance
Performance is another area you called out and something I care passionately about myself. In the interest of transparency I want to provide some updates about how we are doing and where we are headed.

First, we measure a *lot* of scenarios both with the core of the VS Pro experience but also with TFS server operations. We have literally hundreds of goals we track in the product. When a developer checks new code into the tree, it is also measured against a set of those goals to check for regressions (Regression Prevention System or RPS). As an example of these scenarios, a typical end to end test for VS Pro might include:

Start VS & load solution
Scroll down in a large file
Type a new method
Show Add Reference dialog
Add new form
Show toolbox
Add new control to form
Add event handler to control
Open existing form
Build/rebuild
Step into (F11 10 times)
Stop debugging
Close VS (w/solution open)

This is just an example but essentially I want to take a very typical daily usage of the tool and make sure it works really well. In addition to raw times for every step, we also do a version where we weight some of the steps as more important. For example you may only start VS once a day (or less) but you are likely to be typing all day long.

We run these scenarios on a variety of hardware, multiple versions of Windows, using our primary languages (C#, VB, C++, etc), using our presentation technologies (XAML, HTML, Windows Forms), etc.

For Beta 1 we are making progress on performance but it is not yet where I want it to be. For example the VB / Windows Forms application is actually doing pretty well while the VB / ASP.NET application is slower than VS2008 (similar with C#).

I’m committed to having the new innovations in VS2010 (editor, WPF, etc) while still maintaining a fast environment. I’ve asked Rico Mariani to dedicate a significant amount of time working on performance for this release to help make sure we get there.

Beta 1
We are getting *very* close to releasing Beta 1. Stay tuned here for the formal announce of the release and keep sending us your feedback!

New Name for Test and Lab Tools

2009-05-12T15:56:27Z

At the Professional Developers’ Conference (PDC) in October last year, we disclosed information on a generalist testing tool (codenamed “Camano”) within Visual Studio® Team System 2010 that focuses entirely on test case management. Today we have formally named the tool: Microsoft Test and Lab Manager! Test and Lab Manager will be available with several of the Visual Studio Team System products including Visual Studio Team Test 2010.

We expect that there will be plenty of cases where generalist testers will want to manage and execute test cases without installing the entire Visual Studio system on each machine. To help make that easier, we will also release a scaled down edition for generalist testers called Visual Studio Team Test 2010 Essentials.

This gives us a great line up of test related products:

Visual Studio® Team Test 2010	Support for the specialist tester including Web and load testing capabilities in addition to the ability to create automated test suites. Executes in the Visual Studio environment for test professionals. Comes with Microsoft Test and Lab Manager.
Visual Studio® Team Test 2010 Essentials	Support for the generalist tester including the ability to manage test cases and manual/automated test execution. Installs as a scaled down product for easy access on test machines.
Visual Studio® Lab Management 2010	Support for creating virtualized environments with snapshot capabilities. You can now execute your tests using the lab capabilities and save the state later for both development and test usage.

The new products are a great addition to the Visual Studio Team System product family and are a key part of our goal to help cut down on the number of “no-repro” scenarios that are experienced today between developers and testers.

We are finalizing Visual Studio 2010 Beta 1 as we speak. I hope you will install the builds and send us your feedback!

A Different Kind of Fan Boy

2009-04-16T17:24:12Z

The marketing team gave me one of these really cool VS2008 fans from the Japanese sub. It has the key board short cuts for the product on the back. It was too cool to keep to myself:

I’ve decided to place it next to my Cup<T>:

VSTS and the Platforms Magic Quadrant

2009-04-01T15:24:33Z

Over the last few months I’ve been sharing updates about VSTS 2008 and 2010, most recently sharing the new UI for VS 2010. Today I wanted to mention that leading analyst firm Gartner has positioned Microsoft in the Leaders Quadrant of its Software Change and Configuration management for Distributed Platforms Magic Quadrant. And, on a related note, they also recognized Microsoft with a Positive rating in their December MarketScope for Application Life Cycle Management. These are recognitions that I’m proud of, and happy to share.

Read the full reports here:

I think this news demonstrates that VSTS is rapidly maturing in the marketplace since its introduction in 2005. Our goal has been to deliver an integrated story that allows you to quickly create high-quality business applications in team environments. VSTS 2008 is a great platform for ALM and if you’re not already using it, check it out!

And as always, if you’d like to share your feedback with the Visual Studio team, please leave me a comment below.

The Gartner Magic Quadrant is copyrighted (SCCM MQ2009, March 26, 2009. MarketScope for Application Life Cycle Management, 12/17/08) by Gartner, Inc., and is reused with permission. The Magic Quadrant is a graphical representation of a marketplace at and for a specific time period. It depicts Gartner’s analysis of how certain vendors measure against criteria for that marketplace, as defined by Gartner. Gartner does not endorse any vendor, product or service depicted in the Magic Quadrant, and does not advise technology users to select only those vendors placed in the “Leaders” quadrant. The Magic Quadrant is intended solely as a research tool, and is not meant to be a specific guide to action. Gartner disclaims all warranties, express or implied, with respect to this research, including any warranties of merchantability or fitness for a particular purpose.

Essential LINQ

2009-03-28T03:33:22Z

Charlie Calvert and Dinesh Kulkarni have just released their new book, Essential LINQ.

LINQ was introduced with C# 3.0 and VB 9.0 (shipped with VS 2008) and stands for Language Integrated Query. The technology allows you to use SQL like syntax right inside your code. For example:

This simple C# expression declares an integer List object with four elements and allows me to query out all values greater than 12. The resulting variable q then has the numbers 15 and 20 in it. LINQ is very powerful in that the objects you query can include any data type represented by the CLR. That means you could be querying inbox mail messages from Outlook, SQL data, SharePoint lists, etc.

Essential LINQ walks you through everything you need to know to take advantage of LINQ starting from the basics and then working all the way up to transacted database applications. Highly recommended reading!

A New Look for Visual Studio 2010

2009-02-20T19:51:00Z

At the PDC and TechEd EMEA last year we described our new editor support built on the WPF technology in .NET Framework 4.0. Today I’m happy to reveal the new UI for Visual Studio, also built on WPF:

In this image you can see several areas of concentration:

Reduced clutter and visual complexity by removing excessive lines and gradients in the UX and modernized the interface by removing outdated 3D bevels
Placed focus on content areas by opening negative space between windows and drawing attention to the current focus with a dominant accent color and a distinctive background
Added an inviting new palette to make VS 2010 more distinctive

In the following image you can see floating documents which allows you to utilize multiple monitors while designing your project and writing code:

This image shows new support in the editor for outlining:

Triangle glyphs in the margin are used to collapse or expand your code blocks
Collapsed sections of code are marked with an empty triangle (pointing straight) as well as a set of ellipses
Colors on the margin indicate edits that have been made

The New Project dialog has also gotten an update to include online template viewing, a search box, and easier navigation. Multi-targeting remains in this version but now with .NET Framework 4.0 included as an option:

Visual Studio has a very broad and rich ecosystem of extensions written by our partners and folks like you. In VS2010 we wanted to make it easier for you to find those extensions and install them. We’ve enabled the new Extension Manager for this purpose:

With the Extension Manager you will be able to browse for templates and tools online and install them easily into the Visual Studio environment. The next public release of VS will have this new functionality and we’ll be hooking up the online capabilities through the Visual Studio Gallery as part of the final release.

These designs were developed and tested for user feedback by our User Experience team and implemented by the VS Platform team (excellent job!).

We hope you like the new look and feel of Visual Studio 2010. You’ll be able to play with these bits when we release Beta 1 which we are working hard on right now (no formal announce date just yet, stay tuned).

Enjoy!

Pep Talks

2009-02-18T23:19:02Z

I’ve found at times working as a team can be tough. The VSTS marketing team just released a new tool to help you out, The Coach. I decided to help my own team get on track:

Thankfully using Team System helped us out :)

You can send your own pep talks by following the customization tags. Enjoy!