VS Team Architect Blog

Our Product Unit Manager, Cameron Skinner is back at the blogging game, as you can tell from his post we are working on some exciting new features for Rosario. 

http://blogs.msdn.com/camerons/archive/2008/06/13/new-role-running-the-vsts-architecture-edition-team.aspx

As Jeff announce late last week, the April Community Technology Preview of Visual Studio Team System code name "Rosario" is now available for download.  The Architecture Edition has added some exiting new features that we would appreciate your feedback. 

In Visual Studio Team System Codename “Rosario” April 2008 CTP, Team Architecture edition includes capabilities for:

· Exploring the Existing Code Structure

· Designing Process Flow as Activities

· Designing User Interactions with Systems

· Designing System Functionality as Components

· Visualizing and Designing Types in Systems

· Visualizing and Designing Interaction Sequences in Systems

We are looking forward to your feedback, as Jeff mentions in his post, bugs and suggestions can be submitted via Connect.  Please remember to select “Visual Studio Team System Code Name “Rosario” (April 2008 CTP)” for the product version, we don't want to miss your feedback.  Additionally we have a special forum for Rosario at: http://forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=1736&SiteID=1.  And as always please feel free to comment on this blog. 

Join members of the Visual Studio Team System product group to discuss features available in Team Foundation Server, Team Suite, Architecture Edition, Development Edition, Database Edition, and Test Edition. In addition, discuss what's new for these editions for Visual Studio 2008.

Add to Calendar

April 9, 2008
10:00 A.M. Pacific Time
Additional Time Zones

With our latest release, VS 2008, out the door, we have begun work on our next release and we want to hear from our customers.  So if you own Visual Studio Team System Architecture Edition or Team Suite please take a few minutes and help us by filling out this survey.  If you are a Team Systems customer and decided not to purchase the Architecture Edition, we would love to hear for you also.

One of the major changes in Visual Studio Team System 2008 Architecture Edition is the ability to design systems with a Top-down approach.  Richard Hundhausen has posted a great little video walking through the new feature.

http://msdn2.microsoft.com/en-us/vsts2008/cc178915.aspx

This blog discusses the new Architectural Roles feature available in the Visual Studio Team System 2008 Architecture Edition.

Architectural Roles (or Roles for short) are an extensibility point, allowing software architects to embellish objects of Application Diagrams, System Diagrams, and Logical Datacenter Diagrams with metadata that describes the responsibilities objects have within a design. The metadata can be a simple label that calls attention to the role, or it can include rich information about the role including documentation and even links to specialized tools.

In practice, an architect can employ this feature to provide custom and specific guidance to his/her team. Applying the Roles to specific objects in a design allows team members to consume the guidance.

For example, an architect could define roles that identify specific architectural layers (SmartClient, EntityService, GatewayService, etc.).

To do this, the architect authors new SDM resources to define the Architectural Roles (See example below: SampleArchitecturalLayers.sdmDocument), and registers the file under the key: [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\EnterpriseTools\Sdm\InitializationFiles]

The roles can be applied to specific objects in a design, by right clicking on a shape and choosing Add | Role | <Role Name>.

The role’s name will be visible on the object’s shape, and the role’s properties will be visible in the Settings and Constraints window. The user can query these properties to receive guidance. This extensibility point opens the possibility for Tools to be written to make use of these Architectural Role properties.

You can learn more about defining and using SDM resources in the System Definition Model (SDM) SDK: http://msdn2.microsoft.com/en-us/teamsystem/aa718757.aspx.

Copy and Paste the below XML into a file named SampleArchitecturalLayers.sdmDocument and use the SDM SDK to compile this document. 

<?xml version="1.0" encoding="utf-8"?>

<SystemDefinitionModel xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" Name="Microsoft.SdmDesigners.Example.ArchitecturalLayers" Version="1.0.0.0" DocumentLanguage="en" xmlns="http://schemas.microsoft.com/SystemDefinitionModel/2005/1" CompilationHash="1B4172215886FDDC7078F59AF6758811220084BF">

<Information>

<FriendlyName>Sample ArchitecturalRoles describing Architectrual Layers</FriendlyName>

<CompanyName>Microsoft Corporation</CompanyName>

<Copyright>Copyright (c) Microsoft Corporation. All rights reserved. This is provided AS IS with no warranties, and confers no rights.</Copyright>

<Description>

<Entry Name="Description">Contains some sample definitions of architectural roles .</Entry>

</Description>

<CompilerVersion>1.0.60130.0</CompilerVersion>

</Information>

<Import Alias="System" Name="System" Version="1.0.60130.0" Culture="neutral" />

<Import Alias="ArchitecturalRoles" Name="Microsoft.ArchitecturalRoles" Version="1.0.60130.0" Culture="neutral" />

<DesignData>

<VisualStudio xmlns="http://schemas.microsoft.com/SystemDefinitionModel/2005/1/DesignData/VisualStudio">

<ModelElement Type="Microsoft.VisualStudio.EnterpriseTools.Application.Modeling.SoftwareComponentDocument">

<Property Name="DocumentType" Value="AbstractTypes" />

</ModelElement>

</VisualStudio>

</DesignData>

<!--EntityService can be applied to either a WebService or a WebApplication-->

<ResourceDefinition Name="EntityService" Extends="System:ResourceDefinition" Abstract="true">

<Description>

<Entry Name="Description">A Sample Role</Entry>

</Description>

<SettingDeclaration Name="StandardPractices" Definition="System:String" CanBeNull="true">

<Description>

<Entry Name="DisplayName">Standard Practices</Entry>

<Entry Name="Category">Guidance</Entry>

<Entry Name="Description">A link to the Standard Practices guidance document.</Entry>

</Description>

</SettingDeclaration>

<SettingDeclaration Name="PreCannedDataContracts" Definition="System:String" CanBeNull="true">

<Description>

<Entry Name="DisplayName">Pre-Canned Data Contracts</Entry>

<Entry Name="Category">Contracts</Entry>

<Entry Name="Description">A link to existing data contracts.</Entry>

</Description>

</SettingDeclaration>

</ResourceDefinition>

<ContainmentDefinition Name="WebServiceRolesContainsEntityService" Extends="System:ContainmentDefinition" ParentDefinition="ArchitecturalRoles:WebServiceRoles" MemberDefinition="EntityService" />

<ContainmentDefinition Name="WebApplicationRolesContainsEntityService" Extends="System:ContainmentDefinition" ParentDefinition="ArchitecturalRoles:WebApplicationRoles" MemberDefinition="EntityService" />

<!--GatewayService can be applied to either a WebService or a WebApplication-->

<ResourceDefinition Name="GatewayService" Extends="System:ResourceDefinition" Abstract="true" />

<ContainmentDefinition Name="WebServiceRolesContainsGatewayService" Extends="System:ContainmentDefinition" ParentDefinition="ArchitecturalRoles:WebServiceRoles" MemberDefinition="GatewayService" />

<ContainmentDefinition Name="WebApplicationRolesContainsGatewayService" Extends="System:ContainmentDefinition" ParentDefinition="ArchitecturalRoles:WebApplicationRoles" MemberDefinition="GatewayService" />

<!--SmartClient can be applied to a WindowsApplication-->

<ResourceDefinition Name="SmartClient" Extends="System:ResourceDefinition" Abstract="true" />

<ContainmentDefinition Name="WindowsApplicationRolesContainsSmartClient" Extends="System:ContainmentDefinition" ParentDefinition="ArchitecturalRoles:WindowsApplicationRoles" MemberDefinition="SmartClient" />

</SystemDefinitionModel>

We’ve added a cool new feature called Delegation to the System Designer to really simplify top-down system design. Delegation makes it possible for you to define systems at higher levels of abstraction and progressively refine them until you end up with concrete applications. Although you could perform this task in Visual Studio 2005 Team Edition for Software Architects (see TN_1111: Top-Down System Design), the next version makes top-down system design a breeze!

In Visual Studio 2005, you can compose a new system from existing applications and systems. These applications and systems become members of the new system. The endpoints on these members describe the behavior of the members. You can expose this behavior outside the system by creating proxy endpoints. These proxy endpoints appear on the system but they represent real endpoints that always and ultimately live on an application (possibly via several layers of nested systems).

In Visual Studio 2008, you can now add endpoints directly to systems. You can then configure the behavior of these endpoints. For example, you can define the operations of a .NET Web Service Endpoint via the Web Service Details window (see Figure 1).

Figure 1: Define operations for a .NET Web service endpoint

You can then delegate the behavior of a system endpoint to a member of the system. This delegation will copy the endpoint onto the member and replace the system endpoint with a proxy endpoint. In essence, we allow you to define systems at higher levels of abstraction and progressively refine them until you end up with concrete applications. This is what we call Top-Down System Design.

To try this new approach, download convenient VPC images of Visual Studio Team System 2008 Beta 2 Team Suite from the following location: http://go.microsoft.com/?linkid=7171917

You may not be aware, but within Visual Studio Architecture Edition you can create customized versions of the applications, servers, endpoints, and zones that you find in the Distributed System Designers Toolbox. You can add these customized versions to the Toolbox as custom prototypes.

For more information about custom prototypes, see TN_1107 at http://msdn2.microsoft.com/en-us/teamsystem/aa718854.aspx.

In the VS 2005 version, there was no simple way to import or export the custom prototypes you create. To perform this task, you must open the Visual Studio directory, locate the prototype directory, and then figure out which prototype file corresponds to the Toolbox item that you want to import or export! We agree this is not a very elegant way of sharing files among a team.

In Architecture Edition 2008 we made it more convenient for you to import and export custom prototypes within Visual Studio. To import a custom prototype, right-click the Toolbox and click Import Prototype. Visual Studio will prompt you to select the prototype file that you want to import (see Figure 1). To export a custom prototype, right-click a Toolbox item and click Export Prototype. Visual Studio will prompt you to specify the location where you want to save the prototype.

Figure 1: The Import Dialog Box

You can also choose to import a custom prototype for all users or your use only (see Figure 1). This option helps filter the Toolbox for multiple users on a single computer. For example, if I want to add 100 new Toolbox items that only I will use, I can add them for my use only instead of adding them for all users on the computer!

Note: To add a prototype for all users requires administrator privileges. If you are running as a normal user in Windows Vista, you might want to save Toolbox items as for this user only.

We've just released the Team System Architecture Edition Power Tools.

The new download is available here

This release requires Orcas Beta 2.

Features in this release are :

• Class Libraries on the AD/SD
• View Class Library projects on the AD
• View references to Class Library projects as connections on the AD
• Create Class Library projects from the AD
• Create references to Class Library projects from the AD
• Synchronize properties between Class Library projects and their representative applications on the AD
• Create and use Class Library applications and references on the System Designer (SD)

Please give us feedback. You can do so by posting your questions/feedback to our forums.

Join members of the Visual Studio Team System product group to discuss features available in Visual Studio Team Foundation Server, Architecture Edition, Development Edition, Database Edition, and Test Edition. In addition, discuss what's new in Beta 2.

We will be holding two sessions:

Join the chat on Wednesday, August 1^st, 2007 from 10:00am - 11:00am Pacific Time. Add to Calendar | Additional Time Zones

            -or-

Join the chat on Wednesday, August 1^st, 2007 from 4:00pm - 5:00pm Pacific Time. Add to Calendar | Additional Time Zones

I know, I am a little late on this one, but if for some strange reason you did not hear the news, we shipped Visual Studio 2008 (Orcas) Beta 2 yesterday! 

More details from Soma's Blog and Brian Harry has all the details of where you can get yourself a copy or 2...

The first beta is available for Visual Studio Team Edition for Software Architects "Orcas".  You can download Orcas Beta 1 here, there are also VPC images available to give it a try.

Team Architect released the summary of new experiences and features in this Visual Studio edition recently here. In this post we'll focus on Conform to WSDL feature.

Conform to WSDL addresses the problems related to contract changes during the development lifecycle, by providing an automated means to update an existing Web service implementation so that that its skeleton (methods, method signatures and message classes) conforms to a specified WSDL contract. The developer is then required to make the associated changes to the business logic (and possibly the implementation logic), which generally cannot be known from the contract definition. This feature facilitates developers adopting a contract-driven approach to webservice development.

This feature is available as a context menu as shown below on all webservice endpoints both in Application Designer and System Designer (including System Endpoints).

Upon invoking this menu and providing the new WSDL file to conform to, the following is accomplished in the code file (if endpoint is implemented) or the model (if unimplemented):

· Creating method signatures with WebMethod attribute declarations for new operations.

· Modifying signatures of existing web methods for updated operations.

· Deleting the WebMethod attribute where operations are not present.

· Adding/modifying appropriate WSDL attributes to methods and message classes.

· Declaring/recreating new message classes while moving old message classes to an obsolete namespace.

· Adding comments whenever changes are made.

Of particular note is that the algorithm *never* deletes user-written business-logic which may contain valuable intellectual property or represent the result of significant effort that the user may wish to use in some other context.

Here is an example that demonstrates the usefulness of this feature. Below is the code-behind file of an endpoint that represents a webservice named CalculatorService. It has two webmethods Add and Divide that take integer inputs.

Feedback

Please try this out give us feedback on if this feature addresses some or all of your requirements for contract driven webservice development.

One of the features that we shipped within Visual Studio 2005 Team Edition for Software Architects is the ability to receive Intellisense within the Web Service Details windows while designing your .NET Web Service messages.  We thought this was a pretty cool feature since you are able to get Intellisense help before you have implemented the web service application. 

We would like to get your feedback on how valuable this feature is to you, and if we were unable to provide Intellisense on .NET Web Services before they were implemented how this would impact your experience using the product?  The reason I am asking is that there have been some changes made to the underlying framework that we use to provide this functionality and we may not be able to easily enable it within the Orcas release. 

To be clear Intellisense was only provided for System types within VS 2005, so if you use user defined types in your messages the feature was not available.  This issue also only impacts the Web Service details window for .NET Web Service endpoints that have not yet been implemented, Intellisense is restored once the hosting application is implemented. 

Intellisense on Non-Implemented Web Service Endpoint:

Intellisense not available:

We would really like your feedback on this issue, please either comment on this post or use the email link to send us a message.  Thanks!

In the DSL Tools, paths are used in a DSL definition to specify how to navigate from one object in the domain to another. They are used in various parts of the DSL definition, such as:

· Compartments: a path specifies which elements will be displayed in the compartment ;

· Decorator maps: a path can be used to specify the object that has the property to display in the decorator;

· ExplorerBehaviour: paths are used to specify which nodes to hide.

The path syntax is described on the DSL Forum at http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=464793&SiteID=1. Basically, a path is composed of multiple path segments. Each path segment specifies a transition from an object to a link, or from a link to an object.

However, the path syntax, although simple, is not particularly easy to work with and the current authoring experience is quite basic – as you type the path into a textbox, the individual segments of the path are checked and a tooltip is displayed if the path segment is invalid. The path as a whole is not checked until the validation rules are run against the model (e.g. by right-clicking on the design surface and selecting “Validate”), so it is possible to enter an invalid path in the textbox.

CTP 2 of the VS SDK for Orcas Beta 1 adds a richer path editing experience to the DSL Designer in the form of a drop-down tree control. You can now either type the path syntax as before, or you can drop down the control to display a tree of all of the valid paths from the current starting point.

This screen shot shows the path editor for a Task element in a language created using the Task Flow template:

The tree displays one or more root nodes, each root node representing a valid starting point for the path. In most cases, there will only be one valid starting point. For example, when specifying the model elements to display in a compartment, the starting point is always the DomainClass that the CompartmentShape containing the compartment is mapped to.

Each child node in the tree represents a domain class or link that can be transitioned to from the parent node, so you can build up a valid path simply by starting from the appropriate root node and navigating down through the child nodes until you reach the domain class or link you want to end at. Selecting the end-point node collapses the tree control, and the appropriate path syntax is shown in the text part of the control.

The tree control also enforces some other restrictions:

· A limitation of v1 of the DSL Tools means that a path may only contain one relationship that has a multiplicity of “many”. If you have selected a node that represents a “many” relationship, then there will be no more “many” nodes under that node.

· Paths of the form “A->B->A”, although valid, do not make sense in practice, so the nodes displayed by the tree won’t allow you to create paths like this. However, if you really want, you can still create “no-op” paths of the form A->B->C->B->A (!).

For performance reasons, validation rules are not run every time a path changes, so there are still some circumstances in which a path created with the editor may later fail validation (although these should be uncommon). Overall, however, the path authoring experience should be much simpler and quicker. Please try it out and let us know what you think!