Skinner's Blog

Performance tips using Windows Server 2008 as Workstation

My team and I do a lot of development on Windows Server 2008. Turns out it is a great workstation environment, but to really squeeze all the performance out of the environment, there are a few things you need to be aware of.

This article has a great walk through of many of the steps.

Most of this I was already aware of, but there were two steps that I was not aware of. After following the suggestions, startup performance of Visual Studio, and every other application I launch has improved significantly.

Be sure to take note of the "Performance Options" section, which has a great walkthrough of how to instruct the OS to optimize performance for Programs rather than ( the default ) Background Services.

The other tip is the "Turn on SuperFetch" service. SuperFetch is a service that is on by default in Win7 but off by default in Server 2008. This is the bit of magic that makes the OS more responsive to app startup based on past usage.

How did I miss this stuff???!!! :)

Links

I try not to do this too much, but wanted to make sure you folks saw a couple of posts that were especially relevant.

Visual Studio Team System 2010 Development Edition

Brian Harry just posted about the Visual Studio Team System 2010 Development Edition that you've gotta check out. He points out a few of the critical new features in the product that you can check out in the current beta 1 bits. Check that post out here.

DSL Tools Modelbus Sample

Jean-Marc, a fantastic Program Manager on my team, has recently published a sample that shows how to take advantage of the new functionality the DSL team has made available in the recent release of the DSL SDK 2010 Beta1. The sample demonstrates the use of the Modelbus, which is a new technology that enables sharing between disparate DSLs.

The source of the sample is here, and the documentation that describes the sample is here.

Enjoy!

Visual Studio 2010 and DSL Toolkit SDK Beta Now Available

The Visual Studio platform team has just announced the availability of the VS 2010 SDK beta! This is great stuff, and includes lots of new features around the new Editor that is part of 2010, as well as the new work we have poured into the DSL Toolkit.

Here's a link to the SDK.

One of the changes we've done this turn of the crank is to move the DSL Toolkit out of the main SDK, but be sure to make available the Toolkit whenever the SDK releases. We've done this for a number of reasons ( minimize download times, more flexibility to deliver bits more often, etc. ).

If you download the SDK, there will be a link to the DSL Toolkit bits from the Start Menu. That link will take you directly to the download page, which is here.

To get an idea of what's new in the DSL Toolkit in the beta, please check out this page. But for the impatient, here's a snippet:

"In Visual Studio 2010, the F5 experience is improved, and deployment of a DSL considerably simplified, exploiting the extension manager in the Visual Studio platform and the new facilities in the Visual Studio SDK top create a VSIX package which is a simple zip archive that unpacks itself into the User’s extensions folder.
Visual Studio 2010 Beta1 also brings 11 new DSL features:

1. Different models can now interact with each other, (and with Visual Studio Team System Architecture UML designers), using the ModelBus. A DSL author can choose to generate a ModelBus adapter, that will expose his model to other models or tools.
2. Databinding support has been added, allowing Windows.Forms and WPF form-based designers to be created by binding a standard winform or WPF-based UI directly to DSL models. This enables developers to quickly create designers such as the .ResX or .settings designers in Visual Studio.
3. It is now possible to have completely or partially read only models, which can be used for instance by reviewing and commenting tools.
4. A number of UI enhancements have been added, including :

• moveable labels for connectors,
• sticky toolbox (when the user double-clicks on an item in the toolbox,it’s not necessary to return to the toolbox for repeated applications of the tool),
• quick navigation and editing of compartments with the keyboard
• Copy and paste of diagram elements to images (in Bitmap and .wmf/emf)
• Copy and paste of model elements in or between diagrams

1. The notion of DslLibrary has been introduced. This enables factorizing and componentizing DSLs (for instance having several domain models have the same base-domain class). The authoring for this feature will not be present in Beta1
2. The DSLs can now be extended by third parties after they have deployment. The authoring for this feature will not be present in Beta1"

The team has worked extremely hard to hit this date, and in fact have shipped earlier than previously scheduled! This is a great milestone! :)

If you caught my talk at TechEd last week in LA, you can take out all those new capabilities that I demonstrated out for a test drive yourself.

Enjoy!

Cameron

10-4 Video on Beta 1 Installation

The guys and gals on channel9 have produced a quick video on how to get and install the Visual Studio 2010 Beta1 bits. Included with that video are a number of great links to other important information that you also may find useful, so please check it out!

VSTS 2010 Beta1 Arrives!

Soma just announced the availability of VS 2010, VSTS 2010, and .NET FX 4.0 beta 1 here.

This is a great milestone for all the teams involved, as a *ton* of work has gone into this beta, with much more following as we run to the final release.

MSDN subscribers can download the beta today from here, while the rest of us will have public access starting this Wednesday.

Can't wait to get feedback from you folks on these bits. This is *not* a VPC or hyper-v image. This is a full-up install. Please hit http://connect.microsoft.com in order to log bugs and give general feedback.

Have fun! :)

Cameron

TechEd 2009

It's that time of the year again, and once again, we find ourselves filling the Los Angeles convention center with over 7000 people, all there to hear about all the technologies Microsoft is bringing to bear to help IT get their jobs done easier / faster / more accurately. Check out the TechEd site for more details.

Monday was the first day of the convention, and I presented one of two talks and did a video interview with Dr. Zhiming Xue.

I presented a "Lap Around VSTS Architecture 2010 Edition" ( ARC201 ), where I went through all the new capabilities of the product that you can expect to see in this upcoming release.

The video interview can be found here. It's a quick little interview talking about the Architecture Edition in 2010, and the problems we're trying to solve with it and the rest of Team System. 13 minutes long, so enjoy.

This Wednesday I'll be giving one more talk. In that presentation ( DTL333 ) I'll be talking about all the new capabilities the team has poured into the DSL Toolkit that will be available in the VS 2010 SDK.

If you're here at TechEd, please drop by one of my talks, or the booth in the main hall. Would love to chat!

Cheers,

Cameron

TSUG-VE

There is a new Team System user group designed to bring people together from all areas of the globe. Why is "Team System User Group ( TSUG ) Virtual Edition ( VE )" different?

"We have different regional meetings each month targeting different time zones around the globe. The meetings work cooperatively but offer different content and topics.  By joining TSUG you can attend any or all of the different regional meetings based on the topics and meeting times best for you."

I'll be signing up to talk at an upcoming meeting ( date TBD ), so stay tuned.

Cameron

P.S.

I had beers recently with one of the organizers of TSUG-VE, Thomas Schissler ( far right ). Great beer, great food, great company! Can you name the MVPs? :)

Upcoming Presentations

For those of you folks who are planning to be in Munich, Germany between May 5th and 7th, please drop by the TeamConf conference. I'll be one of the folks keynoting the event along with Ken Schwaber ( the mastermind behind Scrum ). I plan on talking a bit more about Team System 2010 and what we are planning for this upcoming release, as well as postulate a bit beyond. ;)

Immediately after that event, I'm rushing back to the states to give a couple of talks at TechEd2009 held in Los Angeles this year.

I'll be giving two talks at TechEd:

"A Lap Around Team System 2010 Architecture Edition ( ARC201 )"

as well as

"Domain Specific Languages with Team System 2010 ( DTL333 )"

The "Lap Around..." talk will be going through many of the features that are present in the 2010 Architecture product that we have been working on, and that I have touched on in previous posts.

The "Domain Specific..." talk will be a drill into much of the work the team has accomplished with the DSL Toolkit and runtime that will be part of the 2010 VS SDK, as well as an integral part of the VSTS 2010 Architecture product.

Hope to see you at one of these events!

Cameron

Oracle DSP Provider and Quest Software

I just wanted to make sure everyone had heard of the great news that was announced today at VSLive! in San Francisco. Quest Software has announced that it will be building atop the rich extensibility infrastructure that is present in what was the VSTS Database Professionals box ( aka "Data Dude" ), now merged into the VSTS Developer box ( as of last October ), and providing a DSP provider targeting Oracle databases. This is great news, 'cause what this really means is that database developers can now use DBPro functionality against Oracle backends, in much the same way as database developers can work against SQL Server!

Check out some of the press coverage of the announce to learn more...

• http://www.sdtimes.com/ORACLE_DATABASE_DEVELOPMENT_COMES_TO_VISUAL_STUDIO_2010/About_ORACLE_and_QUEST_and_VISUALSTUDIO/33292
• http://www.centredaily.com/business/technology/story/1135766.html

This was the culmination of a lot of hard work by many people from both Microsoft and Quest. I personally am very glad and happy to see this actually come to pass!

WooHoo! :)

DGML, Containers, and VSTS 2010 Architecture Rendering

I previously pointed out how easy it was to manipulate and then render a .dgml file in the upcoming VSTS 2010 Architecture product. I want to continue that discussion by showing how easy it is to indicate to the product that you need to see nodes contained inside another, and a few other niceties along the way.

So we had previously started with a graph that looked like this:

In order to tell the VSTS 2010 Architecture product's DGML rendering engine to draw a container around the "From" node, you first start by adding another Link element that has the Source attribute named "My Container" ( value doesn't matter ), and the Target attribute's value set to "From" ( this value does matter ). When you add that to your graph, you'll see this:

Not exactly containing the "From" node at this point, but we're not done. We need to add two more things to the markup.

The first step is to add a Category element to the Link element we just added, with a value of "Contains". Markup should now look like this:

The second step is to add a Nodes element with a single Node element contained inside, like so:

The resulting graph looks like this:

Let me point out a number of things, and bring them to your attention. In the image below, I've selected the contained "From" node:

1. This is a number that indicates how many nodes are actually contained in the container.
2. The Id of the container. The Id must match the Source attribute value of the Link element that has the "Contains" Category attribute applied to it. You can further include a Label attribute to the Node element in order to use a different value for the container's title than the Id value. VSTS 2010 Architecture defaults to the Id value when the Label attribute is not present.
3. A chevron that can be clicked resulting in a collapsed or expanded container. The container in this example is clearly expanded, allowing you to see the contents of the container in the graph. The expanded state is captured in the dgml file via the value of the Group attribute on the Node element set to "Expanded". Setting that value to "Collapsed" collapses the container, hiding its contents. Here's a shot that shows the results of setting that value to "Collapsed" as well as using the Label attribute on the Node element:
   
4. This is showing that I have selected the "From" node.
5. Because I have selected the "From" node, the link between the "From" node and "To" node shows up. If you aren't selecting "From" or the "To" nodes, that link disappears.

That's it! I should also add that you can have as many levels of containment as you'd like. Hope that helps!

Cameron

VSTS Has a New Web Site

The VSTS product groups here at Microsoft are all heads down working as hard as we can to get the next great version of Visual Studio Team System out the door, VSTS 2010. We're working new features, fixing bugs, testing, listening to feedback, testing some more, and so on.

I'm proud of the fact that the Team System team in particular has a great reputation for not only listening to customer and MVP feedback, but doing something with it.

We have another great example of this that you can try out for yourself right here.

The VSTS home page on MSDN has received a load of "tender love and care" by a great team of people. Sharon Elkins took point on this project, and has done a fantastic job in making the content more discoverable, correct, and easier to soak up!

Please take some time to explore the newly organized site, as well as the new content found there, and above all else, keep the feedback coming! :)

Cameron

DSL Multiple Views example and other links

Mr. Provost was recently interviewed by the ElegantCode folks. Find that podcast here.

Wanted to make people aware of the excellent work two of our MVPs ( Pascal Recchia and Anthony Guerot ) have done recently with the DSL Toolkit. Checkout this great article on how they have manipulated the DSL API in order to get multiple views over a single store. They have also provided access to a video showing the functionality, as well as the code they created.

This is great stuff, and does show the power of the DSL framework that we have built the UML designers coming in VSTS 2010 on.

With the 2010 product, we hope to make this type of functionality even easier, with even more extensibility options possible with new APIs we will be providing.

Enjoy!

Directed Graph Markup Language ( DGML )

In this previous post I introduced you to the new format, and then this follow on post showed some of the examples of how the format is used to back some common graphs you can expect in the product.

In this post, I'm going to talk about a couple ways of controlling how links are rendered in the VSTS 2010 Architecture product.

The Graph Element

At the root of every DGML document is the DirectedGraph element. The default namespace for this document, attributed to this element, is http://schemas.microsoft.com/vs/2009/dgml. There are a number of xml attributes that is supported for this element that you will be able to quickly discover through the intellisense functionality off the file, but I want to call out the Background attribute in particular.

The Background attribute allows you to set the color of the background of the graph surface itself, either by name of ARGB hex values as documented here.

For example, this snippet of DGML:

Results in this graph:

Amazing, but good to know nonetheless. :)

The Link Element

A DGML graph is fundamentally all about nodes and the links between those nodes. You'll notice in the markup above the Links element containing one Link element. You'll also notice that the rendering engine that reads this particular DGML is smart enough to understand that a link cannot exist without nodes to connect, so automatically creates a "From" node and a "To" node based on the values found in the Source and Target attributes on the Link element.

The Link element has a number of interesting attributes that are directly supported. I'll call out a few here.

In order to change the background color of a link arrowhead, set the Backround attribute to "Red". You'll get something like this:

In order to change the color of the entire link, set the Stroke attribute to your desired color. If you only specify Stroke and not Background, the arrowhead fill color will also be changed to the Stroke color value.

You can also change the thickness of the link itself by assigning a value to the StrokeThickness attribute, like so:

You can also make the link a dashed line by playing with values in the StrokeDashArray attribute. The comma delimited values are converted to doubles, and are taken in relation to the StrokeThickness value, which is 1 by default. For example, setting StrokeDashArray to 5 with a default thickness of 1 results in something like this:

You can make the dashed line much more involved by adding more values to the dash array, as specified here. Here's an example:

Summary

Just a quick taste on how to control link rendering. We'll start to build up more knowledge as we go. In a future post, I want to show the Node element, and specifically get into how grouping / nesting is supported. Stay tuned!

Visualize Java Code

In this last post I introduced you to some *very* basic understanding of how DGML works. Now I want to take that knowledge out for a test drive. :)

What I've decided to do is a couple of things. I've decided I'm going to show how to visualize Java code using Antlr and Visual Studio 2008 and output a DGML file that the VSTS 2010 Architecture product found in the latest CTP can render.

Why am I doing this? Because I think it will be an excellent example ( you'll be the judge of that ) of how easy it will be to visualize all kinds of data, not just .NET languages. Java code, Work Items, MSBuild dependencies, on and on. Literally, this list is potentially enormous, gated only by imagination and effort ( aren't all good things this way? ).

In some future posts, I'll show how you can continue to tweak the DGML to do some things that you can't do in the current CTP, but can with current bits ( such as node grouping, advanced selection, etc. ).

Prerequisites

If you want to follow along on this little journey, you need to get the following things:

1. Visual Studio 2008
2. Latest JDK from Sun. Lots of options here but I ultimately went here and followed the steps.
3. Antlr 3.1.1 ( see below for instructions )
4. VSTS 2010 CTP ( follow link for instructions )
5. The Visual Studio 2008 solution that I used to create this post

Establish "Base of Operations"

I'm going to be very descriptive of what I'm doing 'cause the complication is not going to be in the implementation, but more in the "configuration of the parts".

1. Create a directory where work will be done. This will be our "Base of Operations". From here on out, I'll refer to this directory as %BOO%.
2. Download Antlr 3.1.1
   1. If this link becomes stale, go to http://www.antlr.org and download the latest source distribution which includes the runtime jars that you'll need.
3. Extract the contents of the download to the %BOO% directory. When done, you should have the following contents in the %BOO%\antlr-3.1.1 directory:
   
4. Ensure Java is installed correctly
   1. Open up a command prompt, CD to your %BOO% directory.
   2. Type the following: java -?
   3. If you don't see a typical "Usage" statement, then you probably have something installed wrong. For me, I had to make sure that the java bin directory was in my path, so I added that to my system environment variables.
5. Create a BOO.bat file that contains the following contents, and save to %BOO%:
   
   set BOO=%CD%
   set ANTLR_LIB=%BOO%\antlr-3.1.1\lib
   set classpath=.;%ANTLR_LIB%\antlr-3.1.1.jar;%ANTLR_LIB%\antlr-3.1.1-runtime.jar;%ANTLR_LIB%\stringtemplate-3.2.jar;%ANTLR_LIB%\antlr-2.7.7.jar
   
6. Ensure Antlr is now ready to go.
   1. At the command prompt, type BOO.bat and hit enter
   2. Now type java org.antlr.Tool and hit enter
   3. You should see this:
      
      
      If you don't, double check your BOO.bat file and make sure you don't have any typos.
7. Feel free to download the original Java.g file also available on the Antlr site. I've included the one I have modified in the solution I've made available in the "Prerequisites section":
   1. Click here.
   2. If it looks like a page just full of text, right click and say view source, then "Save As..." java.g into your %BOO% directory.
8. Unzip the solution I created into your %BOO% directory.
9. You'll need to replace the references to antlr.runtime, Antlr3.Runtime, Antlr3.Utility, and StringTemplate to those now in your %BOO% directory:
   1. Add Antlr C# runtime references to the project.
      1. First we have to extract the runtime files found in the %BOO%\antlr-3.1.1\runtime\CSharp\dist\DOT-NET-runtime-3.1.1.zip.
         1. Extract the contents of that zip to %BOO%\antlr-3.1.1\runtime\CSharp\Libraries
         2. Once extracted, you should have a bin directory.
      2. Right click on the References node in the project
      3. Click on the Browse tab.
      4. Navigate to %BOO%\antlr-3.1.1\runtime\CSharp\Libraries\bin\net-2.0
      5. Add all the dlls found in that directory as references. There should be four dlls in there, as mentioned above ( If you do everything I've just mentioned just right, this step shouldn't be necessary, as the solution I provided should be relative )
10. OK, we're ready to build.
    1. Rebuild the solution.
11. If all went well, you now have a parser that's ready to parse Java 1.5 code!

Results

The executable created after building the solution is Java2DGML.exe. If you drop to the command line, CD into the debug directory where the exe is found, run the following command:

Java2DGML.exe /f %BOO%\antlr-3.1.1\src\org\antlr\Tool.java > Tool.dgml

then open Tool.dgml in the VSTS 2010 CTP, here's what you'll see:

Here's the XPS file of that image as well.

The exe is by no means a robust piece of software. It currently understands how to gather information for simple Java classes ( i.e., not templated ), fields, and methods. No interfaces, enums, etc., but after this post, you should have all the info you need to take this example a bit farther.

Now let me explain the source a little bit...

Taxonomy of the Solution

Here is a shot of the Solution Explorer with the Java2DGML solution loaded:

Generated Files

Java.Tokens, JavaLexer.cs, and JavaParser.cs are all generated files. You can regenerate those files by executing the following command in you command window where you executed BOO.bat, in the %BOO%\Java2DGML\Java2DGML directory:

java org.antlr.Tool Java.g

Java.g

The Java.g file is where the grammar for parsing Java 1.5 is defined. This grammar file instructs the org.antlr.Tool object how to generate a parser in C# capable of parsing Java 1.5 code. More on this later.

DGMLContext.cs

A simple utility class used to gather information during the parse that is later used to generate the appropriate DGML. For every Java class, one DGMLContext object will be created to capture the relevant details.

DGMLFile.st

Antlr has a great mechanism built in called the StringTemplate framework. Check out this link for more details. This file is an example of a StringTemplate for DGML files. More on this later.

JavaParserImpl.cs

Antlr allows the C# developer to tell Antlr to create a partial class for its parser implementation so that additional behavior can be added and used in the grammar file more easily. I've taken advantage of that in this file.

Program.cs

This is the main program, where all the pieces come together.

Summary

This post is really meant to whet your appetite on some of the possibilities coming in the 2010 version of the Architecture product around visualization. Admittedly, I'm clearly just scratching the surface of this particular example ( Java source visualization ), but that's ok. From time to time, I may come back to this example and flesh out a little more in order to exemplify some deeper features.

In the meantime, I think in my next post I'll start to show some more of the features inherent in DGML, beyond just the simple nodes and links I've shown to date.

Stay Tuned!

Channel 9 and 10-4

If you are not already aware of Channel 9, stop what you are doing right now and go check it out.

Really.

I'll wait. :)

Channel 9 has a long a brilliant history of shining a light on all things that Microsoft is doing through the video medium. Soon after the 2008 PDC was over, the session videos were made available on Channel 9, allowing folks who couldn't make the conference to see the details, but also giving the folks who were there the ability to catch the sessions they were unable to catch in person. ( Here's the link to my talk at the PDC. )

In addition, when the VSTS 2010 CTP became available, the Channel 9 folks launched a series of videos that introduced you to the various areas of the Team System product line ( including your's truly :) ).

Well now, they're doing it again.

Today the Channel 9 folks have announced a new video podcast series entitled "10-4". The idea is simple: every week, provide a video to the community detailing various aspects of Visual Studio 2010 and the .NET Framework 4.0.

Check out Brian Keller's post for some more details.

I love those guys!