The final version of the Feature Builder Power Tool designed to work seamlessly with Visual Studio 2010 has been released to the gallery.

Download it from here. There are a number of videos up on channel9 that you can check out to understand what Feature Builder is exactly by clicking on this link.

A real world example of how an internal Microsoft team has taken advantage of Feature Builder can be seen in this video. It is basically a video talking about how the Feature Builder was used in the latest Hands On Lab for Windows Workflow 4.

Nice!

If you use Visual Studio 2010 at all, stop what you are doing and install the Productivity Power Tools. It is extraordinarily easy to do so ( go to Tools->Extension Manager…, and search for “Productivity Power Tools” ):

There are a number of fantastic features in the Power Tool deliverable, but the one I want to point out is the new Solution Navigator. ( There have been a number of posts about these capabilities today, but I simply couldn’t help myself on this. I had to write about it! :) )

Solution Navigator: A Solution Explorer Replace

After you install the power tool and open your favorite solution, notice the new Solution Navigator tool window. The Solution Navigator gives a number of new features that you will quickly find invaluable. There are a number of little capabilities that you will find valuable, such as the ability to collapse all nodes in the navigator with one click of a button:

But this is just the start. You can also filter the Navigator by typing in a search string in the search toolbox as seen below:

In the example above, you’ll notice that I typed in “Main” in the search box, which highlights the “Main” method found in the Program class located in the Program.cs file in the OrderProcessor project. This exemplifies yet another fantastic addition, which is the ability to drill down into individual files to see the types found in those files. Nice!

You can do the same thing with Assembly references as well, which allows you to drill down into the assembly, getting at contained namespaces and types:

Another great touch is the ability to root the navigator to any arbitrary node. You do this by clicking the icon to the right of the node you want to root, or select the node and hit Ctrl-Right Arrow:

And here’s a shot of the Project node I selected above rooted in the navigator.

The great thing about this of course, is that it removes some of the noise in the UI when you are working in one particular area of your source base.

You’ll also notice the “All, Open, Unsaved, Edited” words below the solution. Below I’m showing you what happens to the navigator when I’ve got a three documents opened in the document well and want to filter the navigator so that I can quickly see what projects those files belong to:

I just can’t say enough how great this new capability is.

It has simply made my day! :)

Cameron

Chris Lovett has created another fantastic video that explains the ins and outs of manipulating the look and feel of DGML documents via the <Styles> markup capabilities that shipped with Visual Studio 2010 Ultimate.

Check it out here. Absolutely fantastic!

One of the many great things about the new IntelliTrace feature in Visual Studio Ultimate 2010 is the ability to walk up to a code base you are not familiar with and determine where to set your first break point.

How many times have you walked up to some code you’ve never modified with the thought, “boy, I’d love to just set a break point in that button clicked event handler…”? With IntelliTrace, that scenario is very simple.

Let me show you, by following along the following steps:

1. Please download this sample app. All screen shots are coming from that application.
2. Next, ensure you are running IntelliTrace with the default settings enabled. Best way to do that is to go to Tools->Options… and make sure your screen options look similar to mine:

   

   

   

   

3. Open up the CardGame solution and hit F5. You’ll see the following window ( minus the comment bubble ).

   

   What we want to do is find out where in the code the “button clicked” event for the “New Game” button is being handled.

4. Click the “New Game” button
   You should now see something like this:
   

5. Ensure the IntelliTrace tool window is displayed in Visual Studio by selecting Debug->IntelliTrace->IntelliTrace Events:
    
   
   After selecting that menu item, you should see the following tool window in Visual Studio:
   
   
   Click the “Break All” button.

6. Select the “Gesture” event in the IntelliTrace tool window:
   

7. Notice how source code is raised in the document well, with the button handler highlighted. NICE!
   
   

Now imagine you wanted to do a similar thing, except you wanted to see Gesture events associated with the clicking of a check box. No problem, but you will need to enable that event in the Options dialog, as it is not checked by default:

Be sure to explore the “IntelliTrace Events” in the Options dialog, as you will find all kinds of other options that you can use to get quickly into unfamiliar code, such as when the registry or file is being accessed, perhaps when an environment variable is being set, and so on.

As you explore further, keep in mind that you are able to filter the events in the IntelliTrace tool window so that you only see Gesture events ( for example ). You can do that quickly by typing in “Gesture” in the search toolbox of the IntelliTrace window:

Or by pulling the “All Categories” combo box down, deselecting all ( by unchecking the “All Categories” option ), and selecting “Gesture”:

Summary

This ability to quickly get into a code base that you are unfamiliar with by directing you to the location where you can set your first break point based on gestures made with your application can really save a lot of time. This is of course, just the beginning of all the things this new feature set allows you to do.

More later. Stay tuned…

Cameron

I’ve been saying since the first PDC “Lap Around Visual Studio” talk I did back in 2008 how “big” of release the Visual Studio 2010 release was and certainly is. The number of new capabilities now built into the product is simply amazing!

This does come with a challenge however. Customers have told me numerous times in the past couple of months how much they appreciate all the new features, and how much the product is helping them in their day to day. But the thing they want more of is guidance. Folks want and need to understand best practices and strategies on how to use these new features.

The new visualization and modeling tools is no exception.

The Visual Studio ALM Rangers has just released the Visual Studio 2010 Architecture Tooling Guidance ( download from here ), which has been a true group effort done by many MVPs and Microsoft personnel alike.

Here’s some details:

Visual Studio 2010 Architecture Tooling Guidance

Practical guidance for Visual Studio 2010 Ultimate, focused on modeling tools. This release includes common usage scenarios, hands on labs and lessons learned from community discussions. The scenarios include understanding and reverse engineering of existing solutions or starting a new solution from scratch. These are both common challenges that any dev lead or architect faces. The intent is not to give you an in-depth tour of the product features, but to present you with examples that show how these tools can support you in real world scenarios, and to provide you with practical guidance and checklists. This guidance is focused on practical ways of effectively using Visual Studio 2010 Ultimate and other tools to create a new or revised design as part of application lifecycle management.
The Rangers involved with this project are: Alan Wills (MSFT), Bijan Javidi (MSFT), Christof Sprenger (MSFT), Clemens Reijnen (MVP), Clementino de Mendonca (MVP), Edward Bakker (MVP), Francisco Xavier Fagas Albarracín (MVP), Marcel de Vries (MVP), Michael Lehman (MSFT), Randy Miller (MSFT), Tiago Pascoal (MVP), Willy-Peter Schaub (MSFT), Suhail Dutta (MSFT), David Trowbridge (MSFT), Hassan Fadili (MVP), Mathias Olausson (MVP), Rob Steel (MSFT) and Shawn Cicoria (MSFT).

Way to go Rangers! Great stuff!

Cameron

As you certainly know by now, we have released the Visualization and Modeling Feature Pack.

One of the new capabilities that we have enabled in the Pack is the ability to hook into the Layer Diagram in a number of different ways ( Command, Gesture, and Validation Extensions ).

I want to make you aware of an issue that you will certainly run into if you don’t first read our documentation.

The documentation is here: http://msdn.microsoft.com/en-us/library/ff657794.aspx entitled “Troubleshooting Extensions for Layer Diagrams”.

The essence of the issue is the need to install the Feature Pack in the experimental instance of Visual Studio.

If you follow the steps in the docs, you’ll be fine, and the good news this is a one time situation.

I wanted to point this out, ‘cause if you are anything like me, you might “miss” the documentation suggestion. ;)

Regards,

Cameron

In my “Sneak Peek…” post I promised to discuss the differences between a Feature Pack and a Power Tool. Now that we’ve just made our first feature pack available, it’s probably time to discuss these differences.

Brian Harry has just blogged about the differences and actually a larger spectrum of release vehicles that we use here on the Visual Studio team.

Check it out here.

It’s a great post, as usual. :)

Cheers,

Cameron

The MSDN Library of documentation has been updated.

Along with new content discussing the new features in the Visualization and Modeling Feature Pack, the page on Extending UML Models and Diagrams has been updated, and a number of new articles / whitepapers have been published:

· Customizing Team Foundation Server Project Portals

· Dynamic Performance Analysis: Rules and Guidance for Visual Studio Profiling Tools Users

· Profiling HPC Applications

· Remote Debugging Summary

· Streamline Testing Process with Test Impact Analysis

· Visual Studio 2010 SQL Database Projects

Hope that helps,

Cameron

I gave you a sneak peek about this new feature pack here, but I am now very happy to announce that the final release of Visualization and Modeling Feature Pack for VS2010 Ultimate is now available.

For you active MSDN subscribers, go download the feature pack from here as soon as you can, ‘cause it is chalk full of some great functionality.

Jason Zander has just announced the availability during his TechEd keynote speech in New Orleans, and has also blogged about this and the availability of the Visual Studio 2010 Pro Power Tools.

I will be blogging about the Feature Pack features in more detail in the days ahead, so stay tuned, and happy downloading! :)

Cameron

David Giard, the force behind Technology and Friends,  has just pushed up a conversation we had during last month’s launch tour about all the new visualization and modeling tools we have now made available in VS 2010.

Check it out here.

It’s amazing how quickly things change. In the time it took Dave to edit and put up his video, my team has now grown to include technologies such as the VS debugger and Intellitrace, as well as the Visualization and Modeling tools you see in VS 2010. :)

Cheers,

Cameron

David Giard, the force behind Technology and Friends,  has just pushed up a conversation we had during last month’s launch tour about all the new visualization and modeling tools we have now made available in VS 2010.

Check it out here.

It’s amazing how quickly things change. In the time it took Dave to edit and put up his video, my team has now grown to include technologies such as the VS debugger and Intellitrace, as well as the Visualization and Modeling tools you see in VS 2010. :)

Cheers,

Cameron

Jennifer Marsman has created a series of posts that capture the essence of my talks that I did on that last launch tour.

Check out this one, this one, and this one.

She does a great job of capturing the details of my talk, which shouldn’t be too surprising, as she was forced to listen to me giving the same talk 19 times in 5 days! :)

Nice job Jennifer!

Cameron

Jennifer Marsman, Developer Evangelist extraordinaire, has just blogged about the recent launch tour she organized. She was an absolute task master during this tour, making sure all details were covered and accounted for! It was a fantastic experience!

She’s made available the power point deck I used for the 19 talks I gave ( my voice still hasn’t recovered! ), as well as the demo solution I used ( a derivative of the PetShop 4 code base ).

I really can’t wait to participate in another tour of this kind, as I simply *love* getting in front of folks to talk about bits my team and I have poured our hearts and souls into. Even better is to see the looks on faces as realization of how much these new capabilities will help in their everyday. Love it!

My next public talk will be a launch keynote down in San Francisco on May 20th, so if you are around the Hyatt Regency on that day, drop by and say hello!

Cheers,

Cameron

The Sequence Diagram Reverse Engineering feature available in Visual Studio 2010 allows you to create a UML 2.1 “like” diagram that represents your source code. I say “like” in the previous sentence because we use all the notation prescribed by the UML standard, but there are a few instances where we add some notation that is not found in the standard. Support for LINQ and Lambda expressions are examples of where we have extended the Combined Fragment notation to include what we have dubbed a “Deferred Call”.

Here’s a simple console application that I’ll use to show what I mean.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        class Customer
        {
            public string Name { get; set; }
            public string City { get; set; }
        }

        static void Main( string[] args )
        {
            var customers = new Customer[]{ 
                                new Customer{ 
                                    Name="Sally Smith",
                                    City="Dallas"
                                },
                                new Customer{
                                    Name="John Roberts",
                                    City="Denver"
                                },
                                new Customer{
                                    Name="Cameron Skinner",
                                    City="Redmond"
                                },
                                new Customer{
                                    Name="Betty Silas",
                                    City="Redmond"
                                }
                            };

            Func<Customer, string > test = ( x ) => { return string.Format( "Name={0}", x.Name );  };

            var customer = from x in customers
                      where x.City == "Redmond"
                      select x;

            foreach( var x in customer )
            {
                Console.WriteLine( x );
                Console.WriteLine( test( x ) );
            }
        }
    }
}

And here’s the resulting diagram created by right-clicking anywhere in the Main() method and selecting “Generate Sequence Diagram…”:

( NOTE: Ok, it’s not exactly. I’ve collapsed a couple of lifelines to reduce the amount of information displayed. Notice the LifelineGroup1 lifeline? Try it out for yourself by generating the sequence diagram, then select the four Program.Customer lifelines by Ctrl + Left click, then right click and select Collapse. Once you do that, you might want to relayout the diagram in order to fill the resulting blank space. Do that by right-click and select Rearrange Layout. )

Take note of the two Deferred Call combined fragments. Here’s one that represents the where clause in the LINQ expression:

And here’s the other one that represents the lambda:

We wanted to make it very explicit and indicate to you that a sequence of messages may actually not execute in the exact spot on the diagram as indicated if you were looking at the diagram relative to time passing as you move down the Y axis. We found this important in both LINQ expressions as well as lambdas, ‘cause LINQ expressions are not necessarily executed at the time you step over that line in the debugger. And when it comes to lambdas, we wanted to show the actually definition of the lambda when invoked, as UML doesn’t really have a way to show that otherwise.

This approach may seem strange at first, especially when trying to get your head around the diagrammatic representation of LINQ expressions. Deferred execution in LINQ is common place. One technique that helps drive a deeper understand of LINQ’s deferred execution strategy is to step through the Visual Studio debugger. Once you do, you’ll also understand the diagrammatic representation better.

For example, hit F11 to start stepping into this code. Keep hitting F11 until you get to the foreach statement:

( Notice how you stepped right over the LINQ expression to get to the foreach? )

Hit F11 again and customer will be highlighted. One more time and the in keyword will be highlighted. One more time and the highlighted statement to be executed next jumps to the where clause of the LINQ expression:

Hit F11 a few more times and the highlighted statement jumps back down to the foreach statement. This is “deferred execution” in action!

Hope that helps,

Cameron

I got a number of great questions in last weeks launch tour. One of those questions was a general need to understand how the various dependency analysis features in VS 2010 Ultimate worked vis-a-vis WCF services, and whether there was support for walking across the service boundaries to discover further dependencies on the other side.

The short answer is “No”. How’s that for short. :)

The analysis that we are doing to determine dependencies as well as call information when generating the Sequence Diagram from code is all done statically. That means we are not going to pick up types that were loaded up dynamically at runtime, nor are we going to be able to walk across a service boundary, given how complicated endpoint configurations can be. Dynamically loaded types that are “injected” at runtime is high on our product backlog for next version, but walking service boundaries is not.

The main design principle behind the tooling you see in VS2010’s visualization and modeling tools is the need to understand your existing system’s current dependency “web”. The idea being that in many of the systems we’re seeing out there, dependency management is difficult, and as a result, dependencies are a mess in many of those applications. We wanted to give you some tooling to help deal with that mess. That mess is generally due to the inability to understand how one piece of code can adversely impact a piece of code somewhere else in the system due to complicated dependency coupling more than one or two “hops” away. So we prioritized dependencies that we could discover statically. Next priority is pull in runtime analytics so dynamically loaded types and the dependencies therein can be reasoned over. Then sometime after that, service boundary dependencies.

We prioritized this way ‘cause we learned that most shops out there aren’t doing anything explicit about dependency management, such as leveraging an IoC framework. So we wanted to optimize for the larger issue.

All that said, it isn’t as though folks using IoC frameworks or services don’t have dependency problems. But the problems for them are probably not at the boundaries they have explicitly addressed, but more internal to the subcomponents they are injecting, consuming, etc.

Hope that makes sense. :)

Regardless, what does running Sequence Diagram RE over a WCF client look like? Take a look at the following picture, created by right-clicking in the Main() method of the client code of a very simple WCF client. ( Check out this very simple tutorial for WCF ).

You’ll see that the calls stop at the contract of the service. CalculatorClient is simply a proxy created with the ServiceModel Metadata Utility Tool ( Svcutil.exe ). We do not grovel across that boundary to analyze calls on the actual implementation side of the service.

Another way to look at this is via the DGML Assembly Graph, shown here:

Notice that there is no link between the “Service.Exe” assembly and the “Client.Exe” assembly.

Hope that helps,

Cameron

The amount of new features that we have enabled in VS2010 is simply staggering. Scott Guthrie just put out a great post summarizing most of the new IDE and .NET features we just shipped yesterday. Check it out here. That post doesn’t even touch all the new things we shipped on the ALM side of the house, such as all the new Test capabilities, UML diagrams, Intellitrace, etc., just to name a few.

To help you get a leg up on all these new capabilities, AppDev and Microsoft are teaming together to give you 15+ hours of online Visual Studio 2010 training at no charge. A big piece of this training is also focused on the ALM tooling where a lot of the new surface area of the product can be found.

Follow this link to get more info, but here’s a quick blurb as well:

This free online learning for Visual Studio 2010 features practical, demonstration-based instruction by Microsoft experts like Ken Getz, Robert Green and Chris Menegay, plus sample code and pre/post exams. Use these courses to get up to speed on the most important new features and functionality in Visual Studio 2010 so you can better serve your clients.

This free online learning covers these courses and topics:

• Exploring Visual Studio 2010 Using Visual Basic or Visual C# (2 complete courses)
• Investigate new language features and see the benefits of the new WPF-based IDE
• Learn about many of the new ASP.NET Web Forms features
• See how the all-new Workflow 4.0 works and get started learning its features
• Create services using the new features in WCF
• Drill into new WPF features, focusing on new controls, data binding and more
• Create Silverlight applications using the new designer built into Visual Studio 2010
• Incorporate Office 2010 features into .NET applications, focusing on SharePoint 2010
• Exploring Visual Studio 2010 ALM Tools (4 of 8 modules)
• See the new features of Visual Studio 2010 Application Lifecycle Management (ALM) Tools
• Understand about Team System and Excel Reports as well as Ad-hoc reporting
• Then move on to Version Control with Team Foundation Server version control concepts
• Learn about Microsoft Test and Lab Manager for test plans for both manual and automated testing

Hope that helps! Let me know what you think!

Cameron

Not only is Visual Studio itself launching today, but a couple of supporting deliverables are also now available that I wanted to make sure you were made aware of.

If you created models ( UML, Sequence Diagram RE, or Layer Diagrams ) with the Beta2 version of Visual Studio, or created work item links to model elements in the RC version of the product, please download our upgrade tool from here. If you created these models in the RC build and didn’t take advantage of work item links, you need not bother, as the models will open just fine.

At the same time, the final version of the Visual Studio Visualization and Modeling SDK is now available from here. Check out Jean-Marc’s post on more details about this release of the SDK here.

Cheers!

Cameron

As you undoubtedly have heard by now, VS2010 and .NET Framework 4 have officially launched! WooHoo!

This is an enormous achievement by literally thousands of men and women here at Microsoft, as well as close partners and friends. Truly an accumulation of multiple years of effort, now being made available today. Makes me tired just thinking about it! :)

But the work is not yet done for many of us folks on the product team, marketing, and field folks. What you will be seeing in the weeks ahead is a huge push from a large number of us trying to get the word out, as well as make ourselves more available to customers both existing and potential. The sheer amount of new capabilities in Visual Studio 2010 is simply staggering, so it will take a while for folks to understand what is there, let alone how best to use these new capabilities in their day to day jobs.

So I will be doing my part to help get the word out and have the more face-to-face conversations with you folks.

I will be travelling the Midwest at the end of this month with one of our best Developer Evangelists, Jennifer Marsman, hitting customer sites, presenting at user group events, etc. Check out Jennifer’s post about this tour for details.

If you are in the area on any of those dates, please drop by. Oh, and don’t let my “glamour” shot scare you away. :)

Cheers, and happy launch day! :)

Cameron