Search results matching tag 'tsbt-arch'

PDC 2009

camerons — Thu, 05 Nov 2009 08:00:00 GMT

Realized I haven’t mentioned that I am planning on giving a talk at this year’s PDC. Here’s that abstract:

Visualization, UML, and DSLs

Cameron Skinner

Microsoft Visual Studio Team System 2010 Architecture Edition introduces a whole host of new designers and modeling tools to help enterprises and teams build software. UML Diagrams and the Layer Diagram can be used to plan and design the assets your team will produce, and communicate effectively about those designs during the entire development lifecycle. The Architecture Explorer and Graphs help you investigate and better understand the assets you have to enable more effective planning and decision making. Come learn how you can use all of these tools when investigating your current assets, and planning and designing your future work.

I hope to see you all there!

One other thing that I also want to mention is that Jens Jacobsen, a Program Manager on my team, has just started blogging. His first-time post is right here.

I’m looking forward to watching what Jens comes up with, as he is planning on focusing in on how to improve overall User Experience of the tooling we are producing, now and into the future. He is uniquely qualified to lead the charge on this as he has deep experience in user experience research.

So check out his blog and give Jens some feedback / participate in future discussions he begins.

Thanks!

Cameron

Providing Feedback

camerons — Mon, 26 Oct 2009 07:00:00 GMT

By now, you’ve pulled down the Beta2 bits and have started exploring. ( No you say? Please check this post for details on how to get the bits…. )

You may have questions, want to express concerns, find bugs and want to report them, or in general just look for more venues where topics specific to the Architecture and Modeling tools in Visual Studio 2010 can be found.

The MSDN forums are the place to start, and in particular, the following two forums have been created for the Beta2 bits:

Visual Studio Architectural Discovery & Modeling Tools
”Discuss the code visualization and modeling tools in Visual Studio 2010, such as Architecture Explorer, dependency graphs, UML diagrams, and layer diagrams”

Visual Studio 2010 Domain-Specific Languages (DSL) & Modeling Tools Extensibility
”Discuss the Microsoft Domain-Specific Language (DSL) Tools and extending the architecture and modeling tools for Visual Studio 2010”

As the product roles into RTM, these forums will be the place to directly interact with MVP, fellow users, and of course the folks from Microsoft that actually built the product!

See you there! :)

Cameron

Custom Toolbox Items

camerons — Thu, 22 Oct 2009 07:00:00 GMT

[NOTE: This post is part of a blog series, the start of which is here.]

When defining layer diagrams for your organization, or various other modeling concepts and diagrams that you want to make available to your team, you can of course simply check in those diagrams to your version control system, such as Team Foundation Server. But another mechanism we have enabled in the product that can easily be overlooked is the ability to create custom toolbox items from existing diagrams ( UML or Layer ), and then make those available through the VSIX mechanism also new in Visual Studio 2010.

In this post, I’m going to walk you through the steps needed to create a couple different custom toolbox items. ( I’ll talk about the new VSIX capabilities in another post. )

Let’s create a Layer Diagram ( I discuss the basics of what the Layer Diagram is about here ) that can be used as the pattern for a new toolbox item that will appear whenever a Layer Diagram is present in the VS document well.

1) Select the “Architecture->New Diagram…” menu item.

2) Select the “Layer Diagram” in the Add New Diagram dialog, and give the diagram the “PresentationLayer” name:

3) If you are following along exactly, this will prompt you for the name of a new modeling project. Let’s give the project the name of “CustomToolBoxItems”:

Cool. Now the new layer diagram and modeling project show up inside Visual Studio.

What we’re going to do now is replicate a layer diagram that is found in the second edition of the Patterns & Practices Architecture Guide. Specifically, the layer diagram described in Chapter 6: Presentation Layer Guidelines.

4) Create the following layer diagram:

Tips & Tricks, plus a Beta2 BUG ALERT:

I cut a quick video to include with this post to show a couple of suggestions / tips on how to quickly build the diagram above, as well as call out some funky behavior in the Beta2 build that has since been corrected. Here’s that video.

One thing I failed to mention in the video is that you can navigate in and out of nested layers by holding the Shift-> to get the tab to go to inner layers, and Shift-< to go to containers.

5) Save the PresentationLayer.layerdiagram

At this point, you need to create a directory in your %userprofile%\my Documents\Visual Studio 2010 directory.

6) Start a command prompt and cd to %userprofile%\my Documents\Visual Studio 2010

7) Create a directory called “Team Architecture”

8) cd into the “Team Architecture” directory and create another directory called “Custom Toolbox Items”

9) Copy your “PresentationLayer.*” files from your modeling project to the “Custom Toolbox Items” directory.

Here’s an image of my command line actions of steps 5-9:

Ok, we’re almost there. Before we exit Visual Studio, do take notice of the current toolbox window, which should look something like this:

10) Exit and then restart Visual Studio, and create a new modeling project.

11) Create a new layer diagram

Once the new layer diagram is visible, your toolbox should look something like this:

At this point, you can select the “PresentationLayer” toolbox item and drop into your new layer diagram. You should see the exact same diagram that we created in the step 4!

Now this is great, but we also give you the ability to control how these new toolbox items are displayed and organized. Enter the .tbxinfo file.

12) Create a file called “MyCustomItems.tbxinfo” in the “Custom Toolbox Items” directory we created in step 8.

13) Open that file in Visual Studio, and paste the following code:

<?xml version="1.0" encoding="utf-8" ?>
<customToolboxItems xmlns="http://schemas.microsoft.com/visualstudio/2010/TeamArchitect/CustomToolboxItems">
<customToolboxItem fileName="PresentationLayer.layerdiagram">
    <displayName>
      <value>Presentation Layer Pattern</value>
    </displayName>
    <tabName>
      <value>Patterns & Practices</value>
    </tabName>
    <image>
      <bmp fileName="cloudservice.ico"/>
    </image>
    <f1Keyword>
      <value>PLayerHelp</value>
    </f1Keyword>
    <tooltip>
      <value>Create the Presentation Layer As mentioned In Pattern And Practices' Architecture Guidance v2</value>
    </tooltip>
</customToolboxItem>
</customToolboxItems>

Once you save that file, exit Visual Studio, open a modeling project and open a layer diagram, you’ll see the following:

NOTE:

As you play around with these custom tool box items, it is possible that you’ll start to see toolbox items from past experiments. If you start to see things your aren’t expecting, right click in the toolbox and select “Reset Toolbox”:

That’s it! You can experiment with adding more custom toolbox items created by using layer diagrams, and you can do the exact same thing with any of the UML diagrams as well. This is a great way to get started with Design Patterns or any other template you’d like to make more accessible with your engineering team.

Enjoy!

Cameron

[NOTE: This post is part of a blog series, the start of which is here.]

DSL SDK for Visual Studio 2010 Beta2 Released

camerons — Thu, 22 Oct 2009 07:00:00 GMT

Jean-Marc has just posted some great details on the Beta2 version of the DSL SDK.

The amount of capabilities that have gone into the DSL Toolkit this version has been great to see. That team has done a fantastic job of increasing the power of what a DSL created via the toolkit can get done.

Man, this has been a crazy week, in all the best of ways! :)

Lovett is Blogging!

camerons — Mon, 19 Oct 2009 07:00:00 GMT

Chris Lovett, an architect on my team who has a glorious and long history with Microsoft, has finally joined the blogosphere! His expertise is all things .NET, but in particular he knows the code behind the new DGML graphs and dependency diagrams that are new in Visual Studio 2010 Ultimate.

His first two posts are fabulous, both of which include videos of Chris walking through some of the power of the DGML graphing technology. Be sure to check out his “teaser” post here, and a more in-depth post on our Standard Dependency Graphs.

Be sure to subscribe to his blog, as I know he’ll be putting up quite a bit more content in the weeks ahead.

You’ll be glad you did! :)

“First-time Experience” with Arch Tools

camerons — Mon, 19 Oct 2009 07:00:00 GMT

[NOTE: This post is part of a blog series, the start of which is here.]

Ok, you’ve downloaded the Beta 2 bits of Visual Studio 2010 and .NET Framework 4.

Now you want to explorer the new Modeling and Visualization tools. This post will help you make those first couple of steps.

1) Launch Visual Studio

Notice the new top-level menu item called “Architecture”:

With no solution open, selecting the menu item simply results in the following:

2) Select “New Diagram…”

After a couple of seconds, a dialog box appears, which looks like this:

This dialog makes it very easy to see all the diagrammatic capabilities that are new in 2010. You see the ability to create a total of five different UML diagrams, a Layer Diagram option, and last but not least, the Directed Graph Document.

I’ll go into detail on all these later, but for now, just accept all the defaults and hit the OK button.

Now, because you do not have any solution open, you will see the following dialog:

( You’ll see the same dialog even if you have a solution open, but no Modeling projects exist in the solution ).

BUG ALERT:

Unfortunately, a little bug slipped through the cracks that I want to point out so you don’t waste your time logging a bug that has already been fixed.

If you hit the cancel button at this point, you’ll see this dialog:

You can hit the OK button and no harm will be done, but not quite the experience we’re looking for. ;)

Take the defaults and hit the OK button. You should see something similar to what you see in the image below ( minus my red annotations of course ):

At this point, your ready to start adding items to the class diagram to your hearts content. This is a pretty common first couple of steps that you will take as you start using VS 2010 Ultimate to model your problem domain using the various UML diagrams.

The steps above are very similar if you have an existing solution already open, but I do want to point out a couple of differences. The steps below are quite common when you are looking to the tool to help you understand an existing code base.

3) Open an existing solution

Just open any solution you’ve got within reach. I’m going to open up the old standby, Petshop 4.0. ( This will result in the current solution being closed, but don’t worry about that. )

Once your solution is opened, you’ll see some new additions to the “Architecture” menu item:

Go ahead and try one of the menu items out. I selected the “Generate Dependency Graph->By Assembly” menu item, which resulted in a graph that looks like this:

Don’t worry about the details on this yet. We’ll be diving into those details in future posts. For now, we’re just kicking tires.

One last thing to point out before calling this post done.

4) Open up a source file

In my case, I’m going to open up the Order.cs file in the OracleDAL project.

Find a decent size method in your class, right click in the text editor, anywhere within the method and select …

5) Generate Sequence Diagram

You’ll see this dialog:

Just take the defaults and hit OK. In my case, a diagram is generated that looks like this:

Again, I’m not going to go into any more detail on this than I have just done. I just wanted to point out a few very common ways into some of the new features in the product.

As I pointed out in this previous post, I’ve got a lot of topics I’m going to nail down for you. I don’t have any specific order that I’m committed to following, so if you have some preferences of which topics I do first, please let me know!

Cameron

NOTE: This post is part of a blog series, the start of which is here.

Visual Studio 2010 and .NET Framework 4 Beta 2!!!

camerons — Mon, 19 Oct 2009 07:00:00 GMT

Ok, it has been a little while since I blogged last, but it is for good reason, and now’s the time to show you why.

The entire Visual Studio team, including my own, have been working extremely hard to get the Visual Studio 2010 Beta 2 release squared away, and I’m very pleased to announce that those bits have been made available as of 9:00 AM PDT today! ( See Soma’s announcement here. )

WooHoo!!!

There have been simply a *ton* of changes to the product since last we chatted, both from a functionality perspective ( we’ve made lots of progress that I can’t wait to tell you about! ) to changes in the Visual Studio SKU structure, to logo and name branding, and pricing changes. MSDN itself has been redesigned!

But first and foremost, if you are an MSDN subscriber, stop what you are doing and go down load Beta2 and the .NET Framework 4 bits from this link. I really think you’re going to like what you see! And Beta2 is a “Go Live” release, which means we are encouraging you to use the product in production, with an implied understanding that if serialization formats or what have you change between now and RTM, we’ll provide a way to move your data and artifacts forward so that you don’t lose any work.

If you aren’t an MSDN subscriber, general availability for the release will happen on October 21st.

To get more information on the new packaging and licensing details, please visit this link. But here’s a taste of the new Visual Studio 2010 logo:

And to top everything else off, the official launch date for Visual Studio 2010 and .NET Framework 4 is March 22nd, 2010!

SKU Structure Change

A couple words about the changes that you can read more about here. The Architecture Edition, along with many of the features of the Team System 2008 Development box, are now part of the Visual Studio 2010 Ultimate product.

The Visual Studio product line has moved to more of a “Russian Doll” model in regards to how the features are represented in each version of the product. At the top of the stack, including all the features and functionality of Visual Studio 2010 Premium and Visual Studio 2010 Professional, is the capabilities found in Visual Studio 2010 Ultimate. Going forward, I’m going to be spending my time with posts describing the Modeling and Visualization technologies in Ultimate, as that is what I know best, as that is what my team does. :)

But quickly, here’s a general view of the capabilities found in the new SKU structure. Please understand that from a feature perspective, Ultimate contains everything you see in this list ( all the Premium + Professional features ), plus the Ultimate specific features.

The features in red are the ones my team is responsible for delivering. Those features are the ones I will continue to blog about in depth in the days and weeks ahead.

Microsoft Visual Studio 2010 Ultimate ( includes all features from Premium and Professional SKUs ):

IntelliTrace
UML Modeling
Layer Diagram & Architectural Validation
Architecture Explorer
Web Testing
Load Testing

Microsoft Visual Studio 2010 Premium ( includes all features from the Professional SKU ):

UI Test Automation
Test Impact Analysis
Performance Profiling
Static Code Analysis
Code Coverage
Code Metrics
Database Change Management
Database Deployment
Database Unit Testing
Test Data Generation
Read-Only UML, Layer, and DGML Graphs

Microsoft Visual Studio 2010 Professional:

Silverlight Tools
Multi-Core Development
Sharepoint Development
Cloud Development
Web Development
Windows Development
Generate from Usage
Office Development
New WPF Editor
Customizable IDE

So stay tuned, as I’m planning on a number of posts that are designed to drill into the new features available in this beta 2 release of Visual Studio!

Cameron

DGML, Containers, and VSTS 2010 Architecture Rendering

camerons — Mon, 23 Feb 2009 08:00:00 GMT

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.

NOTE:

I do need to make one thing clear before we move forward. The difference between the core DGML and the additional capabilities you will find in the Architecture product is significant. The core DGML markup is limited to very few elements: DirectedGraph, Nodes, Node, Links, Link, Categories, and Category. Any additional markup beyond those basic elements is specific to the VSTS Architecture product.

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:

This is a number that indicates how many nodes are actually contained in the container.
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.
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:
This is showing that I have selected the "From" node.
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

DSL Multiple Views example and other links

camerons — Tue, 27 Jan 2009 08:00:00 GMT

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 )

camerons — Mon, 26 Jan 2009 08:00:00 GMT

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!