Wat zeggen de experts?

VS2010 TMap Testing Template | Initial Work Items #1

info.nospam@nospam.ClemensReijnen.nl (ClemensReijnen) — Wed, 10 Mar 2010 00:54:14 -0800

During the unfolding of the TMap for VS2010 process template, several pre-defined work items are created for the test organization. These work items helps the test organization to start structured test process with a Master Test Plan.

When starting a testing effort first several things needs to be in place… we need to understand the assignment, determine what we are going to test what are the risks, etc… the first four steps in the image below.

Beside these steps also decisions needs to be taken about what to test where, you don’t want to loose money by testing things twice. As described in the TMap Next book:

The type of system and/or development approach and/or test policy determine which forms of which test levels are best used. For iterative system development, for instance, a thorough acceptance test is less obvious. This is because the quality from the user perspective has already been tested in previous test levels. However, for package implementations there is a far greater emphasis on a thorough acceptance test. The risks here are focused on the implementation of the package in the organization, a typical acceptance test aspect.

So, topics covered by the master test plan can be:

All these activities are described in detail in the TMap Next book, and you also get these steps when using the TMap for VS2010 process template, as initial work items.

These Master Test Plan activities got descriptive guidance attached to it. Accessible by using Microsoft Test Manager 2010, Visual Studio 2010 or the TFS 2010 Web Access tool, helping every role, to understand the assignment, the activities and test goals.

[Microsoft Test Manager 2010 | Initial Master Test Plan Work Items with guidance]

[Visual Studio 2010 | Initial Master Test Plan Work Items with guidance]

[ TFS 2010 Web Access | Initial Master Test Plan Work Items with guidance]

So, when the project starts the guy / girl with the Test Manager role has to assign the different tasks to the right team members to complete the Master Test Plan.

In a following post [probably not the next one] some Word and Excel templates which support these tasks and can be found at the project portal. First a planned post about initial work items for planning the infrastructure.

If you want to keep up to date about TMap testing and the VS2010 process template, send me an email with your name and organization. Beside this blog and our the TMap codeplex site we have a community of users, to exchange ideas, usages stories and additional updates of the template en testing practices.

TMap for VS2010 Testing Process Template RC published on Codeplex.

info.nospam@nospam.ClemensReijnen.nl (ClemensReijnen) — Tue, 09 Mar 2010 05:22:47 -0800

A bit later as planned, due to my broken leg.

Just checked in the RC version of the TMap for VS2010 process template…
Downloaded it from TMap.Codeplex.com.

Still a lot of work to do, specially on the documentation and reporting part [lucky me, my colleagues from Sogeti US, Sweden and other Sogeti countries are helping me]. But still, the documentation section is a very good starting point when you want to discover the TMap processes for VS2010.

Later this week I will post some more content.

Speaking at Dutch DevDays and Danish ALM Day

info.nospam@nospam.ClemensReijnen.nl (ClemensReijnen) — Sat, 06 Mar 2010 23:14:00 -0800

Will be speaking at the Dutch DevDays [about VS2010 general/practical usages] and Danish ALM Day [about TMap for VS2010] in March/April.

The Hague, The Netherlands
March 30-31, 2010
DevDays 2010

[update]
Will give the interactive session "ALM Best Practices: Modeling the Showcase Application" with @Edwb (www.edwardbakker.nl) and the session "ALM Best Practices: Testing the Showcase Application" with www.RobKuijt.nl. Rob is a real tester, who will give an interesting look in the world of the tester.

Copenhagen, Denmark
April 9, 2010
ALM Day 2010

Not as much as Brian Keller [4 weeks, 7 countries, 25+ sessions, 1 suitcase…]… looking forward to it, specially because I can travel again and almost can walk without crutches. So, I can do my talks standing with my hands on the keyboard without falling.

Test Tool Checklists - TMAP NEXT DOWNLOADS

info.nospam@nospam.ClemensReijnen.nl (ClemensReijnen) — Mon, 01 Feb 2010 00:59:26 -0800

Some interesting downloads from my test expert colleagues…
Beside you can find these documents on our www.TMap.NET site all these templates and checklists also have a place in the TMap Process Template for VS2010 [which can be found at TMap.Codeplex.com].

	Overview "Tools per TMap activity" TMap has a lot of test specific activities in this Excel sheet you can see a link between these activities and the tool categories. Interesting to map Visual Studio with Test Professional 2010 to it, it almost fulfills every category.
	Checklist "Intake Test Tools" After your test tool selection this is a nice checklist when setting up your test environments.
	Checklist "Test Environment" Nice checklist when setting up your Lab environment with Lab Manager.
	Overzicht "Test Tool selection criteria" [Test Tool Selection Criteria]. Combined with the “tools per TMap activity” will give you a nice capability overview of your test tools…

More in the process template and on the TMap site.

VS2010 Architecture Explorer Analyzers

info.nospam@nospam.ClemensReijnen.nl (ClemensReijnen) — Mon, 18 Jan 2010 02:07:46 -0800

DGML, the new VS2010 visualization technology has capabilities to render graphs. Graphs like dependencies between classes, inheritance graphs, custom graph, you actually can visualize any relation you want. Cameron Skinner has posts about DGML and Chris Lovett has some great video’s.

[class dependencies uml2doc.codeplex.com]

Now the interesting thing is that you can analyze these graphs. In the image below you see the analyzers; Circular References – Hub – Unreferenced.
The purple classes are unreferenced which probably means dead code or entry point of the application. The kind of blue-green nodes are hub, classes which are important and heavy used, and no strongly connected classes in this solution.

Make your own analyzer.

You also can make your own analyzer. For example code coverage or naming conventions or … whatever you can imaging. In the example below I created an analyzer which marks the nodes green with the string ‘Clemens’… (code you know is great:)

Ok, maybe not that interesting analyzer, more interesting is the creation… in the /PrivateAssemblies/Providers folder there are already several analyzers available, actually the ones mentioned above.

A small analyze of this assembly tells us that all the analyzers are using the IProvider interface and the ProviderAttribute [see below]. After some more exploration you will find that the prgroesion.common assembly has a method ‘ProviderDiscovery’ which looks for classes in the provider directory.

so, making a assembly with the code below is a good start:

[Provider(Name = "ClemensAnalyzer")]
public class TestAnalyzer : IProvider

In the void Initialize(IServiceProvider serviceProvider); you have to initialize your provider, register the actions and action handler [action.ActionHandlers.Add(new ActionHandler(this.OnAnalyzeTests));]… which calls your analysis…

foreach (Node node in this._graph.VisibleNodes)
    {
       if (node.Label.Contains("Clemens"))
           {
                  node[HasClemens] = true;
                  outputObjects.Add(node);
                  this.ThrowIfCancelled();
           }
    }

the node[HasClemens] = true; is some additional meta data you add to your diagram: private static GraphProperty HasClemens = GraphProperty.Register("HasClemens", typeof(bool), new GraphMetadata("Clemens","This one contains Clemens",null,GraphMetadataFlags.Default), typeof(TestAnalyzer));

All this and a bit more [didn’t finished the analysis completely, there is a lot more possible] result in your own analyzer…

Now, let’s start making a useful one :-)

Visual Studio 2010 Team Foundation Server Requirements Management Guidance

info.nospam@nospam.ClemensReijnen.nl (ClemensReijnen) — Fri, 15 Jan 2010 23:01:18 -0800

Another delivery from the VS ALM Rangers is public available… the Requirements Management Guidance.

Very useful guidance, with a small contribution from me with the Enrich VSTA 2010 Use case diagram with SketchFlow Screens post. [see the Requirements Elicitation part].

Visual Studio 2010 Ranger News

info.nospam@nospam.ClemensReijnen.nl (ClemensReijnen) — Wed, 13 Jan 2010 20:43:23 -0800

> Rangers - Visual Studio Team Foundation Server 2010 Upgrade Guidance ships to Codeplex

> Rangers – Visual Studio 2010 Quick Reference Guidance ships to Codeplex

more will follow..!
http://blogs.msdn.com/willy-peter_schaub/archive/2009/11/16/rangers-visual-studio-2010-architect-edition-guidance-kickoff.aspx

Visual Studio 2010 and .NET Framework 4 Training Kit updated

Wed, 13 Jan 2010 04:19:57 -0800

New on Microsoft downloads this week is the Visual Studio 2010 and .NET Framework 4 training kit.

It contains 151 MB of techie goodness such as demos, labs, presentations and videos.

If you want, you can even turn it into a 3-day workshop as the included agenda suggests:

Day 1

Lap Around Visual Studio 2010

PPT: What's New In Visual Studio 2010

Lap Around .NET Framework 4

PPT: Whats New In .NET Framework 4

Managed Languages Overview (C#/VB)

PPT: What's New In C# 4 and Visual Basic 10

Entity Framework 4

PPT: Whats New In Entity Framework 4

ADO.NET Data Services 1.5

PPT: Whats New In ADONET Data Services 1.5

Velocity

PPT: Introduction to Project "Velocity"

Silverlight 3

PPT: Not included in the kit

Day 2

ASP.NET 4

PPT: Whats New In ASP.NET Web Forms 4

AJAX 4

PPT: Whats New In ASP.NET AJAX 4

Web Deployment with Visual Studio 2010

PPT: Web Deployment with Visual Studio 2010

Windows Presentation Foundation 4

PPT: What's New in Windows Presentation Foundation 4

.NET RIA Services

PPT: Introduction to .NET RIA Services

Managed Extensibility Framework

PPT: Introduction to the Managed Extensibility Framework

Day 3

WF/WCF 4

PPT: Workflow 4: A First Look

Parallel Computing with Visual Studio 2010

PPT: Parallel Computing with Visual Studio 2010

Parallel Computing for Managed Developers

PPT: Parallel Computing for Managed Developers

Visual Studio Team System 2010

These are short modules that can be picked based on the interest of the audience.

PPT: Introduction: Visual Studio Team System 2010

PPT: No More Planning Black Box

PPT: No More Late Surprises

PPT: No More Stakeholder Surprises

PPT: No More Parallel Development Pain

PPT: No More Bewildering Admin

PPT: No More No Repro

Visual Studio Team System 2010

PPT: No More Build Breaks

PPT: No More Butterfly Effect

PPT: No More UI Regressions

PPT: No More Missed Requirements or Changes

PPT: No More Waiting for Build Setup

PPT: No More Performance Regressions

Visual Studio 2010 Quick Reference Guidance

Wed, 13 Jan 2010 03:59:25 -0800

VSTS Rangers are a team of very active MVPs and other experts, such as Inner Circle partners, that are dedicated to improve the ease of use and adoption of Visual Studio Team System. Willy-Peter frequently blogs about the projects these guys are working and their progress.

Recently they released Quick Reference Guidance for Visual Studio 2010 on codeplex, which I think is very valuable. Go check it out:

http://vs2010quickref.codeplex.com/

“The Visual Studio 2010 Quick Reference Guidance consists of compact cheat sheets for Team Foundation Server (TFS) 2010 and Visual Studio (VS) 2010, addressing the core problem of teams in the field who are unaware of Visual Studio and Team Foundation Server capabilities or have little time to invest in detailed education.
The artifacts include an overview document and poster that allows you to quickly focus on individual areas like testing, by providing crisp and compact guidance sheets and quick reference posters. You can take these to your 5-min coffee break discussions or use them as a stepping stone to the more detailed and in-depth guidance you will find on MSDN.
The download package consist of three ZIP files containing a number of quick reference posters and quick reference sheets in XML Paper Specification (XPS) format:

An overview of the guidance and focus areas, contained in one index table and overview quick reference poster. >
A collection of basic guidance sheets, focusing on the “what” are the key features and “why” to consider them.
A set of documents and quick reference posters, supporting the basic guidance sheets.”

History of Test Automation

Rob Kuijt — Sun, 10 Jan 2010 12:44:14 -0800

Test Automation is the use of software to control the execution of tests, the comparison of actual outcomes to predicted outcomes, the setting up of test preconditions, test design, and other test control and test reporting functions. Commonly, test automation involves automating a manual process already in place that uses a formalized testing process. (Wikipedia)

Working with Model-Based Testing I get many questions on Test Automation. To be honest, around a year ago, I could not answer them at all. After a year playing with test industrialization my knowledge is better. But still, especially the timeline (when was a specific type of test tooling introduced) was a gap in my mind. An overview: History of Test Automation would be very practical.

On internet, I couldnt find the complete Test Automation timeline I needed, so I started creating one

Inspired by the powerpoint slides: Generations of Test Automation by dr Mark Utting, I made a slide show (kind of e-learning component) which gives an overview how the (automating of the) test process did evolve since the 1940's.
I created some nice graphics, added some definitions and expanded the presentation with more detailed slides and background information from TMap®, Wikipedia, James Bach, William E. Lewis, Gunasekaran Veerapillai and Marvin Niven (thanks guys!) and uploaded the slide show/e-learning component for future use

Interested? See History of Test Automation

[Dutch] Engineering World 2010

info.nospam@nospam.ClemensReijnen.nl (ClemensReijnen) — Thu, 07 Jan 2010 11:05:41 -0800

Engineering World 2010

Wil jij ook in één dag op de hoogte zijn van de ontwikkelingen binnen jouw engineering vakgebied? Aarzel niet en meld je dan nu aan voor Engineering World 2010.

De volgende stap in volwassenheid en productiviteit

Zaterdag, 6 februari 2010, Achmea Conferentie Center in Zeist

Voor de derde keer op rij organiseert Sogeti in samenwerking met het Software Development Network dit unieke evenement.

Programma

Het engineering vakgebied is volop in beweging en gaat een nieuwe volwassenheidsfase in, waarbij de productiviteit zich enorm snel ontwikkeld.

We zijn er trots op dat tijdens Engineering World 2010

Key Note spreker Taco Oosterkamp een lezing geeft over time- en stressmanagement nieuwe stijl. In die lezing vertelt hij over principes voor effectief én ontspannen werken.

Hij laat daarbij een serie tips en trucs zien – alles bij elkaar een interessant, praktisch verhaal. Taco is dé productiviteitsgoeroe van Nederland en mede-initiator van www.lifehacking.nl.

Naast Taco Oosterkamp, wordt de dag gevuld met presentaties en workshops. De inhoud van de verschillende sessies kun je nalezen op www.engineeringworld.nl.

We gaan je op deze zaterdag ook uitdagen! Want…

Ben jij de beste programmeur van het event?

Tijdens Engineeringworld 2010 schrijven we een programmeerwedstrijd uit. Je krijgt een programmeeropdracht die ter plekke moet worden uitgevoerd, alleen of in een team. Je krijgt voldoende tijd om aan je oplossing te werken zodat er ook nog ruimte is om presentaties bij te wonen. Neem je laptop mee met jouw favoriete programmeeromgeving. De winnaar krijgt een mooie prijs.

Meer informatie over de wedstrijd kun je binnenkort vinden op www.engineeringworld.nl.

Kortom, een evenement dat jij als engineer niet mag missen.

Je kunt je kosteloos inschrijven via www.engineeringworld.nl.

Graag tot ziens op 6 februari 2010 in Zeist.

Christmas presents from Microsoft Downloads

Mon, 28 Dec 2009 07:00:06 -0800

This is one of my start pages: http://www.microsoft.com/downloads/en/resultsForCategory.aspx?nr=50&sortOrder=Descending&sortCriteria=Date&period=30&stype=ss_nd&sterm=All+Categories

It is a great start of the day as it prompts you all new downloads at MS Downloads. As you can see in the listing below, the Visual Studio team have updated the VSTS 2008 VMs. On top of that you can also get the 2010 Beta 2 version in a ready to go VM. Pretty cool, right? Brian Keller posted about the latter and he also provides an easy way to download the GBs and how to get the hands-on-labs. So if you have some time to burn this week, check them out.

Microsoft® Visual Studio® 2010 and Team Foundation Server® 2010 Beta 2 for Windows Virtual PC Image

Microsoft Visual Studio 2010 Ultimate simplifies solution development, lowering risk and increasing return. The virtual machine image in this download contains both Microsoft Visual Studio 2010 Beta2 and Team Foundation Server 2010 Beta2 and is designed to be run under Windows Virtual PC.

12/24/2009
Microsoft Visual Studio 2010 Beta 2 and Team Foundation Server® 2010 Beta 2 Hyper-V Image

12/24/2009
Visual Studio 2010 Beta 2 Virtual PC SP1 Image

12/24/2009
Visual Studio® Team System 2008 VSTS Hyper-V Image (Trial)

Microsoft Visual Studio 2008 is the next-generation development tool for Windows Vista, the 2007 Office System, and the Web.

12/23/2009
Visual Studio® Team System 2008 VSTS VPC Image (Trial)

Microsoft Visual Studio 2008 is the next-generation development tool for Windows Vista, the 2007 Office System, and the Web.

12/23/2009
Visual Studio® Team System 2008 TFS SP1 VPC Image (Trial)

Visual Studio Team System 2008 Team Foundation Server SP1 is an integrated collaboration server for Visual Studio Team System.

12/23/2009
Visual Studio® Team System 2008 TFS Hyper-V Image (Trial)

Visual Studio Team System 2008 Team Foundation Server is an integrated collaboration server for Visual Studio Team System.

12/23/2009

Traceability in VS2010

info.nospam@nospam.ClemensReijnen.nl (clemensreijnen) — Wed, 23 Dec 2009 00:27:42 -0800

Always an interesting question, how does traceability work in VS2010?
To often asked without any context, or only asked from a requirements perspective. Still way too open to answer in a tweet. So, a post to canalize those questions a little bit more…

[see the image below for the numbers]
you can take two directions when talking about traceability. The first is focused on “work”, the work items repository part of TFS [on the left side of the green dotted line]. with work related traceability we can answer questions like “did we completed all tasks for that requirement?” [for more see the red list]. Information which is very important for every roll in the Application Lifecycle. A tester want to know if he can start testing, so he want to see if the developer is ready. A project manager wants to plan the work. Developers want to know if designers are ready to start with a stabile set of needs… and many more. All work related information, and information which can be tracked/ traced by using work item and its repository.

VS2010 main capability for work related traceability are the TFS work item repository [see image below from MSDN] and linking of work items, setting up a hierarchy.

We can breakdown requirements, or user stories, in tasks. tasks that needs to be executed to get the requirement done. These tasks can have a parent-child relation [and other see Working with Link Types on MSDN]. Giving us the information we need in any kind of way, for example reports.

So far the work related traceability. The other kind of traceability is based on artifacts, things we make during the application lifecycle, I will call them ALM artifacts. ALM artifacts are used to create the solution/ application. For example the source, XAML and configuration files which make the solution. But, also the diagrams which we created to make a correct, consistent and good communicated application architecture, we use them to drill down from the needs to code. And also test cases belong to the things we make during the application lifecycle [I can imaging when you get confused now, test cases are within VS2010 work item types, but they definitely belong to the artifacts section].

Use case – user story what is the difference… I often use both [see this piece of MSDN documentation for modeling requirements]. User stories are work item types and use cases are ALM artifacts. So, they are a great bridge between the ‘work-world’ and ‘artifact-world’. The good thing is the capability of VS2010 to link diagrams, and other model elements to work items. [How to: Link Work Items to Model Elements], this give us the capability to create a trace.

From the description and diagrams of the requirements, the often called problem domain, we have to make a big jump into the solution domain. Diagrams are created like the component diagram and layer diagrams visualizing the high level pieces of the solution with the dependency and interfaces between these components and layers. [used this image in this post; the modeling world].

It is also a big gap for traceability, to get this a little bit better a solution can be the replaying of scenarios written down in the user stories and drawn in activities as described in this post; VS2010 Modeling; Create Lifeline from Component.

A trace back from component/layer to requirement can be a link from model element to the user story work items in where he is used. Never did this, it’s a manual process and probably people will forget the links, maybe with some kind of notification this would be valuable…

An interesting VS2010 capability is the connection between the layer diagram and the sources. This makes a trace possible between the high level design and the sources. See image below.

Because test cases are work item types in VS2010 they can be connected to any other ALM artifact, giving us the possibility to connect for example test cases to use case diagrams. Easier to accomplish and to maintain is the connection with test tasks and corresponding user story. But this doesn’t answers questions like; “which code is touched by this test”. VS2010 answers this question with Test Impact, see “Determining Which Builds Have Bug Fixes, New Features, or Requirements”, “Recommending Tests to Run That are Affected by Code Changes” and “Developing Tests from a Model”.

Another interesting traceability scenario can be build with test case generation, see this ‘old’ Model Based Testing beta 1 video. [some more info on MBT can be read on Rob’s blog]

Next, all have a work related task. So, not only traceability within the two sections is possible also traceability between the two sections is possible. answering questions like; “which task created this line of code?”… creating this link / trace is a manual task but it can be controlled by a check-in policy.

So, when someone asks you the question; “what about traceability in VS2010?” you now can canalize this and guide him/ her to the real traceability question they want to have answered [and tell the solution]….

< probably more to come on this interesting topic, also because the extensibility model of the diagrams is powerful enough to create your own required traceability between artifacts with notifications and work item linking… very very interesting >

Test Case Design: Manually or Automated?

Rob Kuijt — Sat, 19 Dec 2009 22:42:37 -0800

There are several tools that can help with the creation of test cases. So why don't we succeed in automating the Test Cases Design Process? In this short article I will explain that, if test collaborates with design, we can make huge progress on this topic!

4 Examples of Test Case Design
Lets imagine a business process that is documented by the design team on one page. Test will create the test cases. In the first example the description is done in plain text. In that case it is not possible to automate the test, and also it is not possible to use a formal test specification technique:

Example 1: Test Design from plain text: many interpretations and assumptions...

Creating test cases from plain text may look easy, but when you ask 5 test engineers to create the test cases you get 5 different sets without any insight in the quality of the coverage.
Choosing the process flow diagram technique for describing the business process, will result in less interpretations and assumptions, therefore in much better test cases:

Example 2: Manual Test Design: Process Cycle Test (TMap®)

The advantage of formal Test Case Design techniques like Process Cycle Test (PCT) is that it can be automated! How? The first step of deriving test cases with PCT, is to identify the paths and path combinations within the process flow diagram. Step 2: Instead of manually combining those path combinations to test cases, the path combinations (joined with a short description) can be inserted in a Test Design Tool. Step 3: The test cases are generated. Comparing with manual test case design: much faster; less knowledge is needed, but you need a tool* (license):

Example 3: Using a Test Design Tool: much Faster!

Most of the time, designers make these process flow diagrams in modeling tools (like MsVisio, Protos, Aris, BiZZdesigner,..). A common feature of the modeling tools is exporting the models in XML-format. Model Based Testing tools* do read XML! So, lets skip all manual steps and generate test cases directly from the process flow diagram:

Example 4: Model Based Test Case Design

Model Based Test Tools* can generate test cases within minutes. Of course, before using the test cases you must do a sanity check to confirm the tool understood the model correctly but nevertheless the time cant be beaten manually.

Collaborate!
Test Case Design can be automated (Im already working with these tooling on a daily basis).
But, besides getting the right tool(s), there is an important condition: the Test Base must have a minimum level of quality.
For instance: instead of describing business processes in plain text, they should be specified with the help of activity diagrams or process flow diagrams (and that is not (yet) common knowledge within the design processes). To get an automated Test Design process, lets join the forces: Together, Design and Test can make projects much faster and cheaper!

*) Example of a Test Design/Model Based Testing Tool I personally often use: STaaS/COVER (Sogeti Netherlands)

Article in MSDN magazine got published

Mon, 14 Dec 2009 15:58:36 -0800

Well it has been an interesting journey, but today I found that the article I wrote with Brian A. Randell early this year on creating a custom team explorer extension got published. I haven’t received the glossy copy yet, but my search on MSDN resulted in the December issue that has it even as a featured article on the cover :-)

http://msdn.microsoft.com/en-us/magazine/ee819132.aspx

It is just great to see that it finally made it and I want to give a big thank you to Brian, Dennis and Buck for their help on getting this published.

More return on development with Application Lifecycle Management

Tue, 24 Nov 2009 06:58:09 -0800

This is a translated version of an article that I wrote for Software Release Magazine.

Application Lifecycle Management

In the past ten years, the costs of IT projects dropped significantly. In addition, the number of projects that turned out to be successful, rose. Nevertheless, only forty percent of all IT projects succeeds. This means that it takes less time today for a project to fail. Application Lifecycle Management (ALM) may help improve the return on projects. An efficient deployment of ALM requires the right scope and focus.

Today, many organizations regard Application Lifecycle Management (ALM) as one of the answers to their bad performing IT departments. With ALM, they try to get more grip on software development by integrating, coordinating and controlling the various phases of development. ALM guides an organization from software development until software implementation and management. Very often, an organization will limit its focus to optimizing the developer’s work processes and the communication between developers and project managers. An ALM tool is rolled out and its features are used to manage the progress of the project as well as the quality of the code. Deploying an ALM tool in this way is a step in the right direction but in practice it is not a guarantee for success. Without the right focus, software development will remain a stand alone activity without any relation to other parts of the organization, including business and operations. Additionally, research shows that companies spend on average 30 percent of their available IT budget on newly built applications. This means that they neglect an area of 70 percent, where optimization is also possible.

More return by shift in focus

With the right scope and focus ALM has much to offer. Figure 1 shows a schematic view of the lifecycle of an application that is to be developed. In this view de x-axis represents the time and the y-axis the value/cost of the application. In this figure, the extended curve shows the lifecycle of the application from development until end-of-life. The figure provides insight in the different phases of an application’s lifecycle. It also enables for determining the impact of ALM.

Figure 1. The lifecycle of an application

Reduce development costs

The lifecycle of an application starts in the first phase of development. As of the start of the project, costs are made for design, programming and testing. At this time, the application offers no value. All development costs are therefore to be regarded as costs. Often, organizations focus on these costs when deploying ALM and optimizing the software development process. Figure 1 shows however, that the development phase only accounts for a small part for the full lifecycle of the application.

Time to market

The figure also shows that the application will only add value to the organization when it has gone live. This means that the ALM activities need to be focused on getting the application (or a part of it) live as soon as possible. One of the ways to do this is using agile development methods, including iterative delivery. Shortening the time to market not only results in faster added value, it can also provide competitive advantage. In general, organizations that are first in addressing new needs or market changes profit the most from these developments. Organizations that are trend followers profit less; or even worse, they have to invest in order to stay in the market.

Added Value

It is clear that an application will add value when it has gone live. Many organizations do no recognize this added value. ALM activities should focus on getting as much added value as possible. As the application is developed for the end-users , it is key to involve this group as much as possible in the development process. User involvement, support from the (executive) management, defining clear business goals and optimizing requirements are all equally important.

One of the ways to realize this is to optimize the communication between the user organization and IT and to create a common involvement for all stakeholders. In this way, stakeholders are better geared to state their demands. They are also better able to determine the consequences of their choices and to change priorities and requirements during the project, together with the project team. Here, it is also cost-effective to use short iterations, as changes in scope, priorities and requirements can easily be made. In this way, an organization can address new insights during the project, which may increase the added value of the application further.

Operational costs

When developing the application it is advisable to acknowledge in an early stage the need for application management. By creating consensus on the requirements for the management department, operational management costs of the application can be reduced significantly. The focus on management is paramount in an ALM approach.

Extending the lifecycle

By adding value and reducing costs, a developed application will provide return in the long run. By focusing on the value of an application and by constantly monitoring this aspect, an organization is better capable of determining the moment when value is replaced by costs. This early insight helps in deciding what to do with the application: adjust or phase out?

Phase out

When an organization decides to abandon an application, the knowledge of the application will lead to less abandoning costs. This is definitely the case when an organization combines this knowledge with the optimizations, provided by ALM in the earlier development phase of the application. An example is the right documentation on the application interface to other systems.

Figure 2. The new lifecycle of an application

The new lifecycle

Figure 2 shows the new lifecycle of the application. This is the result of broadening the ALM focus as described earlier. The green field in the figure depicts the extra return of the application. This is possible by speeding up the go-live process, a longer life of the application and more added value for the user. The red areas in the figure represent the decreased development costs and the costs for abandonment.

Priorities of an organization

Figure 2 shows that the return on ALM increases when an organization not only focuses on the development phase, but also on the other phases of an application’s lifecycle. This optimization obviously pays off, but the question is how to relate this to the goals of today’s organizations. Many organizations focus on cost reduction, compliancy and risk management. How can ALM be related to these three priorities?

Cost reduction

A too strong focus on cost reduction may well lead to an imbalance in this area, resulting in a paralyzed organization in terms of productivity. By continuously executing cost reducing measures, tools and communication channels are lost. In the end, this can affect the productivity of employees negatively. By combining cost savings and productivity improvements this issue can be addressed.

A combination of ALM activities with a so-called high-performance workplace can be the answer. The high performance workplace is a physical or virtual environment which is especially designed for knowledge and information workers. It supports them optimally in executing non-routine duties. In these duties, exploring, learning, innovating, collaborating and managing are key.

The current generation of ALM tools already pays attention to optimizing communication and collaboration between stakeholders in an IT project. This shows that the awareness on effective collaboration is growing. It also requires the focus to be placed on the process and the human aspect of collaboration. Important success factors are creating joint goals and making sure there is a shared vision of the truth.

Compliancy

The current compliancy requirements demand a high level of control. In recent years, this control is expressed in continuous process optimization. The need for a process approach led to reduction of flexibility within an organization. It is becoming increasingly difficult to address market changes and needs without losing control. The focus on processes, tools and management also led to a situation in which up to twenty percent of project costs can be allocated to the developed software. The rest of the costs are related to project support and meeting internal and external requirements. The new generation ALM tools and corresponding methods, enable an organization to meet these strict compliancy requirements without affecting flexibility. These tools provide the necessary mechanisms and means of control to link requirements, quality metrics and the solution. This makes it much easier to prove that the solution meets all requirements. The full support of agile methods within the ALM tools ensures the required flexibility.

Risk management

Experience from the past shows that risk is inherent to projects. However, the higher the risk, the higher the return, as optimists say. It is not necessary for organizations to exclude all risks. They need to assess risks continuously on the return they can provide. The collaboration in a project, the commitment from stakeholders and the combination of business and ICT knowledge enable the right assessment of risks. This may lead to a situation in which a risk that is regarded as unacceptable by individual members, is controllable or even desirable.

Conclusion

ALM is gaining in popularity. Many organizations take their first steps in this area and start to purchase ALM tools. Seemingly without thinking, they focus on the development phase. This is an excellent first step but still they should not stop here. By broadening their focus and incorporating the full lifecycle of an application in their approach, they are able to increase their return on ALM significantly. The broader approach offers more insight in the added value of the application. By combining ALM and a high performance workplace, and by putting the human aspect first, it is possible tot create an environment in which collaboration is optimized. The result is a software development process with predictable results and sufficient flexibility to contribute to the three main priorities of an organization: cost reduction, compliancy and risk management.

Creating Custom DGML Diagrams using the Progression API

Fri, 13 Nov 2009 12:24:37 -0800

Thursday night I presented a Session for the VSUG in Belgium, with the title “Modeling that works with code”. In this session I demonstrated how we can add more value into models and diagrams and how that can help us to keep our model in sync with the actual codebase we work on. (You can download the presentation here)

During this session I also addressed the concept of creating your own custom DGML diagram, using the progression API, that can be found in the visual studio directories.

In this post I want to describe how you can create a Custom DGML diagram. I will show you how you can use the standard Coverage files you get from the Microsoft Test tools and use that data to create a diagram that shows which classes have a coverage percentage below a defined quality bar.

When you want to create a DGML diagram, you can do that by using the Progression API. You can find the classes you need in the following assemblies :

Microsoft.VisualStudio.Progression.Common
Microsoft.VisualStudio.Progression.GraphModel

Just use the add reference dialog and browse to the following location:
<installdrive>:\Program Files\visual Studio 10\Common7\Ide\PrivateAssemblies

note:on a 64 bit machine this is program Files (x86) instead of program files

I want to create a new diagram, so to start, I need an instance of a Graph object. This is nothing more than just creating an instance of the Graph class. Now I want to define some custom metadata to my Nodes, that contain the code coverage information. For that purpose, I register a custom metadata property of the type double with the name “CodeCoverage” and I register it to be available on the Nodes in my diagram.

So the only thing I need to do is load the Code Coverage XML file, use an XLinq query to get only the Class nodes and then create a loop that generates the nodes I want to add to the diagram.

The code for this is like follows:

Graph DgmlGraph = Graph.Load(filetoAnnotate);
GraphProperty codeCoverageProperty =
GraphProperty.Register("CodeCoverage", typeof(double),
GraphMetadata.Default, typeof(Node));
var codeCoverageXmlFile = XElement.Load(coverageFileName);
foreach (var classCoverageNode in codeCoverageXmlFile.Descendants("Class"))
{ var classname = classCoverageNode.Element("ClassName").Value; int linesCovered = int.Parse(classCoverageNode.Element("LinesCovered").Value); int linesNotCovered = int.Parse(classCoverageNode.Element("LinesNotCovered").Value); int linesPartiallyCovered = int.Parse(classCoverageNode.Element("LinesPartiallyCovered").Value); int totalLines = linesCovered + linesNotCovered + linesPartiallyCovered; double coveragePercentage = (linesCovered * 100 / totalLines); Node coverageNode = new Node(className); coverageNode.SetValue<double>(codeCoverageProperty, coveragePercentage); DgmlGraph.Nodes.Add(coverageNode);
}

So now I have a Graph, that contains nodes and each node has the percentage code coverage set.

Finally, I need to define specific styles so the diagram shows which classes are below a certain code coverage percentage and which are above. For that you can add so called Conditional Styles to the diagram. This is also very straightforward to do.

You just create a new ConditionalStyle object instance and give it the graph as argument. Then you define to what type of element it needs to be applied to in the DGML diagram. So for this purpose we define this style to be applied to the “Node “ type. Next you give it a Label and last but not least a Condition. The expressions that evaluate if it needs to apply the condition can use all information in the model. The expression syntax can be found here (http://msdn.microsoft.com/en-us/library/dd409453(VS.100).aspx#Highlight)

So for this diagram, I want to apply the style to all nodes with Code Coverage > 80. Therefore I need to apply the following expression: “CodeCoverage > 80”

var ConditionalStyle = new ConditionalStyle(DgmlGraph);
ConditionalStyle.TargetType = typeof(Node);
ConditionalStyle.GroupLabel = "Coverage > 80%";
var Condition = new Condition(ConditionalStyle);
Condition.Expression = "CodeCoverage > 80";
ConditionalStyle.Conditions.Add(Condition);
DgmlGraph.Styles.Add(ConditionalStyle);

Now the last thing I need to do is define what property of a node visualization I want to change on this ConditionalStyle. I choose to set an Icon to be a green checkmark and the background to green

var CodeCoverageSetterBackGround = new Setter(ConditionalStyle, "BackGround");
CodeCoverageSetterBackGround.Value = "#FF00FF00";
ConditionalStyle.Setters.Add(CodeCoverageSetterBackGround);
var CodeCoverageSetterIcon = new Setter(ConditionalStyle, "Icon");
CodeCoverageSetterIcon.Value = "pack://application:,,,/Microsoft.VisualStudio.Progression.GraphControl;component/Icons/kpi_green_sym2_large.png";
ConditionalStyle.Setters.Add(CodeCoverageSetterIcon);

I also did the same for coverage below 80% and set that style to be Red and use the Icon type “Node.Error”.

So now when I run my program with a code coverage file, I will get the following results:

In a next post, I will show you how you can also leverage the DGML diagrams generated with the architecture explorer and then applying this same code coverage information to that diagram, so you can decide which classed need additional effort in getting better coverage.

Cheers,
Marcel

Codecamp is here again

Sun, 01 Nov 2009 11:24:47 -0800

How time flies! Last year I presented Modelling in VSTS Rosario with demos in CTP12. Since then Microsoft have moved on: The product is now called Visual Studio Team System 2010 and we are at Beta2 already.

For the past few weeks I have used my rare spare time to get to know the Beta2 release. I already liked Beta1 a lot and this is even better. Sure there is room for improvement, which you can express here, but I can advise both VS as well as TFS to anyone for production use.

My session is called “New in VSTS2010” and there is much more content such as Surface development, ASP.NET security and ADO.NET Entity Framework. If you want to get the guided tour around VSTS2010 make sure to attend Codecamp in Rotterdam on November 21st.

Hogeschool Rotterdam
Locatie Academieplein
G.J. de Jonghweg 4 - 6
3015 GG Rotterdam

Eclipse and VSTS

Thu, 29 Oct 2009 01:40:46 -0700

For years Teamprise have provided integration between Eclipse and Team Foundation Server. Teamprise also works on mainframes.

The collaboration continues: At the European Eclipse conference Microsoft announced improved support for Eclipse and the Windows world. In short Eclipse will get better interop support for Windows 7, Windows Azure, Silverlight and others like ADO.NET Data Services.

“Microsoft teams with Tasktop Technologies and Soyatec on open source projects designed to foster interoperability and make Eclipse a first-class tool on the Microsoft platform.”

Source: Partnering to foster Eclipse and Microsoft platform interoperability

Press release: http://www.microsoft.com/presspass/press/2009/oct09/10-28eclipsepr.mspx

“This One’s a Game Changer”

Wed, 21 Oct 2009 04:09:41 -0700

By now you must have heard about the new Visual Studio 2010 Beta 2 release. There are plenty of blogs and videos that demonstrate the great functionality of both Visual Studio and Team Foundation Server. As of today it is available for everyone to download.

I was most curious about the TFS Basic configuration which gives you TFS version control and build on your local machine. The installation went pretty smooth: I used my sysprepped copy of Windows Server 2008 R2 and installed TFS Basic without additions. So the good thing is that you do not have to think about installing and configuring IIS or SQL Server (Express); the TFS Basic installation takes care of that. The installation is a breeze and only takes minutes and a reboot.

One error message I encountered when clicking the links in the installation summary was:

Server Error in '/tfs/web' Application.

Configuration Error

Description: An error occurred during the processing of a configuration file required to service this request. Please review the specific error details below and modify your configuration file appropriately.
Parser Error Message: Could not load file or assembly 'System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35' or one of its dependencies. The system cannot find the file specified. (C:\Program Files\Microsoft Team Foundation Server 2010\Application Tier\Web Access\Web\web.config line 123)
Source Error:

Line 121:

Line 122:    <httpModules>

Line 123:      <add name="ScriptModule"
type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral,
PublicKeyToken=31BF3856AD364E35"/>

Line 124:      <add name="TSWAAuthentication" type="Microsoft.TeamFoundation.WebAccess.TSWAAuthenticationModule"/>

Line 125:    </httpModules>

Source File: C:\Program Files\Microsoft Team Foundation Server 2010\Application Tier\Web Access\Web\web.config Line: 123

Version Information: Microsoft .NET Framework Version:2.0.50727.4927; ASP.NET Version:2.0.50727.4927

It turns out that the although the installation runs smooth, you do have to install .NET Framework 3.5 additionally.

ALM and MBT

Rob Kuijt — Mon, 19 Oct 2009 10:08:29 -0700

Both ALM (Application Lifecycle Management) and MBT (Model Based Testing) are hot. I'm pretty busy running from customer to customer starting/supporting MBT proof of concepts and assignments. With some explanation all my contacts are convinced that the combination of ALM and MBT is THE roadmap for the future.

The advantages of ALM can already be implemented by choosing for the new generation of tools of Microsoft (VSTS2010) and IBM (JAZZ etc.) are presenting to strongly support the collaboration of the different roles in and around the ICT. Model Based Testing has not yet that same level of maturity. Most participants in the Model Based Testing world are very ambitious: They try to Generate Test Cases for direct automatic execution, based on test specific models.

I think this is a bridge to far for most companies using for instance mainly ERP-software. In the ERP-scope most of the testing is still done manually, and jumping to this ultimate form of Model Based Testing (Generate Test Cases for direct automatic execution) will be very tricky and/or costly. That's why we (Sogeti) are introducing also a basic form of Model Based Testing (STaaS/COVER), using the same models as the developers do.

"MBT: ...a bridge to far..."

MBT: Generate Test Cases for direct automatic execution
Does this mean that Generating automated tests is a dead end? NO! It is a very good approach for testing high risk functionalities, which are to risky or to complex to test manually.
Making test specific models is a costly business and top designers/test engineers are needed to make it work. So be sure to pinpoint these heavy coverage and tooling only on the high risk areas. AND!! Do not try to make the test specific models in the Testing Silo! Look for collaboration with the design department to get these test specific models in the same configuration mnagement as the models the devlopers use to build the software. Preferably in an "ALM Center Configuration Management".

MBT-basic: Using the same models as the developers do
On the other hand, when the ambition of Model Based Testing is lowered to only generating the test cases, it is a complete different story. Especially the generation of the (more global) logical test cases can be done from the same (functional and/or requirement) models the developers use as a bases for creating the software. For instance process flows (activity diagrams), decision tables and pseudo code are a perfect basis for generating (logical) test cases.
Enrichment of these models (in collaboration with the design department) will bring us to the next step: Generating the physical test cases. In that case the Test Cases are no longer Configuration Items (costly maintenance!) but Test Cases become Work Items (if desired: directly generated from the same models the developers use to build the software).

Rob Kuijt

ALM: the end of the whispering game

Rob Kuijt — Sat, 17 Oct 2009 11:35:06 -0700

Who don't know the whispering game? For me it was one of my favourite games in my childhood. Whispering a tricky word in the ear of the child next to you and waiting for the twisted result at the end of the cycle....

Nowadays not only children do play this game. In the ICT world practically everyone is playing this game. Only they invented a new name for it: The Waterfall Model .

ALM (Application Lifecycle Management) makes an end to the twisted results of this widely implemented whispering game. Instead of working in Silos with their own project and configuration management, in ALM the requirement, workflow and configuration management is organized in the center of the process. So everybody is working on the same artifacts.

In ALM everbody is working on the same artifacts. No whispering risks at all.. ;-)

And from my archive..
Some famous twisted results of the whispering game:

Team Foundation Server basic

Thu, 15 Oct 2009 04:04:18 -0700

… and the end of Visual SourceSafe. Brian Harry blogged about this recently. His post explains the early days of SourceSafe and the idea of bringing easy version control to developers. In the 3rd generation of Visual Studio Team System this concept returns in the form of TFS Basic. It is Team Foundation Server without components such as Windows Sharepoint Services and SQL Reporting Services but it does provide functionality for version control, builds and simple work items. The installation is supposed to be just 2 Gb and takes 20 minutes to complete. You can even install it on your laptop if you are doing a disconnected development project solo where you want to use version control. And if your TFS Basic is to be used by the entire organization, you can simply “reconfigure” the instance and make it a full-blown Team Foundation Server.

All of this will be publicly available in TFS 2010 Beta2, which is just around the corner. And since Beta2 can go-live you can actually have this functionality in the real world very soon.

Check out Brian’s post for more information.

Indispensable documentation for Team Foundation Server 2008

Wed, 07 Oct 2009 10:49:44 -0700

If you are doing a Team Foundation Implementation or if you are running one, make sure you have these guides to make your life easier:

Installation guide – How to install TFS (in single or dual server setup), TFS build, TFS proxy and team explorer.

Administration guide - Administration concepts, procedures, and walkthroughs.

Operations guidance – When you realize that your ALM solution is business critical

TFS Guide - All about using your TFS and getting the most out of it

Most Valuable Professional in Team System

Mon, 05 Oct 2009 05:57:30 -0700

My first public appearance about Visual Studio Team System was with Dennis Mulder in June 2005. After a few more years of community exposure I received the MVP Team System reward, which I consider a great honor.

Back then the presentation was about source control in VSTS 2005. It is great to see the progress in VSTS 2008 that the discussion is now way beyond version control. And the story continues as the eminent VSTS 2010 Beta2 release will prove.

It is going to be a very promising year for VSTS. And it feels great to be a part of it.

PS: You can see my fellow MVPs here.

How to make VSTS DBPro work with the default database collation

Tue, 08 Sep 2009 15:59:38 -0700

today, I had a few hours of frustration, getting all databases in our project use the same collation.

What I wanted to achieve is that we would use the default collation of Latin1_General_CI_AS but not script that in our SQL scripts.

To start, for some reason the DBPro team decided not to use the names we are used to when we are working with collations. The list we all know (and love ahum ..) doe not show any relationship with the names used for the model collation. So first you need to figure out that English(United States) (1033) – CS, means Latin1_General_CS_AS .

As you might know the default collation for SQL 2008 default installation on an US English machine is Latin1_General_CI_AS, so that does not match by default. So I started to change this setting in all our database projects.

Then I wanted to set the scripts not to contain the collation in the scripts. To do this you can go to the deploy Tab and then click the Deployment Configuration file Edit button.

There you will get the following settings page with the dropdown where you can select the “deployment collation default” for your DBPro project.

Now we get to the fun part, because when you select the option “Do not script the collation” and you hit the deploy button I constantly got the message:

Warning TSD00258: The project and target databases have different collation settings. Deployment errors might occur.

Now that is interesting, I know my database is the default collation, I set the project to use English(United States) (1033), so why do I get this message?!?

So after some searching I found yet another location where you can set the collation and that is in the Catalog properties file on the first properties page. So I selected the option edit and got the following page:

Ok so I see, the collation is here CS and a SQL collation, so I changed that one also to Latin1_General_CI_AS.

So now I should be good right?

Well no, no luck. It just seems there is no way to get rid of the message telling me I have a different collation then the target database.

At this moment I am just stumped and do some additional inquiries why this is the case. The only way for now to make it work for me without warnings during build, is to set the “deployment collation default” back to “Use the collation of my project”.

It seems like a bug at this moment that I get this warning, but once I know for sure, i will post the update here.

Cheers,

Marcel

Silverlight error messages can be very cryptic or even inappropriate sometimes

Sun, 30 Aug 2009 13:26:00 -0700

The past few days I have been working on a simple proof of concept where we want to replace some of the dashboards we have that where build in Flex/Flash with Silverlight 3 controls.

The reason to switch has most to do with the fact we can maintain all our codebase with one single technology instead of having many different technologies. The proof of concept just needs to show we can get the same functionality and have better development and debugging experience then we have today.

So during some work I did, I needed to just call an existing web service that already has an crossdomain.xml file deployed on the website. Now it happens to be that this web service is part of our SharePoint portal. Once I created the proxy by just adding a web reference, I created the simple code to call the service and wait for the data to get back:

DisplayNames.DisplayNameSoapClient client = new BuildStats.DisplayNames.DisplayNameSoapClient();
client.GetViewDataCompleted+=new EventHandler<BuildStats.DisplayNames.GetViewDataCompletedEventArgs>(client_GetViewDataCompleted);
client.GetViewDataAsync("Budget (Earned Value)","Highlight");

As you can see very simple code. Now when I tried to get this code to work, I constantly got the same exception message time and time again, and I just could not understand what was going wrong.

The message I got was the following:(XXXX is the name of the server I just left out)

An error occurred while trying to make a request to URI 'http://xxxxxx/sites/endstp/dev/_vti_bin/DisplayName.asmx'. This could be due to attempting to access a service in a cross-domain way without a proper cross-domain policy in place, or a policy that is unsuitable for SOAP services. You may need to contact the owner of the service to publish a cross-domain policy file and to ensure it allows SOAP-related HTTP headers to be sent. This error may also be caused by using internal types in the web service proxy without using the InternalsVisibleToAttribute attribute. Please see the inner exception for more details.

It took me a very long time to get my head around what was happening here, since I used the same service as the flex control was using and we already had the crossdomain.xml deployed. I used fiddler to see if the crossdomain.xml file was retrieved and I could see it did get the file. So what was happening here? Well as after reading the message over and over again, I finally picked out the following part of the message: “or a policy that is unsuitable for SOAP services”

It happened to be that the way the flex control retrieved the data was different the I did with Silverlight. Therefore I needed to alter the crossdomain.xml file to also include a SOAP call. So the file I now used looks like follows:(See bold line that fixed the problem for me)

<?xml version="1.0"?>
<!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">
<cross-domain-policy> <allow-access-from domain="*" secure="false" />  <allow-http-request-headers-from domain="*" headers="SOAPAction"/>
</cross-domain-policy>

I know for production use we should not allow just anybody to do calls against our server, but since this is only used during development, this is fine for me now. Once the control is implemented it won’t be making cross domain calls anymore and I don’t need the file. (it is not a part of the deployment package)

So after fixing that I was able to get the data and plot the simple graphs based on the data I got. So all was good again.

But then one day later, I started some additional work on the same project and I got the exact same error message again!?!?!?

So how could that be? I wanted to start and see if the cross domain file might be incorrect or changed by someone else and then I found that the network was not even up and running! So I just simply forgot to plug in my network cable before I start to work and I got the exact same message!

Now I must say that encrypting an error message in such a way it will take a while to figure out what is wrong is one thing, but using the exact same message while there is not even a network available, just beats me. I know that with security in mind, you don’t always want to provide a lot of diagnostics what might be the issue, but just giving everybody a walk around the park with a generic message , just makes no sense to me. I really hope this is not a new trend in security practices.

Cheers,

Marcel

Deep dive event at the Microsoft north Carolina office

Wed, 12 Aug 2009 05:14:00 -0700

I Just got back from my holiday in Tuscany Italy, and am already on the road again. We had a great opportunity to visit the Microsoft Team System development team in Raleigh NC. The team over there is responsible for the Team Foundation Server, Team Web Access, Team Test, Setup & Ops and Team Build. The last one is of particular interest to us, since we rely on Team System and Team build in particular for our software factory Endeavour.

With the 2008 Product we integrate very tightly with and we want to have the same or even a better experience with the 2010 version coming down the pipe. As you all might now by now when you have looked at the B1 bits, is that there are significantly changes between 2008 en 2010. The biggest part is that team build is now using windows Workflow Foundation as the engine behind the build process instead of the MSBuild scripts we had in 2008. Now that adds some pro’s and con’s in terms of building our custom experience on top of that. E.g one thing we will going to miss is the option to only extend the process on specific predefined build targets and adding in our own steps to the process. With 2010 there is no notion of an extensible build script anymore and you will get an workflow instead that you need to copy and tweak according to your needs. On the other hand, it is really great that you can see a visual representation on what the process will look like in terms of phases and steps that compose the build.

One area where we extended the Visual Studio 2008 IDE is in the build configuration wizard. We extended the default dialog to work with our factory concept of Configuration Items (CI’s) instead of crafting up a workspace and selecting solution from there. See screenshot below to give you an idea on how we extended the build definition dialog.

For us a CI is defined as the unit of design, development, test and deployment. A CI can consist out of multiple modules and a module contains a solution or a MSBuild script that does some funky stuff needed for a certain folder in Version control to be build. We knew upfront that build would change drastically in 2010, but we took the decision to create the 2008 experience first and based on what we learn from that build the same or improved version in 2010.

As part of our elaboration work on 2010, we flew over to the NC office and had our first two days of meetings with the team build team. We had the opportunity to look at the current status of the product and work with the team to discuss how we can integrate our notion of a build with the out of box experience of Team Build.

I must say I am pretty pleased in terms of what I see coming in the B2 timeframe which I cannot discuss in public yet, but I can say we have seen significant improvements to the B1 that is out there at this moment.

Our goal is to have a good design crafted up by the end of the week in terms of how we are going to integrate with team build 2010 and even have some early proof of concepts that will work once we get B2. Once I am able to speak public about the B2 build, you can see a couple of post up here on how we use the 2010 engine and how you can create and manage your own build processes, just the way we are doing that as well.

Cheers,
Marcel

WSCF.blue Beta 1 is out!

Sat, 04 Jul 2009 13:31:37 -0700

I Just wanted to let you know that we have just released the Beta 1 of WSCF.blue. This great tool supports a Contract First Approach for developing webservices in Visual Studio 2008. Some time ago, I took the project lead (together with Christian) for this great tool. Unfortunately, I have been kind of busy lately so we didn’t made a lot of progress in the last couple of months. Just recently a couple of new members joined our team which resulted in this Beta 1 release. In this release we added MSI support which was one of the key requested features for this tool. For some more info on this release I suggest to have a look at this post from Benjamin (one of our new team mebers!). Our new team members inspired us a lot and brought some great ideas so expect some cool new features soon! Let us know what you think of this release on our forum.

Thanks Buddhike, Benjamin and Alex Meyer-Gleaves for getting this new release out!!

Model-Based Testing is not "Only Fun" anymore....

Rob Kuijt — Sat, 20 Jun 2009 05:09:24 -0700

For several years now, Model-Based Testing is mainly used within the (technical) development processes. In the Black Box testing community it was still "just a theory", and in my case: fun to play with. Today is different! I'm completely into Model-Based Testing nowadays. MBT turned, for Black Box testers, into serious business!

Wikipedia:
Model-Based Testing is software testing in which test cases are derived in whole or in part from a model that describes some (usually functional) aspects of the system under test (SUT).

For quite some years I'm working with a tool called COVER. Initially COVER was build to help lazy testers, like me, to avoid boring manual activitiesand it worked! Using this tool I could easily amaze my surrounding with stunning Speed and Quality. Especially deriving test cases from formal specifications like pseudo code or activity diagrams was fun to do; instead of "solving a boring puzzle" time, it was done in seconds (as a matter of speaking). However, most of the testers in my surrounding didn't recognize the ease of this way of working (or were not lazy enough?) so COVER didn't have much users.

Today is different. The attention for Model-Based Testing is growing rapidly. Previously, when a project had to make test cases, it was accepted that it was done manually and, everybody knew, it should take quite some time.
Today the budgets are lowered...What to do?...Less productivity?
My suggestion: When you've less money to spent, be creative to get the same results!

First Model then Test!

Model-Based Testing is a nice example of creative thinking!
Within a few months the relatively unknown possibilities of Model-Based Testing tools became very popular for Black Box testers within Sogeti. Especially the collaboration-part (designers working together with testers) of Model-Based testing is an eye opener. Everybody knows that it is smart to find defects as early as possible, but it is very difficult to motivate teams to perform good design inspections. Now MBT tools like COVER can do a big part of those intensive inspections, because using the models for generating test cases will directly show the defects in those models in a very early phase of the project! And beside that, it generates a big part of the test cases!

So, when the Designers create models that COVER understands, projects will perform Better, Faster and Cheaper! ....and it works!
Some (early) successes from our proof-of-concepts and implementations:

The amount of time needed for creating test cases dropped 50% (and sometimes more);
The maintenance of the (regression) test cases became in average 70-80% cheaper;
And maybe most important: We have proved to find defects much earlier than the project did manually!

Collaboration will change the world of testers!
Using MBT is in fact collaborating within the Application Lifecycle [ALM] supported by standardization and automation. Many defects, found in functional testing, have their origin in misinterpretations and assumptions of the requirements and/or specifications. The early usage (generating test cases) of formal models, just after or during the design phase, will create a much more solid base for software coding. For the testers this will mean less and less defects, so besides the generated test cases, the improved quality of the software will also fasten the test process.
(PS. When both software and test cases are generated from the same models, be sure that the test objective is clear!)

This industrialization cant be stopped anymore. The time of creating most test cases by hand has had its peak. Of course, not all test cases can be generated, and also manual testing itself will never disappear, but handcrafted test cases will be less and less common practice. The work of Black Box testers will, in my opinion, shift in two directions: 1) Earlier in the life cycle: joined modeling and helping and supporting development to find defects as early as possible (Master Test Plan consultancy), or 2) the coming market End-to-End testing: the importance of complete chains of applications is growing rapidly. End-to-End Testing will become a separate specialism.

Examples
Back to Model-Based Testing: To give an idea what type of models can be used, and how test cases are generated, I've made a some slides (with examples) about the Sogeti MBT tool: COVER. Look for yourself if MBT will affect your work!

It did affect mine!
;-)
Rob Kuijt

How to fix Team build Error in TFS2010 “MSTest.exe not found”

Thu, 11 Jun 2009 04:57:28 -0700

I must say it really helps a lot when you have someone available from the dev teams to solve some issues with the Beta Bits. As I told in my previous post I worked with Adam Bar from the Microsoft North Carolina Office for our devdays pre-conference. While working on my demo’s I ran into a problem where I did have a tests working locally, but once I ran an Team Build on the solution, I always got the message that MSTest.exe could not be found.

This happened to be a known bug on 64 bit machines and can easily be fixed by adding a registry key to the non wow64 node in the registry. It appears that in Beta 1, from the team build environment the location of MSTest is searched in the non 64bit registry location. What you need to do to fix this problem is the following:

Use regedit to add the following Key:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\10.0

Key Name: InstallDir and set that key to the location where Visual Studio 2010 is installed (e.g. C:\program files\ Microsoft Visual Studio 10\Common7\IDE)

Now start a new build and you will see the build will find MSTest again :-)

Cheers,
Marcel

Visual Studio 2010 Beta 1: How to fix Worklow designer crash

Wed, 10 Jun 2009 12:54:37 -0700

Last week I gave a presentation internally at our Info Support Knowledge Transfer evenings. Based on a deep dive training I got to attend on Campus begin of May, I presented a session on Windows Workflow 4.0. As you might know I am passionate about two technologies that I try to dig into as deep a s possible and those are visual Studio Team System and Windows Workflow Foundation. During the preparation of my talk on workflow, I obviously wanted to show some workflow designs and create some designs on the fly.

But Every time I wanted to create a new Workflow, the designer crashed and Visual Studio got closed :-(

It took me some while to discover that the crash was caused by the Visual Basic expression editor that gets activated once you create a workflow. This editor was unable to load a required assembly. It appears that this was caused by the fact that I installed Visual Studio at a different location then the default c:\ drive.

In the Beta the bits don’t check the install directory location in the registry but just assume this to be the default location.

But how could I fix this? I did install on D:\ and was not willing to install again, since that would take a lot of time.

After some digging around I found a great solution that is posted at the connect site. You can create a symbolic link at the OS level on the file system.
When you make a c:\profgram Files\Visual Studio 10.0 directory point to the actual installation on the D:\ drive the issue is solved.

You can use the mklink command for that and specify the /J option to create a directory junction. After running mklink as an administrator and restarting Visual Studio , I was able to create workflows.

Hope this helps if you run into the same issue.

Cheers
Marcel

How to make Layer Validation Diagrams work in the build

Tue, 09 Jun 2009 14:10:19 -0700

In Visual studio 2010 Team Architect edition, you have a new type of diagram available, called the layer diagram. What is great about this diagram is that you can use it to actually validate if the source code you have written adheres to the rules you defined in terms of allowed dependencies between layers. This adds great value to the notion of modeling the layers for your product and can help you mandate the rules you pose as an architect are actually followed by the development team.

In the visual studio IDE you can run a layer validation just by right clicking the diagram and selecting the option Validate, as show in screenshot below:

But what If I want to run this validation every time you compile the project, or even better during each build we run on the build server?

Cameron Skinner has a blog post based on the PDC CTP bits, on how you can create the layer diagram and link it into your solution for validation. The Beta 1 we currently use has the option to Validate default available in the dropdown of available actions for the linked diagram. But unfortunately it does not validate straight out of the box.

It took me quite some digging around in the target files that come with the architect edition, but I discovered that there is a property called ValidateArchitectureOnBuild that enables or disables the layer validation during the build.

So in order to enable the build during build, you must add this property to your build file. This can be done by unloading the project and adding the property to the property group that contains several options you select in the properties page of your project.

<PropertyGroup>

…
<ValidateArchitectureOnBuild>true</ValidateArchitectureOnBuild>
</PropertyGroup>

Once you reload the the project and run a local compile you will see the layer diagram is validated during the compilation pass.

Hope this helps you get layer validation running as an integral part of your build process :-)

cheers,
Marcel

Devdays 2009

Thu, 04 Jun 2009 14:11:47 -0700

It has been a few days since we held developer days conference here in the Netherlands. I Must say I was quite pleased to see there where so many attendees especially with the current economic situation.

Devdays is always this special week in the year for me since I tend to always give sessions on the latest greatest technologies and they also happen to ship a CTP or beta drop just a week for such a conference. This year again I had to work day and night to get all demo’s working on the latest available bits since that gives the best impression for the attendees in terms of the current available feature set. This year I presented a Pre Conference session on Visual Studio Team System 2010, together with Adam Barr, who is a Test lead at Microsoft on Team foundation sever. Adam Arrived on Monday and we spend two days getting all the demo’s working correctly. Also Edd Glas from the Team Test Team got over and presented part of the preconference. We decided it was great for the preconference audience to have two people straight from the trenches telling about what they are building. The total content for the Pre Conference covers over 6 hours of content and demos on what is all in the product, and the feedback received during the session was very positive.

On Devdays day 1, I got my personal 2 Minutes of fame during the Keynote Session. (aprox. 1800 people attending). Begin of January I have been selected to become a Microsoft regional Director for the Netherlands together with Anko Duizer. During the Keynote I was asked to talk in maximum 2 Minutes on my vision on ALM and what people should expect to happen in that space the coming year. I Got an picture of a Colleague of mine that has me on stage during the Keynote.

I must say it really looks different from the other side when you are on stage :-)

The second Day I gave my Last session that is called “Modeling that works with code” where I show what you can do with all the great new Modeling and DSL stuff shipping with Team Architect Edition 2010.

This is where I showed the value of modeling up front and Bottom up by generating UML Sequence Diagrams and DGML Diagrams based on the code you have. One of the demo’s I gave was something I was able to craft up with the Help of Edward and Clemens. This is a Demo where you can create new DGML Models using the available .NET API’s. This is very powerful if you e.g. use this in a Daily build and generate diagrams that show stuff like: Classes with a Code Coverage below a certain quality bar, Hot Maps in terms of code Churn mapped to all projects in your product, Lines of code expressed in the size of DGML Nodes, etc. It is amazing what the possibilities are. Clemens and Edward are working e.g. on Architectural Inspections based on the archetypes described in the Patterns And Practices application architecture guide.

If you are interested in the slides from this session, you can download them here.

In a Next Post I will show you how easily you can create a new Diagram based on the available API, and some fixes on visual Studio 2010 I needed to make for all the demo’s to work.

Architectural Inspections: Implemented in Visual Studio Team Architect 2010

Thu, 28 May 2009 13:05:24 -0700

Currently, Clemens and I are writing a whitepaper about Architecture, Application Architecture Guide 2.0 and Visual Studio Team Architect 2010. (VSTA). In addition to this paper we are also working on some ‘tooling’ that we plan to deliver with the paper. Since we are not done with the paper and tooling yet and this blog becomes a bit too quite I decided to start sharing some of our thoughts and work in this space on this blog.

One of the topics in the paper is, what we call, ‘Architectural Inspections’. Without going into too much details just yet we can think of an Architectural Inspection as a ‘check’ to help us verify the correctness of (parts of) an application architecture. The concept isn’t totally new, in fact the Application Architecture Guide 2.0 comes with an organized checklist that sums up important inspections that an architect can use during the design and/or validation phase of an architecture. Although a checklist is a great start, we think that a standalone checklist doesn’t get the most out of these so called Architectural Inspections. In our opinion it will be much more powerful if we can include these inspections in our Application Lifecycle Management practice, integrate them in the Visual Studio IDE and provide the right guidance at the right moment!

To validate our thinking, we collected all the inspections in the Applications Architecture Guide 2.0 checklists and stored them in an XML format. In fact, we used the Team Foundation Server 2010 (TFS) Work Item Type XML format which enables us to easily upload our Architectural Inspections into TFS as work items. In addition to the ‘core’ Architectural Inspection data, like title, status, description (where we explain what we need to validate and can add additional guidance) we added some meta data to categorize our Architectural Inspections and make it possible to do some grouping. For example, we can categorize our Architectural Inspections per ‘Cross Cutting Concern’ (Logging, Validation) or ‘Layer’ (Service Contract, Business Logic, etc.) or ArchType (Mobile, Rich Client, Service, etc.), or whatever we think makes sense. In addition we have build a little tool that lets us upload these Architectural Inspections into TFS as work items. Currently we store our Architectural Inspections as normal ‘Task’ work items and abuse some ‘hidden’ fields to store the meta data that we need. However, we already realized that we are better of defining our own work item type for our Architectural Inspections. So, this is probably the next thing on my ToDo list…

Below you can see a screenshot of (a very basic prototype of) the tool that we are using to upload our Architectural Inspections into TFS. As you can see we haven’t spend too much time on the User Interface yet and the data in the screenshot is just dummy data that doesn’t make too much sense.

However, the most important thing right now is that by using a tool like this we (as an architect designing an architecture) can easily decide which Architectural Inspections make sense for the architecture we are designing and add only those inspections into our Application Lifecyle. This means we can, for example, add only those inspections that apply to the layers or cross cutting concerns that our architecture requires. (In a future post we will demonstrate how we can even relate the inspections to layers in our Layering Diagram.)

Another thing that we think is important is to have a clear overview of all the inspections that are considered and/or executed during the design and/or implementation of the architecture of the application. Knowing that the guidance and best practices of a particular inspection wasn’t properly implemented or worse totally neglected is important information and (potentially) tells us something about the quality of the application. Of course sometimes it makes perfectly sense not to spend time on cross cutting concern X. However, at a later time we can’t recall the reasons for not spending effort on them. The fact that we now have our Architectural Inspections stored in TFS (as work items) makes it possible to track the current status (by using the status field (Active, Closed, Rejected?) )and provide us with valuable information about the design decisions (captured in the description field?) that are made during the lifecycle of our application.

Last but not least we think that, to get Architectural Inspections fully integrated in the Application Lifecycle, we need a proper way of visualizing them. In fact, an overview of these inspections and their status might be good starting point for a quality check or valuable input for our testers. The most common way for visualizing the status of work items would obviously be to create a report in TFS. However, we thought we better get some experience with another cool new feature of VSTA 2010 so we decided to visualize our inspections in DGML. So, what we did is, we create a little utility that extracts the Architectural Inspection information out of TFS and generates a nice DGML diagram for that. Below you can see a screenshot of how our first implementation of this looks like. (again, we might need some UI improvements and some real data)

The little icons in the nodes (representing an inspection) display the status of the inspection. At this moment the green check means the inspection has the ‘Closed’ status in TFS and the warning sign means it has the ‘Active’ status (so nothing has been done with it yet).

There is a lot more to tell about the things we have been working on and the thoughts we are still having about Architectural Inspections, Application Architecture Guide and VSTA 2010 extensibility. We are currently busy improving and refactoring all of the above. In the coming period we will share some other VSTA extensions that we are working on and if things goes as planned everything will end up in the whitepaper and/or downloadable assets. So, stay tuned and of course we are very interested in your opinion, concerns, etc. so leave us a message!

How to enable code coverage in Visual Studio 2010 Unit tests

Thu, 21 May 2009 16:14:06 -0700

When you want to Enable code coverage in an Unit test run in Visual Studio 2010 you may find that the steps you need to take have changed.
In Visual Studio 2010 you need to take the following steps:

Open the Local.testsettings file and there you will see a set of items you can configure on the left hand of the dialog.

Here you need to select the “Execution Criteria” in the left list and then you can see at the bottom of the page the set of collectors that are enabled for a test run.

In this list you need to select the “Code Coverage” item and mark the enabled check box. In the 2008 ide you would direct see the assemblies that are part of the coverage gathering during the run. In the 2010 dialog you can select the assemblies by first clicking on the “Code Coverage” row in the collectors list and then clicking the “Advanced…” button. Then you will see the more familiar dialog again as shown below:

Here you need to pick the assembly that is under test and click “Ok”

Now when you run another unit test you will see code coverage is now enabled.
When you take a further look into the set of collectors you might also see a set of new collectors that you have not seen before.

When you enable e.g. the video recorder, you will get an video capture of your computer while the test was running. While this is less interesting for a Unit test that has no UI interactions, this is very interesting when you create a new type of test called Code UI test that can run an previously recorded UI test and replay it on a test machine. You can see the channel 9 video that shows more about coded UI testing if you want some more information on that new feature.

What is interested to see is enabling e.g. the Test Impact collector, that enables the Test Impact feature. Once this collector has run, you can see in the Visual Studio IDE a list of suggested tests based on code changes you have made to your local source. This enables you to run a minimum set of tests to verify changes you have made to the codebase. this test impact analysis can even be used during the Team Builds run e.g. every night on a server, so you can have a lean and mean build that runs only impacted tests to verify regression on previous tests.

When you create a new Unit test in a solution you also might notice that there is a second “testsettings” file created called “TraceAndTestImpact.testsettings”. this file contains all the settings to run a set of unit tests with the correct settings that enable test impact analysis.

Windows 7 RC available soon, very soon

Sun, 26 Apr 2009 15:39:00 -0700

Today I received information that I am allowed to disclose that most people will find very exiting:

Windows 7 RC will be available end of this week!

For MSDN subscribers it will be available at our Queens birthday, April 30th, for the public it will be downloadable May 5th

You can read more about it here on the Windows 7 blog.

Can't wait to get my hand on this new build, it really looks promising if you take a look at all the improvements made while I liked the new OS already :-)

Cheers,
Marcel

Visual Studio Team System 2010 - Episode 4: Quality Check

Rob Kuijt — Fri, 24 Apr 2009 01:04:09 -0700

In this episode I will discuss the different practices around the Quality Check in order to do this important check for ALM as efficient and effective as possible.

Previous episodes:
Visual Studio Team System 2010 - Episode 1: A Focus on Testing
Visual Studio Team System 2010 - Episode 2: No Risk No Test
Visual Studio Team System 2010 - Episode 3: The Lifecycle

In the last episode Clemens talked about the support VSTS2010 will give on the collaboration at artifact level. Different roles in the lifecycle work together on artifacts. Each of them adds their knowledge, vision and ideas to the solution from their view point. These artifacts are accessible by every role in every phase of the project, adding value throughout the lifecycle. People are enabled to collaborate, making applications together, and not only by telling what they are doing but most important by working seamless together on the application.

TMap® Quality Check
A subsequent measure for increasing the quality of the developed artifacts is an evaluation activity: for instance the review.

The review is a method of improving the quality of an artifact by evaluating the work against the requirements and/or guidelines and subjecting it to peer review.

The review on the requirements and/or design can be carried out as a static test activity before the coding starts.
In the review, the following points can be checked, independently of the set requirements:
1. Has the artifact been realized in accordance with the assignment? For example, are the requirements laid down in the technical design realized correctly, completely and demonstrably?
2. Does the artifact meet the following criteria: internally consistent, meeting standards and norms and representing the best possible solution? Best possible solution means the best solution that could be found within the given preconditions, such as time and finance.
3. Does the artifact contribute to the project and architecture aims? Is the artifact consistent with other, related artifacts (consistency across the board)?
4. Is the artifact suitable for use in the next phase of the development?

Why?
Like testing, the Quality Check is a measure to provide insight into the quality of delivered products and the related risks when taken into the next phase of the lifecycle. If the quality is inadequate timely measures can be taken, such as rework by the designers. However, there is never an unlimited quantity of resources and time. In theory it is important to relate the Quality Check effort to the expected risks. A pragmatic approach to determine the Quality Check effort is to look at some past projects and answer the question:

"How many defects, detected in Acceptance Tests, could have been found much earlier, if we had done a Quality Check? (According to the above points)"
In my experience 10-20% of the defects could have been found much earlier in the lifecycle when the Quality Check was done properly. And because defects in the Acceptance Test are quite expensive, you only have to find 1 or 2 serious defects in the Quality Check to make it economic worthwhile. So my strong recommendation is:

7 Hints and tips
1. Performing a good Quality Check is a kind of inborn specialization. Find a person who is good in recognizing texts with high potential risk on assumptions and or interpretation errors. In other words: find a pencil-pushing, nit-picky quality geek!
;-) Most professional testers are proud to have these qualifications.

2. Before checking an artifact: What is the quality of its source? Is the source of the AUC (Artifact Under Check) ready? authorized? stable? If not, consider to do also a check on the source of the artifact to quantify the possible changes in the (near) future,

3. If a previous version of the artifact is available, and the quality of that version is known: make use of a so called Comparison Tool to find and check the differences. AND! Check always the consistency of the change register, especially when the change register is used in the next phase to implement the changes.

4. Combine the Quality Check with the estimation activity for the next phase. If the estimation is done by another person, let them work together!

5. Use a checklist as a reference! For your own protection, a checklist prevents that too much attention is paid to the use of standards and correct spelling or even to these aspects alone (This can be a cause of friction among the various people involved.) Partly owing to the diversity of design techniques and information sources that, it is not possible to create one general checklist per artifact type. Therefore, checklists should be created specific to the situation per organization and per project. Of course you can use examples like Testing Requirements or Testing Use Cases as a start for the creating of your checklist.

6. Make always clear what checks you will perform. By communicating your checklist you can prevent a lot of misunderstandings on later findings.

7. Audi alteram partem (hear the other side). Don't report on findings/defects without a fair hearing in which the author of the artifact is given the opportunity to respond to the "accusations" against his work.

Collaborate
For some, it is very tempting to do a review in their own silo: Get the stuff to check, find as much as defects as possible, receive applause for the prevented damage and do that over and over again
Wrong! Dont be a Scrooge! (see my blog: "Does Scrooge exist?") An essential part of the Quality Check is the Learning Cycle. By performing Quality Checks the quality of future AUCs (Artifacts Under Check) must grow. So collaborate with the designer, information analyst or whoever made that artifact, and get your applause on the better quality of artifacts instead on the number of defects.

In the next episode Clemens will explain how the tools support the Quality Check, as well as the collaboration around it, to get the optimum results.

How to assign a work item to a group and actually have it show a list of values

Tue, 07 Apr 2009 13:45:00 -0700

Today I was asked one of the most asked questions related to work item tracking: “Can you can assign a work item to a group in stead of a person”?

My standard answer to this question is “yes” and I tell people this can be easily be done by setting the ALLOWEDVALUES to include the attribute expanditems = “false” and add list items that contain the TFS group names.

Since the question came from my team mate I said I would fix the work item type so he did not have to spend to much time for this simple change.

To my surprise I found that it is easy but you have to know one additional fact and that is that you must not have altered the System.AssignedTo to only allow valid users!

So what happened?

I have a work item type called “Deliverable”. This is a work item that can be assigned to a group of developers, designers, testers, etc. So the requirement was simple, have this work item only assigned to a group in stead of a person. What I did was quite simple, for each state definition I just set the ALLOWEDVALUES to the list of groups I want to have the work item assigned to. See the example below:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 <STATE value="Scoped"> <FIELDS> <FIELD refname="System.AssignedTo"> <ALLOWEDVALUES expanditems="false"> <LISTITEM value="[project]\Project Managers" /> <LISTITEM value="[project]\Feature Managers" /> <LISTITEM value="[project]\Software Architects" /> <LISTITEM value="[project]\Designers" /> <LISTITEM value="[project]\Implementers" /> <LISTITEM value="[project]\Testers" /> <LISTITEM value="[project]\Integrators" /> </ALLOWEDVALUES> <REQUIRED /> </FIELD> </FIELDS> </STATE> 
After uploading the work item, I got a strange surprise, the assigned to field always appeared empty

It took me quite some time to figure out what happened here. I finally figured out that this is caused by the fact that the Work Item Field definition for System.AssignedTo has a constraint set of <VALIDUSER/> and a TFS group is not considered to be a valid user. (This is something that probably your custom work item has as well since the common way to customize your work items is to pick the Microsoft work items and change those. The Microsoft work item types have this constraint set as well )
1
2
3
4
 <FIELD reportable="dimension" type="String" name="Assigned To" refname="System.AssignedTo"> <strong> <VALIDUSER /> </FIELD> 
So to fix this problem, I removed the <VALIDUSER/> constraint on the System.AssignedTo field. After removing the constraint and restarting Visual Studio after uploading the new type definition(I used WITImport at the command line, but this can also be done using the power tools) , the dropdown will show the options I expected to see.

So it is nice when you know the answer , but here you can see again that only knowing the answer is not enough to be productive, you actually have to have done this so you also know the problems you might run into

Hope this keeps you from pulling your hair out.

Cheers,
Marcel

Hot fix available for Transaction inside receive activity scope bug workflow 3.5

Sun, 08 Mar 2009 15:57:00 -0700

Back in august I worked with a customer to build a workflow solution using Workflow 3.5. We crafted up a simple workflow where we would like to get a message into the workflow using the receive activity and then persist this call in the database, giving the caller a ticket that he can use later for reference. We could do some processing in the background and then when we finish the caller could get information based on the ticket. Now this is in my opinion a very common scenario that you probably will run into with your solutions as well.

to make this scenario more reliable, we used a transaction scope activity to guard the database transaction and make sure the workflow get's persisted in the same transaction.

A simplified version of the workflow we used is shown below.

Now this looks to work perfectly correct, but we discovered that if the transaction fails you will get the following error:

"Workflow service unexpectedly unloaded from memory while executing a ReceiveActivity. Make sure that the the workflow does not contain any blocking activities within a ReceiveActivity."

After getting the error back the workflow will be terminated since it got an unexpected exception.
Things can even become worse if you look from the messaging perspective, that the caller will recieve an timeout on the call, since no reply is send back. It appeared that this happened when you set the UnloadOnIdle to false.

To make sure I did not do anything wrong I called a friend who is also very knowledgeable about workflow and asked him what his thoughts where. He also made a blog post about this issue and spend quite some time to figure out what was going wrong here. (http://msmvps.com/blogs/theproblemsolver/archive/2008/08/06/using-a-transactionscopeactivity-with-a-wcf-receiveactivity.aspx)

Finally I decided that this looked like a bug in the activities, so I issues a PSS call to ask for a hot fix for this problem. After working with the support department and some developers on a simple repro of the problem we finally got to the point that it was recognized as a bug and that they could build a hot fix to solve the problem.

So back in November I received a private hot fix that solved the problem, but I wanted to make sure everybody else could leverage the fix as well, since this is such an common scenario.

I crafted up some tests to show the problem and I could use that easily to verify if the hot fix solved the problem or not. You can see below that after applying the hot fix all tests showed green again :-)

Before:

After:

Last week I got the official hot fix and the analysis back from the development team that states the following:

Root cause of the problem:

WorkflowRequestContext, a member of ReceiveActivity, is not serialized as part of the checkpoint. Consequently, when we restore the checkpoint upon TSA fault, we are unable to send a reply message to the ReceiveActivity caller.

We produced a fix to address this issue and delivered to our customer. This fix will be part of the next major releases of WF 3.5 (if any). KB Article 959362 will be published soon

So if you have this same scenario in your solution, check what happens when your transaction fails, e.g. by stopping the database so the call will fail, and see if you run into the same issue. The problem I found with this bug, is that this only surfaces when you have good tests in place that also test for the failure of the transaction and that is probably not always the case. You might not even have noticed you have a problem, but at least you know you can get a hot fix now. You can refer to KB 959362 and they can hand you the hot fix for your environment.

Cheers,
Marcel

Making money with Application Lifecycle Management

Fri, 20 Feb 2009 13:26:33 -0800

A few days ago I was asked by one of my colleagues why I am spending a lot of my time experimenting with Visual Studio Team System 2010 (Team Architect), Blueprints, App Arch Guide and Application Lifecycle Management (ALM) in general. He noticed me ‘living’ in VSTS 2010 CTP for some time now and he was wondering if it isn’t a bit too early for this and what I did to convice to management to let me do this. My immediate answer to this question was ‘No, it is not to early!’ and I explained that we (Inter Access) expect VS 2010 to help us optimizing our Application Lifecycle Management practice. This answer was a bit too vague for my colleague and of course the next question was how will we benefit *exactly* from investing in VSTS 2010 and ALM. Will it make our life easier?, will it makes us better people?, will it improve quality?, will it save us time?, will it save us money?

Exactly these same questions popup when discussing ALM with customers. Apparently making the business case for ALM (and/or VSTS licenses) isn’t always easy. How come?

From our experiences we learned that currently most people and organizations are relating ALM to their development activities (Software Development Lifecycle). Therefore it is only logical that this is the area where people are trying to identify their benefits (costs savings) from ALM. But is this correct? Is this focus too limited? Shouldn’t we focus on more than only development when it comes to cost savings? Especially if we keep in mind that, on average, only 30% of the IT budget is spend on new application development (the remainder is spend on maintenance/operations)!

How come most of us still only focus on development? Is it because we still focus too much on the tools instead of facilitating collaboration between ‘Business’ ‘Development’ and ‘Operations’?

Everybody experienced in VSTS 2005 and/or VSTS 2008 will come to the conclusion that these tools mainly focus on the different roles within the development team (developer, architect, project management). Source control, unit testing and quality assurance features of these products provide us with a professional development environment and help us improving the overall quality of the products that we deliver. Work item management, a centralized store, reports, portals, etc. improve the collaboration within the development team and support project management in tracking progress, staying in control and managing risks adequately. All of this is great and potentially boost the performance of the development teams but experience learns that these benefits don’t come ‘out of the box’! Installing the tools doesn’t make the development team collaborate by default and most certainly doesn’t stimulate collaboration with the Business and Operations!

Now we know where most of us focus on for their ALM related activities, let see how this relates to the complete application lifecycle. For this we will use an the graph below were the x-axis represents time and the y-axix represents value and negative value displayed as costs.

Obviously the lifecycle of the application starts with its development. During this phase we have to make costs to design, develop and test the application. At that time the application doesn’t bring us (actually the business) any value and the complete development phase of the project only costs money. From the moment the application (parts of it?) are installed into production the appliaction starts to generate value till the moment it needs to phase out where it starts to cost money again.

What we see is, that most organizations are focusing on reducing the developments costs and (sometimes) try to shorten the time to market. Btw. it doesn’t come as a surprise that these are exactly the areas where the current releases of Visual Studio Team System focus on.

Reducing costs and make the application add value earlier is good but if we have a look at the image above we can see that the application lifecycle doesn’t end at the moment the application goes into production (where lifecycle line crosses x axis). So, wouldn’t it be great if our ALM practices help us optimize (reduce costs and/or increase value) during the remainder of the application lifecycle also?

For example, one of the things we can do to increase the business value is to practice a proper User Experience design (see this post of my colleague Andries for more info on this). By taking ‘Operations’ into account during the design and development phase of the application we can reduce operations costs during the remainder of the lifecycle. These things combined will result in an application that is more successful for a longer period of time (because it adds more value and costs less to maintain). Also, because we have done a good job developing the application, we know exactly what it does, where it is interfacing with (something VSTA 2010 will help with) and most importantly when it stops adding value which will help reducing the ‘phase out costs’ of the application.

Adding this to the graphical representation of our application lifecycle results in a graph that looks like this.

Based on this, we can now draw our new application lifecycle which might looks something like this (dotted line is new lifecycle).

The good news is that the green area between the ‘old’ and ‘new’ lifecycle is the area were we can make money by adding extra value. The red colored areas is the place where we can make money by reducing costs. Doesn’t that look great???

Please note that ‘Reduce operations costs’ might be misunderstood from this graph. We don’t mean less value but less costs. I didn’t know how to display this correctly :-)

Of course, all of these things don’t come by itself. We have to actually work for that to make that happen and we can’t do everything at once. In this post I am not going to detail all the steps that we can do to make that happen and where we can use the current or future tooling for. However, hopefully this last image makes it very clear that there are others areas, besides development, within the application lifecycle where we can either reduce costs or increase value. So, if anybody aks you why they should invest in ALM this image should give you a starting point for your discussion…

At least, it *did* help me explain why I should spend my time on ALM and experimenting with VSTS 2010, Blueprints and App Arch Guide :-)

Visual Studio Team System 2010 Episode 2: No Risk No Test

Rob Kuijt — Tue, 10 Feb 2009 11:08:30 -0800

In episode 1, Clemens introduced the focus of Visual Studio Team System 2010 on the collaborative effort between the tester and the other roles in the application lifecycle. In this second episode I will start with a short introduction on testing.

Testing is not an aim in itself! Testing is, in fact, a balancing act. What risks must be covered, what results are to be delivered and how much time and money can be spend, based on rational and economic grounds?

The right test strategy will balance among risks and costs .

Testing supplies insight in the difference between the actual and the required status of an object. Where quality is roughly to be described as 'meeting the requirements and expectations', testing delivers information on the quality.

In this, there is no difference for developers who are testing, specialist testers during system testing or generalist testers during the final acceptance test. Choosing the right test strategy is a joined effort between every tester and the other roles in the application lifecycle. This collaboration is needed because, beside insight in the business risks, much (technical and test) knowledge is needed to find the most important defects as early as possible at the lowest price.

The collaboration doesn't stop after choosing the best test strategy. After designing the test cases, also test execution must be organized as a joined effort. Collaboration between the different roles in the application lifecycle is not self-evident. By nature, it looks like developers and testers don't (want to) understand each other. Having this attitude, it is difficult to find out you need each other to deliver software of good quality.

...dont (want to) understand each other.

The consequence of this virtual (and sometimes real) wall is calamitous for quality. Many bugs arise by doing wrong assumptions and interpretations of the, in generally, unclear specifications and requirements. Reporting, analyzing and resolving these bugs take a lot of time, especially when they prove to be not reproducible or wrong.

An Example: After a development project of 5 man year, testing is done by a team of generalist testers. With much enthusiasm the test team executes the test cases they designed during the building of the system. After 3 months the verdict is given: Negative release advice, because of (8) blocking and (22) big defects, the test team gives the advice NOT to go into production. As you may understand this was a big disappointment for both the project team as the business department. A taskforce was established to keep the delay (damage) in control. After the defect analysis the general feeling became better, after filtering the test faults (20%), the functional wishes (20%) and changes (not passed through to the testers; 30%) the repair costs were approximately 200 hours ( for the remaining 30%). In fact the development team had done a great job. Better communication from both sides, before and during test execution, probably had made the verdict a, celebration worthy, positive release advice. Much, much better than this cold shower!

The above paragraphs show that the collaboration between the tester and developer is important for success. If the collaboration between the different roles in the application lifecycle is not actively stimulated and facilitated, the proverbial wall will arise.

In the next episode Clemens shows us how Visual Studio Team System 2010 will support and stimulate this collaboration...

Security update for Team System Web Access SP1

Tue, 27 Jan 2009 14:11:00 -0800

I just found out that on January 16th Microsoft has released an security update for Team System Web Access that I would urge everybody to install. You can read more on the update on Hakan Eskici's blog here.

Note that this is a full install so you must run an uninstall and install to complete. This means you will have some downtime to apply this update.

I just wanted to give everybody a heads up on this.

Cheers
Marcel

Testing or Documenting?

Rob Kuijt — Mon, 12 Jan 2009 13:28:21 -0800

How sure is a company about the quality of their Calculation Component(s)? Are they bug free? Even after, for instance, nine changes? Testing changed components is tricky, because you never get the time to test a Calculation Component with lots of values, because most of the testing is still done manually.

There are many test tools that could do this job much faster, but they are complex to use and mostly pretty expensive.
So I did some thinking .I want to do lean and mean Calculation Component Analyzing!
Preferably: User-friendly, quick, low cost and in a way that the outcome is easy to check!

Personally I like pictures instead of figures. So I started some PHP programming, and voila these are my results:
The first version is a service that can analyze a one parameter Calculation Component. Let me give an example.
The test object is a web component with one input parameter. In my home made analyzer service I give the URL of the test object, the start input value, the end input value and the step size (see fig.1)

Fig.1 Input screen of my home made Analyzer
After sending the input, the analyzer performs, in this case, 21 calls to the test object, and responses with the following graphics:

Fig.2 Output screen of my home made Analyzer
This output gives a first impression of the calculation. It looks like: output=input*input (if input > zero) or output=input*input (if input >= zero).

But to be sure, let's make the steps in the range smaller(step=10):

Thats strange! The input value 10 gives a response: zero!

Again, let's choose step=1:

Now I'm pretty sure that the calculation function is: output=input*input (if input greater than ten)

And for a last check (in this example) I choose step=0.1:

Yes, it still looks like: output=input*input (if input greater than ten)

Conclusion:
I think that this kind of functionality is valuable, not only for testing, but also for documenting Calculation Components.
Above that, it is:

Easy to use (one simple input screen),
Low cost (I did build the function in 2 hours (with the help of open source: PHPLOT)),
Quick (the above analyzing took me 3 minutes (including capturing the pictures for my blog)),
Simple to read.

And it's FUN to play with!
Now I'll try to find some use for this kind of functionality, and l start thinking how to handle (and present the outcome) for a two parameter Calculation Component.

Rob

Blueprints: Visual Studio 2010 (2)

Mon, 12 Jan 2009 06:07:57 -0800

In an earlier post we mentioned that it is relatively easy to get the current Blueprints bits running on the Visual Studio 2010 CTP by modifying the .MSI in Orcas. At that time we forgot to mention that we need a few extra steps to really get things going with Blueprints in Visual Studio 2010.

When trying to build a Blueprint solution in Visual Studio 2010 we will notice the following error in the error window.

As we can see, the build task ‘BASM’ is failing to retrieve the correct path. This task is implemented in the ‘Microsoft.SoftwareFactories.Blueprints.Builds.Tasks.dll’ that can be found in ‘..\Program Files\MSBuild\Microsoft\Blueprints\2.0’. It turns out that the execute method of this tasks looks for a (hardcoded) ‘String Value’ called ‘Blueprints’ under the ‘HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\MSBuild\SafeImports’ tree. Because we replaced all ‘9.0’ in ‘10.0’ in the Blueprints .MSI to get it to install on Visual Studio 2010 this value doesn’t exist under ‘9.0’ anymore (but does under ‘10.0’).

To fix this we can either make sure to skip this particular replacement when modifying the .MSI in Orcas or manually add the Blueprints ‘String Value’ under the ‘HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\9.0\MSBuild\SafeImports’ and give it the value ‘C:\Program Files\MSBuild\Microsoft\Blueprints\2.0\Microsoft.SoftwareFactories.Blueprints.targets’.

Another issue occurs when debugging our Blueprint in Visual Studio 2010. Currently, there is no property page implemented for the Blueprint project type (.bpproj) and therefore starting up Visual Studio 2008 is hardcoded in the Blueprints core. To get around this we can add an empty C# ‘Class Library’ project to our solution, set this project as the ‘StartUp’ project and make this project startup Visual Studio 2010 (property page) when debugging. Although this solution does work it makes the Visual Studio instances in my Virtual PC image VERY slow (don’t know why). Another option, that does work for me, is to leave the Blueprint project as the ‘StartUp’ project, let it start up a Visual Studio 2008 instance, (and simple ignore it) manually start another Visual Studio 2010 instance and attach this instance to the debugging process of the Visual Studio instance we started the debug session in.

Now everything is in place to *really* start developing Blueprints for Visual Studio 2010 CTP!

Integrating Blueprints, Layering Diagrams and Architecture Guide

Wed, 07 Jan 2009 05:20:17 -0800

In a previous post we already mentioned Blueprints as a means for integrating architectural guidance from the p&p App Arch Guide in the VS2010 IDE. Clemens already mentioned how we can capture some of this knowledge in an item template and use the IWizard interface to populate the diagram. Now, let’s see how we can use Item Templates in a slightly different way and use them in a Blueprint to unfold a predefined architecture (Layering Diagram) in VS2010.

The first step is to capture the architectural guidance in a Layering Diagram that we can reuse. To do this we can we create a new Modeling project and add a Layering Diagram to this project.

In this diagram we can model all layers, dependencies, etc. to make it reflect our architectural guidance. Once we are done it might look something like this.

To make this diagram reusable we have to create an Item Template for it. Unfortunately VS2010 doesn’t let us select the layering diagram in the Export Template Wizard so we have to manually create an item template for our layering diagram. The easiest way to do this is to create an Item Template for another file type (i.e. C# class) and modify the ‘MyTemplate.vstempate’ file in the .zip file that VS2010 generates and add the two diagram files (.layer and .layer.diagram) to the .zip file. The modified MyTemplate.vstemplate file should look something like this.

Now we are done creating a reusable layering diagram we can integrate this with a Blueprint. (of course we can create more item templates for other architectures defined in the p&p App Arch Guide)

In this post we will not explain how to create a Blueprint from scratch but this is pretty easy. Especially after watching the How To videos. Once we have created our Blueprint we can use a Workflow Foundation based workflow to actually add our predefined layering diagram to our solution.

To do this, we first have to add a Workflow Command to our Blueprint (screen cast for more details) that will enable our Blueprint users add a layering diagram to their solution. The documentation that comes with the Blueprint Workflow Command provide us with the code we need to execute a workflow. However, this code assumes we are executing a ‘XOML only’ workflow. In our case we choose to use a codebehind for our workflow so therefor we use the ‘ExecuteWorkFlow’ method instead of the ‘ExecuteXomlWorkflow’ method. The code in your command might look like this (added some hardcoded paths instead of calls to helper class to get the correct paths).

Now that we have the command in place we have to create the actual workflow that we execute from the command. After installing Blueprints we get a few extra activities that we can use in the workflows in our Blueprint. Below we can see how this workflow might look like.

The ‘ShowDialog’ activity in this workflow is a normal ‘Code’ activity that in this case shows the (very simple) dialog that is displayed below. This dialog lets the user select the architecture that will be used in his solution.

Once the architecture is selected, the workflow continues with the ‘CheckProjectExists’ activity. This Blueprint specific activity checks if the current solution contains a ‘Modeling project’ with the name ‘Architecture’ (I am sure you can come up with a better name ;)). If not, the project is created. After that the ‘AddLayeringTemplate’ activity is executed to actually unfold the selected item template that will add the predefined layering diagram to our modeling project in our solution.

In this post we deliberately left out some implementation details that you might need to implement this yourself. However, hopefully it does explain the basic scenario of how to add some architectural guidance from p&p App Arch Guide by using Blueprints and VS2010 Layering diagrams. In future posts we will ellaborate on this scenario, share some more technical details and eventually might even end up with a working solution that we can share :-).

Yessssss, Another year as MVP!

Fri, 02 Jan 2009 01:21:00 -0800

When I got back in the office this morning I was very pleased to see the Congratulations email in my inbox. Little excerpt from the mail:

Congratulations! We are pleased to present you with the 2009 Microsoft® MVP Award! This award is given to exceptional technical community leaders who actively share their high quality, real world expertise with others.

The Microsoft MVP Award provides us the unique opportunity to celebrate and honor your significant contributions and say "Thank you for your technical leadership."

Toby Richards
General Manager
Community Support Services

I feel really privileged to be awarded for a 4th year in a row as Team System MVP.

The most important reason I am so glad to be awarded Team System MVP is that it enables me to be part of a community of really great and knowledgeable people. Not only is the Team System team a great group of people to work with, they also really value the feedback we give and transform our feedback in shaping the product to be the best ALM offering around against a really affordable price.

I want to thank Microsoft in recognizing the work I have done last year for the Team System and developer community. I also want to thank Info Support since they enable me to work at the bleeding edge of technology and support the work I do in the community as Architect, Speaker and Author.

Happy New Year!

Cheers,
Marcel

Blueprints: EnableDeveloperFeatures

Sat, 27 Dec 2008 14:24:13 -0800

During the development of our Blueprints we can sometimes use a little extra help to understand what is really going on. It turns out that if we add a Registry setting called ‘EnableDeveloperFeatures’ under the ‘HKey_Local_Machine\Software\Microsoft\Blueprints’ key and set its value to ‘true’ we get a few extra features enabled in the Blueprint Manager that might help understand (debugging) Blueprints . In the screenshot below we can see the checkboxes that become visible after we have added the ‘EnableDeveloperFeatures’ setting to the Registry. The checkboxes are read only in the Blueprint Manager dialog but can be set through the Registry.

As we can see, the ‘Custom Menu Filter’ checkbox is checked which means custom menu filters are enabled by default for our Blueprints. We can disable this feature by adding a ‘DisableCustomMenuFilters’ setting under the ‘HKey_Local_Machine\Software\Microsoft\Blueprints’ key and set its value to ‘false’.

To enable logging in the Blueprint Manager we can add the ‘BPMLogging’ setting to the Registry and set its value to ‘true’.

In an earlier post I demonstrated how to create a custom menu filter. After adding a ‘MenuDebugging’ setting to the Registry and set its value to ‘true’ we can see that Blueprint Manager now logs (output window) that it actually detects the custom menu filter that we created and also determines if it should be visible or not.

Hopefully, enabling these features help a little during the development of your Blueprints…

Blueprints: Visual Studio 2010 CTP

Tue, 23 Dec 2008 12:58:40 -0800

For some (experimental) work that I am currently doing with Clemens we needed a version of Blueprints that installs on the current VS 2010 CTP. I am sure every developer already knows how to modify an .MSI package by using ‘Orca’ (part of Windows SDK) so I am not going to explain in detail how to do that. However, the good news is, that if we open the Blueprints 2.1.2 CTP in Orca, replace every occurrence of ‘Visual Studio 9.0’ by ‘Visual Studio 10.0’ and save it again we are good to go. No other changes needed. The modified installer runs without issues on VS 2010 CTP and so far we haven’t found any problems with Blueprints on VS 2010.

If you are interested in the work we are doing, I suggest to go read an introductional post that Clemens just posted which describes some early ideas. Expect some more details in the next coming days, weeks, months on both Clemens blog and/or this one.

Sticky Notes!

Tue, 23 Dec 2008 00:20:50 -0800

My friend Pablo just released Sticky Notes. As one of the beta testers for this cool Visual Studio extension I had the opportunity to play with it for some time and I found this a very handy and easy to use tool for ‘managing’ comments in source code. I mentioned to Pablo it might be cool to include TFS integration so I really hope this will be a feature for Sticky Notes vNext! I suggest you take a look at the screenshots and videos and decide for yourself how this can help your development activities. Great work Pablo!

Blueprints: Custom menu filters

Mon, 22 Dec 2008 15:40:59 -0800

For one of the Blueprints I am currently writing I had to add a menu item that enables the Blueprint user to execute a specific task (command). Adding menu items to a Blueprint is pretty easy by using the Blueprint configuration dialog. As we can see in the screenshot below we can also set the ‘visibility for the menu item by specifying a menu filter in the ‘Visibility box’ on the dialog.

The current Blueprints CTP comes with a few ‘built-in’ menu filters like: Project=roject name, FolderEndsWith=folder name, etc. (complete list can be found in de Blueprints documentation). Of course I needed a menu filter that wasn’t available out of the box. Unfortunately the documentation doesn’t say anything about adding custom menu filters but luckily a little experimenting (and Reflector ;)) was enough to get this to work.

Here are the steps to implement your own custom menu filter:

The first thing to do is to simply add the name of your new custom menu filter in the ‘Visibility’ box of the menu item you want the custom menu filter to be applied on. In this example we also pass a custom argument (‘BlaBla’) to our custom menu filter.

The second step is to actually implement the custom menu filter. This can be easily done by adding a ‘Command Extension’ project to your Blueprint solution (Blueprints menu –> Add Command Extension). This project already implements a post build event to make sure the .dll that hosts your command extension is copied to the correct location to let Blueprint Manager find it during execution of your Blueprint.

for this example we can delete all default files in the extension project and add a new class to this project that implements the ‘IMenuFilter’ interface (add a reference to the ‘Microsoft.SoftwareFactories.BASMAPI.dll’ assembly that can be found under the Blueprint installation directory).

In this class, the ‘FilterSupported’ method is used to decide whether a custom menu filter is supported in our Blueprints. Àll we have to do in this method is return ‘true’ for the custom menu filters (name) that we want to support in our Blueprint. (note that we can handle multiple custom filters here).

The ‘Visible’ method is used to decide whether the menu item that has our custom menu filter applied should be visible or not. The screenshot below demonstrates a, not very useful (and not bulletproof), implementation of a custom menu filter that only shows the menu item in case the Blueprint user right clicks the Solution (Solution Explorer) and the name of the selected Solution starts with the parameter supplied to the custom menu filter (‘BlaBla’ in this case). As said, not a very useful filter but it hopefuly demonstrates what can can be done here.

After we finished the ‘Visible’ method, we are done implementing our custom menu filter and all we have to do is make sure the Blueprints Manager knows about our custom menu filter. How?

As we can see in the screenshot below, the menus that we define in our Blueprint configuration dialog (see above) are stored in the ‘config.xml’ file of our Blueprint (located in the properties folder in our Blueprint project).

At some point, the Blueprint Manager parses this config file, searches for custom menus, detects the ‘MyCustomMenuFilter’ that we specified in our menu item and notices it isn’t one of the ‘built-in’ menu filters. At that time the Blueprint Manager checks if any additional ‘resources’ are registered for our Blueprint that might host an implementation of the ‘IMenuFilter’ interface. To make sure the Blueprint Manager can find our extension, we register our custom menu filter by adding the following (screenshot below) to the config file of our Blueprint.

After that, if the Blueprints Manager detects a menu filter that is doesn’t recognize, it will search its additional resources and find our custom menu filter implementation. It will then call the ‘FilterSupported’ and ‘Visible’ methods on our ‘CustomMenuFilters’ class to decide whether or not the custom menu item is supported and under what circumstances display our menu item.

Blueprints: Customize template unfolding

Sat, 20 Dec 2008 14:27:52 -0800

When working with a Blueprint to deliver a product, we very often start with unfolding a solution/project structure (template) that reflects some architectural guidance. When building a Blueprint, we have a few options for unfolding templates within our Blueprint (that we can set through configuration as displayed below). The option ‘None’ obviously doesn’t unfold a template at all, ‘Auto-generated’ unfolds a predefined project template (C# class library) and ‘User-supplied’ provides us with the possibility to define our own solution/project templates. (The guidance that comes with the current release of Blueprints does a pretty good job describing these three options)

However, sometimes we need even more control before, during or after template unfolding (ie create folder structures, complex dialogs, Add to source control, etc.). Luckily, there is another mechanism that we can use for this scenario that gives us full control!

We can add a ‘Command Extension’ (right click on your Blueprint and select ‘Add Command Extension’ from the Blueprints menu) and write an extension that unfolds our custom project templates.

Adding a Command Extension to our Blueprint gives us a new project in our Blueprint solution. This new project already contains an example extension that we can modify to implement our custom unfolding logic. Below, a simplyfied implementation of this modified Command Extension is given that uses the custom ‘MyTemplate.vstemplate’ template and unfolds that to a (hard coded) location.

After we fully implemented our extension, we can add this Command Extension to the commands collection of our Blueprint (More info on how to add commands can be found in the Blueprints documentation).

The real ‘trick’ here is to name the command ‘INIT’ which will force the Blueprints Manager to execute the command automatically for us when unfolding our Blueprint to a (empty) Visual Studio solution. Also, don’t forget to set the ‘Template’ option in the Blueprint configuration dialog to ‘None’! Note that we also added a switch statement to our implementation of the Command Extension to only execute the template unfolding in case the ‘INIT’ command gets executed.

With this in place we can write complex ‘vstemplates’, that include WizardExtensions to collect user input and rely on the Blueprints Manager to execute our ‘INIT’ command to unfold these templates when developers add our Blueprint to their Visual Studio solutions.

Does Scrooge exist?

Rob Kuijt — Wed, 26 Nov 2008 11:19:08 -0800

Fiction or reality? On a, further nice, kind of conference meeting, I did met Ebenezer Scrooge!
I didn't know that such Scrooge-type testers do exist!
:-((

Scrooge was fully focused on finding bugs, and if I say fully, I mean FULLY !
Scrooge was completely focused on his own world, collecting as much as bugs as possible, and enjoying it with a kind of scary laughter..... I must say his test results seems to be excellent, very fast in creating test cases, and he knows and uses more test techniques, I ever did. And he has, as we say it, a nose for finding bugs. But his eyes did spit fire when I suggested helping the developers to find the bugs earlier in the cycle. "Why should I destroy my own work" Scrooge replied..... I must confess, I didn't have a response right away. I know that most of the (good) testers enjoy finding bugs. But such a fanatic ego-centric type was new and a complete surprise for me. In fact, I think that Scrooge-type testers, especially this fanatic, are a disgrace for the test profession I love.

So I tried to convince him to change his attitude. Of course I didn't succeed the remaining 15 minutes we met. Probably he needs a visit from the ghosts of the past, present and future!
;-)

For the Scrooges among us
For the Scrooges in the test world I have a message: Finding bugs can deliver applause from your surrounding and it may look that your manager is pleased with the extra test hours (he can send a bigger invoice). But in the long term no one (beside you) is happy with a Scrooge attitude. The business users don't get their systems on time, the developers won't help you if you need them, and if the project manager becomes aware of this attitude, he will kick you out (so your manager can't send any invoice at all). So broaden your small ego centric world! Adopt Application Lifecycle Management [ALM] and find bugs as early as possible in a collaborative driven attitude.

For the non-Scrooges
How do we fight this irritating phenomenon? In my opinion, the best testers are the ones helping (actively) the developers to build better software. Luckily some of the big test gurus of this world preach the same opinion (see the entry measuring testers in the weblog of James Whittaker).

Wild thought
Can we make testers responsible for the quality of the software? For instance: Is it possible to award testers depending decreasing defect rates. I think a kind of Collaboration-bonus awarding mean time between failures and/or decreasing defect rates can work! Has someone a suggestion for the formulation of such a performance indicator or Collaboration-bonus?

I'll look for some like-minded friends and give it a try in the coming period. Im sure this entry will be continued....
And again: Suggestions are very welcome!

Rob

Wat zeggen de experts?

VS2010 TMap Testing Template | Initial Work Items #1

TMap for VS2010 Testing Process Template RC published on Codeplex.

Speaking at Dutch DevDays and Danish ALM Day

Test Tool Checklists - TMAP NEXT DOWNLOADS

VS2010 Architecture Explorer Analyzers

Visual Studio 2010 Team Foundation Server Requirements Management Guidance

Visual Studio 2010 Ranger News

Visual Studio 2010 and .NET Framework 4 Training Kit updated

Visual Studio 2010 Quick Reference Guidance

History of Test Automation

[Dutch] Engineering World 2010

Christmas presents from Microsoft Downloads

Traceability in VS2010

Test Case Design: Manually or Automated?

Article in MSDN magazine got published

More return on development with Application Lifecycle Management

Creating Custom DGML Diagrams using the Progression API

Codecamp is here again

Eclipse and VSTS

“This One’s a Game Changer”

Server Error in '/tfs/web' Application.

Configuration Error

ALM and MBT

ALM: the end of the whispering game

Team Foundation Server basic

Indispensable documentation for Team Foundation Server 2008

Most Valuable Professional in Team System

How to make VSTS DBPro work with the default database collation

Silverlight error messages can be very cryptic or even inappropriate sometimes

Deep dive event at the Microsoft north Carolina office

WSCF.blue Beta 1 is out!

Model-Based Testing is not "Only Fun" anymore....

How to fix Team build Error in TFS2010 “MSTest.exe not found”

Visual Studio 2010 Beta 1: How to fix Worklow designer crash

How to make Layer Validation Diagrams work in the build

Devdays 2009

Architectural Inspections: Implemented in Visual Studio Team Architect 2010

How to enable code coverage in Visual Studio 2010 Unit tests

Windows 7 RC available soon, very soon

Visual Studio Team System 2010 - Episode 4: Quality Check

How to assign a work item to a group and actually have it show a list of values

Hot fix available for Transaction inside receive activity scope bug workflow 3.5

Making money with Application Lifecycle Management

Visual Studio Team System 2010  Episode 2: No Risk No Test

Security update for Team System Web Access SP1

Testing or Documenting?

Blueprints: Visual Studio 2010 (2)

Integrating Blueprints, Layering Diagrams and Architecture Guide

Yessssss, Another year as MVP!

Blueprints: EnableDeveloperFeatures

Blueprints: Visual Studio 2010 CTP

Sticky Notes!

Blueprints: Custom menu filters

Blueprints: Customize template unfolding

Does Scrooge exist?

Visual Studio Team System 2010 Episode 2: No Risk No Test