I wanted to be able to add items to GetPocket.com via my app. To do this in the nicest way possible, it would be awesome to be able to share urls from other apps to my app.

I saw that you can add an OnShareTargetActivated method to your app.xaml.cs where you can capture the ShareOperation.

It looks like this:

protected override void OnShareTargetActivated(ShareTargetActivatedEventArgs args)

{

var op = args.ShareOperation;

}

Information how to implement Share Target Contract without Caliburn.Micro can be found at http://msdn.microsoft.com/en-us/library/windows/apps/xaml/hh871368.aspx

However… I want my Caliburn.Micro!

This question on Stack Overflow (the answer, that is) shows us the MarkerMetro WinRT example. But this is not our default Caliburn.Micro but a fork… I don't want no forks, but the code showed me the way. This is how they did it:

protected override void OnShareTargetActivated(ShareTargetActivatedEventArgs args)

{

// Normally wouldn't need to do this but need the container to be initialised

Initialise();

// replace the share operation in the container

container.UnregisterHandler(typeof(ShareOperation), null);

container.Instance(args.ShareOperation);

DisplayRootViewFor<ShareTargetViewModel>();

}

Basically the point is to unregister the already registered instance if the shareoperation and than register a new one… Unfortunately, the standard Caliburn.Micro doesn't have the UnregisteredHandler method.

So I ended up creating a ShareContext class which has a ShareOperation property.:

public class ShareContext

{

public ShareOperation Operation { get; set; }

}

This way I can register an instance of ShareContext in the Configure method and leave the Operation parameter null.

So here is my code:

protected override void OnShareTargetActivated(ShareTargetActivatedEventArgs args)

{

Initialise();

ShareContext c = container.GetInstance(typeof(ShareContext), null) as ShareContext;

c.Operation = args.ShareOperation;

DisplayRootViewFor<AddByShareViewModel>();

}

A collegue of mine followed this blogpost (http://www.jfarrell.net/2012/11/caliburn-from-windows-8-apps.html) to implement Caliburn.Micro in the WinRT app…

He stumbled upon a problem. The post seems to suggest that you should remove all content from your App.xaml, but then the reference to the resource common/standardstyles.xaml will be missing and the default item templates for pages are going to give you errors.

I followed this blogpost (http://mikaelkoskinen.net/caliburn-micro-for-winrt-getting-started) which prevented that issue… However, I still had a problem with getting a new Basic Page to use my ViewModel.

The problem was the line marked in yellow below:

<common:LayoutAwarePage

x:Name="pageRoot"

x:Class="InThePocket.BasicPage1"

DataContext="{Binding DefaultViewModel, RelativeSource={RelativeSource Self}}"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:local="using:InThePocket"

xmlns:common="using:InThePocket.Common"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

mc:Ignorable="d">

…

<common:LayoutAwarePage>

This line binds the page to a DefaultViewModel and thus overrides the binding that Caliburn.Micro creates.

Hope it will help you avoid or solve these problems…

Here's what I found out the hard way. If you show web content in a WebView control and you want to use the AppBar in the same page (overlapping the WebView) than the AppBar isn't shown. This allegedly also happens to flyouts.

Very annoying. Apparently it has to do with the internal drawing logic of the WebView control. Luckily there is a way around it. As Alex Yakhnin's blog (http://blogs.msdn.com/b/priozersk/archive/2012/08/13/how-to-display-charms-on-a-top-of-the-webview.aspx) suggests you can replace the current content of the WebView with the same content used as a brush on a rectangle and this works as a charm.

So here's what I did:

private void AppBar_Opened_1(object sender, object e)

{

WebViewBrush wvb = new WebViewBrush();

wvb.SourceName = "contentView";

wvb.SetSource(WebViewCtrl);

wvb.Redraw();

WebViewBrushRectangle.Fill = wvb;

WebViewCtrl.Visibility = Windows.UI.Xaml.Visibility.Collapsed;

}

private void AppBar_Closed_1(object sender, object e)

{

WebViewCtrl.Visibility = Windows.UI.Xaml.Visibility.Visible;

WebViewBrushRectangle.Fill = new SolidColorBrush(Windows.UI.Colors.Transparent);

}

And the result is:

It's been a while since I blogged. I have been busy with other stuff, but I'm back…

I am currently building a Windows 8 application for Pocket (http://www.getpocket .com). I want to share my experiences here. It won't be a blog with long posts, but instead I will try and push small messages. They will be representations of my thoughts.They can vary in size.

So, without further ado… Let's start…

(Super cool image copied from: http://inboundmarketing.kohfa.com/blog/bid/241680/Some-Thoughts-on-Website-Redesign)

In a previous post, I talked about the specification pattern. In the last sentence I promised you to keep you posted on the next version of the implementation. I still owe you guys that result. So without further ado:

Download it here.

The implementation itself is pretty straightforward. The class has a protected property Predicate that takes in a Lambda expression that results in a boolean ( a predicate). It is protected so that you have to set the predicate in the derived class.

/// <summary>
/// Use the Specification to make some complex (business) logic explicit. 
/// </summary>
/// <typeparam name="TEntity">The Type of entity that is the subject of the specification</typeparam>
public abstract class Specification<TEntity>
{
     
    protected Func<TEntity, bool> evalCompiled;
    protected Expression<Func<TEntity, bool>> evalExpression;

    protected internal Expression<Func<TEntity, bool>> Predicate
    {
        get
        {
            return evalExpression;
        }
        set
        {
            evalExpression = value;
            evalCompiled = evalExpression.Compile();
        }
    }

    /// <summary>
    /// Use this method to evaluate the predicate for a single item.
    /// </summary>
    /// <param name="item">The item to examine</param>
    /// <returns>A boolean.</returns>
    public bool IsSatisfiedBy(TEntity item)
    {
        return evalCompiled(item);
    }

    /// <summary>
    /// Use this method to filter IQueryables using the Predicate 
    /// </summary>
    /// <param name="candidates">The IQueryable that needs filtering</param>
    /// <returns>An IQueryable that has the added filter</returns>
    public IQueryable<TEntity> SatisfyingElementsFrom(IQueryable<TEntity> candidates)
    {
            return candidates.Where(evalExpression);
    }
}

The usage is simple.

Suppose that there is a business rule that big orders need approval by a manager. Big orders are orders above a 1000 euros. There are 2 cases when we need to know whether an order is a big order. First, when the order is created so that we can send a request for approval to the manager and second in a managers app that shows all the big orders.

The class IsBigOrderSpecification is a business rule made explicit. This rule could be throughout your system. Here’s what it looks like:

class IsBigOrderSpecification : Specification<SalesOrderDetail>
{
    public IsBigOrderSpecification()
    {
        Predicate = (o => o.LineTotal >= 1000);
    }
}

When a new order is created we can now use this specification to enforce the business rule.

SalesOrderDetail orderLine = new SalesOrderDetail();
orderLine.LineTotal = 999;
bool isBigOrderLine = isBigOrderLineSpec.IsSatisfiedBy(orderLine);
if (isBigOrderLine)
{
    Console.WriteLine("LineTotal {0} means this is a big orderline.", orderLine.LineTotal);
}
else
{
    Console.WriteLine("LineTotal {0} means this is a not big orderline.", orderLine.LineTotal);
}

Yet the same specification can be used when querying for these big orders in the system. Because it works on IQueryable<SalesOrderDetail> we get all the advantages of deferred execution.

AdventureWorksEntities db = new AdventureWorksEntities();

var query = from so in db.SalesOrderDetails
                        select so;

var bigOrderLines = isBigOrderLineSpec.SatisfyingElementsFrom(query);

Console.WriteLine("{0} big OrderLines in database", bigOrderLines.Count());

Composite specification

In the solution you can also find the code to create composite specifications. Composite specifications are specifications that have been combined. What if we changed the business rule (the manager is getting to busy) to state that only big orders from sales people that have little experience have to be approved. Little experience has been qualified at working at the company less than 2 years. You probably get an IsExperiencedSalesPersonSpecification.

We are now able to combine the 2 specifications as follows:

bool needsApproval = isBigOrderLineSpec.And(new IsExperiencedSalesPersonSpecification().Not()).IsSatisfiedBy(orderLine);

My opinion is that this specification pattern is quite powerful in specifying and enforcing business rules in a distributed system.

At work we never really had a branching strategy. This resulted in a big branching mess. People were either not branching at all or were making it up as they went along.

Now we have chosen to follow guidance given at http://tfsbranchingguideiii.codeplex.com/. The Basic Branch Plan should work fine for us in most cases. This plan dictates that our branch hierarchy should look like this:

However, our branch hierarchy looked more like 2 separate trees or just a single column like this:

That’s not good.

I came across the option to reparent a branch from: http://social.msdn.microsoft.com/Forums/en/tfsversioncontrol/thread/70eb6d7d-ac81-4de0-a182-89993803b3de

However, when I tried this I saw that I could not select certain branches as a parent to other branches. The solution to this is the same as fixing branches after a migration. Do a baseless merge! This is nicely described in this post,  step 2:

http://www.richard-banks.org/2010/09/how-to-fix-branches-after-migration-to.html

And look at our branch hierarchy now:

For some time now I’ve been willing to find a good implementation of the Specification Pattern. Information about this pattern can be found here:

http://en.wikipedia.org/wiki/Specification_pattern

interface ISpecification<TEntity>
{
	bool IsSatisfiedBy(TEntity item);
}

The idea I had was to use the IQueryable of Linq to query over large collections of objects and get all the benefits of delayed execution.

Recently I came across a blog post by Dennis Doomen who  did exactly that. Read about it here:

http://www.dennisdoomen.net/2010/10/my-silverlight-4-reference-architecture_12.html

That implementation gives me:

public class ActiveRegistrationsSpecification
{
	public IQueryable<Registration> SatisfyingElementsFrom
	(IQueryable<registration> registrations)
	{
		return registrations
			.Where(r => r.Status != AgreementStatus.Incomplete);
	}
}

What I ultimately wanted was an implementation that has both capabilities, to evaluate a single item and to get all items from a collection.

Today I found a very old blog post of Nicholas Blumhardt that did that:

http://nblumhardt.com/archives/implementing-the-specification-pattern-via-linq/

public abstract class Specification<T>
{
	public bool IsSatisfiedBy(T item)
	{
		return SatisfyingElementsFrom(new[] { item }.AsQueryable()).Any();
	}

	public abstract IQueryable<T> SatisfyingElementsFrom
	(IQueryable<T> candidates);
}

However this implementation has a downside as Nicholas Blumhardt already states:

“Unknown performance ramifications of AsQueryable() under heavy usage”

And he is right. The AsQueryable() usage is very slow compared to the normal IsSatisfiedBy method.

My idea to improve this implementation was to make the both methods use a Predicate. Of course this wasn’t all that easy, but after some testing I ended up with this very useful implementation:

public abstract class Specification<TEntity>
{
	protected Func<TEntity, bool> evalCompiled;
	protected Expression<Func<TEntity, bool>> evalExpression;

	internal Expression<Func<TEntity, bool>> Predicate
	{
		get
		{
			return evalExpression;
		}
		set
		{
			evalExpression = value;
			evalCompiled = evalExpression.Compile();
		}
	}

	public bool IsSatisfiedBy(TEntity item)
	{
		return evalCompiled(item);
	}

	public IQueryable<TEntity> SatisfyingElementsFrom
	(IQueryable<TEntity> candidates)
	{
		return candidates.Where(evalExpression);
	}
}

Next on my wishlist is to get a CompositeSpecification so I can combine specifications with And and Or or Negate a specification. I will keep you posted.

Ever tried to do a join on text columns? Like this:

SELECT * from LocationAustralie la 
left join steps s on la.StepText = s.Value 

If your tables have different collations you get the error message:

Msg 468, Level 16, State 9, Line 2: Cannot resolve the collation
conflict between "Latin1_General_CI_AS" and 
"SQL_Latin1_General_CP1_CI_AS" in the equal to operation.

Two of my colleagues had this problem in a single week and asked whether I had a solution. I have…

So here is the solution: the keyword COLLATE.

Just add the collate to one of the columns on the join

SELECT * from LocationAustralie la
left join steps s on la.StepText = s.Value collate Latin1_General_CI_AS

Happy Querying!

Today our team leader asked me to get someone in our team started on a new solution. This entails 2 things:

1. A dev tree
2. Tests and code (and yes, I choose this order on purpose)

The Dev Tree

Suppose you have to make a new solution.

• Create root:
  • $/TeamProject/<SolutionName>
• Create main branch:
  • $/TeamProject/<SolutionName>/Dev
• Create lib & src folder:
  • $/TeamProject/<SolutionName>/Development/lib
  • $/TeamProject/<SolutionName>/Development/lib/Unity
  • $/TeamProject/<SolutionName>/Development/lib/EnterpriseLibrary
  • $/TeamProject/<SolutionName>/Development/src
  • $/TeamProject/<SolutionName>/Development/src/Applications
  • $/TeamProject/<SolutionName>/Development/src/Framework
  • $/TeamProject/<SolutionName>/Development/src/Tests/Unit Tests
  • $/TeamProject/<SolutionName>/Development/src/Tests/Integration Tests

In the ‘scr’ folder you create the solution with the solution name. In the the solution you should create the same solution folder structure as on the file system, just to keep things easy to find. Be careful though, when you create new projects, Visual Studio doesn’t automatically set the project in the same folder as the solution folder you created it in.

Keep your structure in the tests the same as the structure of the ‘real’ projects. So if you have:

Project.Naam/Visitors/PaymentVisitor.cs

Than you should have:

Tests/Unit Tests/Test.Project.Naam/Visitors/PaymentVisitorTests/

Keep your project name the same as the assembly name. So if you have TeamProject.Billing.Framework.dll, your project name should be TeamProject.Billing.Framework.

This would also be a good time to add an automatic build. We use FinalBuilder which is an excellent tool – Dennis did an excellent job explaining why -  and we created a template for making automatic builds. This speeds up the creation process and that should help with the adoption of continuous integration and nightly builds. Generally it should help adoption of a strive towards better quality.

Now add tests and code…

Tests and Code

As far as I am concerned a new solution has at least 1 project: a Test Project. I don’t care that you don’t have any code (yet), as long as you have tests. Why? Having tests, even if they fail or even just don’t build, means you have thought about what it is you have to build to get what your ‘customers’ want. It should be the first project you create. Is this Test Driven Development (TDD)? Maybe. But I like to think of it as Behavior Driven Development (BDD). Personally I think BDD is somewhat easier to do than is TDD, because it gives you a much better starting point for your tests: the behavior requested by the customer. If you want to know about BDD I suggest this presentation by Dan North from about 14 minutes onward. (I suggest you start at the beginning and let Domain Driven Design sink in as well. I think DDD and BDD are a good match.)

I realize that I am going to have to give you an example of where to start. So here it comes.

In December 2009 someone from the sales department comes up to me and says: ‘I finally have everything ready for the price changes for 2010. In 2 days we have to get the letters out to all the customers or we will be to late. Here is the excel sheet with all the data. Oh and when this column is empty we should do blah and when this column has blah we the price should be yada yada yada…’ Right… I think you realize how I felt. I had 2 days to write some tool that would read the data from excel and get out the correct prices for 2010. There was very little time for manual testing by the sales team. They could do this just once. There just wasn’t anymore time. How did I feel? I was  excited! This was an excellent opportunity to use BDD/TDD and find out if it is as good as it claims it is.

First thing I did – after creating the dev tree as shown above - was create the Test Project. Then I started to do some thinking. (Don’t skip this step, it is important!) Every row in the sheet was a single price instance in our system. I created a test called Does_ReturnPrice_When_FedARow.. I admit, the name wasn’t optimal, but I had no clear idea of what I was going to build either. The test had a single Assert statement that verified if a not existent object was of type Price. Needless to say this didn’t compile.

I quickly added a Framework project called PriceChanges in which I added a Linq2Sql model with the Price class and added a class called ‘PriceChanger’ that could act as the ‘service’ that is going to do the work. The method under test was to be

ConvertToPrice(Row row)

I immediately  stumbled upon a problem. It is a problem which has everything to do with control. Control is important if you are writing unit tests. I had little control over the Row instances of Excel. I could have used TypeMock Isolator to gain control, but I think there is something to be gained from keeping your tests simple. So I designed for testability… I created a class called RawEntry and used that as input for the ConvertToPrice method. I could than start writing more tests and implementing the behavior in the method.

Along the way I realized I needed to acces the database to check the existing prices already there. It is hard to test linq2sql queries, for you have to fake your entire model. So I wrote a small Repository which was based on the Repository ScottGu created for MVC in the NerdDinner project: it is simple and easy to fake. In effect I created a wrapper around the operation that was hard to fake You can do the same for ‘supporting services’ if you need to.

In the same way I created a technical service that read the excel sheet and returns a List<RawEntry> and tested that. Writing the actual application in the Application folder was very easy now. It looked like this:

string filename = …

ExcelReader reader  = new …

PriceChanger changer = new …

PriceRepository repos = new …

List<RawEntry> list = reader.Read(filename);

foreach (RawEntry item in list)

{

     Price price = changer.ConvertToPrice(item);

     repos.Save(price);

}

We ran the code against a test database and had the sales department check it. They came back with the following remark: ‘It is all good… really… but we’d like something extra.’ For the extra behaviro we created extra tests and than we adjusted the code of the PriceChanger to implement the extra behavior. This only took about 30 minutes. So within 2 days we created a tool that did exactly what it should and added extra features in just 30 minutes. Tests are great!

var query = from c in Customers
join o in Orders on
new {Col1 = c.CustomerID, Col2 = c.CountryCode}
equals
new {Col1 = o.CustomerID, Col2 = o.CountryCode}
into g
from o in g.DefaultIfEmpty()
select new {c.CustomerID, c.CountryCode, OrderId = (o == null ? null : o.OrderId)};

However, I found another way to do this:

var query = from c in Customers
join o in Orders on o.CustomerID equals c.CustomerID into g
from o in g.Where(item => i.CountryCode == c.CountryCode).DefaultIfEmpty()
select new {c.CustomerID, c.CountryCode, OrderId = (o == null ? null : o.OrderId)};

NOTE OF CAUTION: In the end we decided to turn off the continue on conflict option, because too many conflicts were ignored and the tables got too far out of sync... So the continue on conflict is not such a great option afterall...

Part 1: http://bloggingabout.net/blogs/dries/archive/2009/04/18/repair-a-broken-replication-sql-server-2005-vs-sql-server-2008.aspx

So here's the update: The option to to continue on conflict works fine!

I tested it on two virtual machines that have p2p replication with a test table. Stopped Replication by stopping the SQL agents and then inserted identical rows at all servers. Nothing happened, at least no error.

So I did it again with records with the same id, but different values. That also worked, but the first processed command was replaced by the second value. So both nodes were in sync again.

I decided to go live with it and inserted the missing records from one node in one of the others. No problems at all! 

A note of caution though: Not all conflicts are handled.

On Friday I marked a table for replication that did not exist on the other nodes. This did result in a replication error! Apparently the option doesn’t work for this situation. Well, no worries. I created the table on the other nodes and then the magic option did the rest: lots of conflicts, but no errors! Don’t forget to remove the table from the articles of the publication though…

NOTE OF CAUTION:

In the end we decided to turn off the continue on conflict option, because too many conflicts were ignored and the tables got too far out of sync... So the continue on conflict is not such a great option afterall...

BEFORE YOU READ THIS:  In the end we decided to turn off the continue on conflict option, because too many conflicts were ignored and the tables got too far out of sync... So the continue on conflict is not such a great option afterall...

This is actually a personal note that I wrote down in june 2007.

That day we broke the peer to peer replication across our three servers. But I fixed it without having to restore databases and rebuild the replication.

The bad news: Today we broke replication again. This time the cause was a unique index on 2 columns that was being filled from 2 nodes simultaniously. That is BAD.

The good news: I fixed it.

Last time the replication broke I noticed a list of stored procedures that are responsible for theC(R)UD operations of replication. There are insert, update and delete procedures for all tables in replication and for every subscribing node. So for 1 table there are 2 insert, 2 update and 2 delete procedures.

To fix replication you can tweak these stored procedures to return success even in case of a failure. But be careful! If the databases get even more out of sync that’s even worse!

If a delete or update fails you can skip the error message that the row does not exist on the subscribing node.

However if an insert fails, you will have to write your own check to see if the insert will fail and than skip that insert.

Last friday the support team had a problem with peer-to-peer replication after installing SP 3 for Sql Server 2005. Even the update for SP3 did not resolve the issue. The issue was that every 30 seconds replication claimed that the process cannot allocate memory, although it was still replicating.

So with replication in a fault state and a wish to upgrade to Sql Server 2008 in the near future the support team decided to upgrade now and hope that that would fix the issue. Well… needless to say… it didn’t.

Non of the support people know how to set up replication, so I ended up doing it. The first time it all seemed to work, tracers worked fine and arrived after about 3 seconds. But the moment I started some of the processes replication failed.  That was a set back, because now the databases were out of sync…  I decided to ignore the fact that the databases were out of sync and set up replication all over again. I could do this, because I was and still am sure that these missing records on two of the nodes aren’t going to give us problems.

With a situation like this I would have had to spend at least a day to get back in sync.

As far as this article - http://technet.microsoft.com/en-us/library/bb934199.aspx - on technet claims: Once I turn on the option to continu on conflict, I do not have to manually change all the stored procedures to continu on conflict. If that is true it will save me a lot of time! First thing on monday I will try this on a test environment before I will use this on the production server.

I will definitely let you know how this went!

Something really annoying happens in Visual Studio when I debug my tests. No tests run, because of a test run error:

Code coverage collection error: The Visual Studio performance and coverage logging engine is already running on the computer. Therefore, the test run cannot continue. Close the pending performance or code coverage session and then rerun the tests.

I open up the Task Manager and there is VSPerfMon.exe which is causing the problem. End the process and everything is fine again. But why won’t it shut down?

Well the reason for that  is that I stop debugging my tests while they are still executing. Let them run and fail and there is no problem.

I had a problem today. My ASP.NET Development server wouldn’t start because the specified port was already in use. The port number was 50678, so it wasn’t very likely that it actually was in use. But I decided to check anyway. But as expected ‘netstat –a’ gave me no results for port 50678.

Restarting VS or my PC didn’t help….

It had to be some sort of firewall issue then. So I turned of Windows Firewall, but that didn’t help at all. Weird stuff.

Some searching on the net brought me to the following question and the answer from Macros:

http://stackoverflow.com/questions/607562/visual-studio-development-server-using-wrong-port

And (mostly for my own reference) here’s the management summary:

• the cause: NOD32 is blocking the ASP.NET Development Server.
• the solution: configure NOD32 to no longer see VS as a web browser. (setup -> advanced firewall setup -> antivirus & anti spyware -> web access protection -> HTTP –> webbrowsers)

Hope it helps you as well…

An exhausting day at PDC... Here are the sessions that I did:

• Keynote: Windows Azure

• Microsoft Visual Studio Team System: A Lap Around VSTS 2010

• ASP.NET 4.0 Roadmap

• Team Foundation Server 2010: Cool New Features

• WF 4.0: A first look

I really love the new features of VSTS and TFS; I can hardly wait to start using them...

I will not go into a lot of detail here, instead I will highlight a couple of the main features and hope it will incourage you to go and view the session online.

Microsoft Visual Studio Team System: A Lap Around VSTS 2010

Cameron Skinner put it real nicely with 4 key points all getting rid of things we do not like as Developers. VSTS 2010 is focussed on making the developers happy...

No More 'No Repros'

Basically focusses on getting more complete data from the testers to make it easier to sea where/why/when a bug occured. What do you think of a Manual Test Runner with a recorder to capture a video which can be viewed by the developer? Or what about a System Info tab in the workitem? Or a Debug History window, where you can 'debug' the code on the server from the nightly build as if it were happening live?

These things really are going to make the developers life a lot easier.

No More Broken Builds

This is a developers dream come true: being unable to break the build. No more buying cake for the team...

Made possible by:

Gated Check-in, which is more a TFS feature than a VSTS one but who cares. If set up on the server, you cannot check in changes if these changes break the build.

Test Impact Analysis, which is a feature that analyses a changeset to see which test is most likely to be affected by the change, so you can start with that test.

No More Butterfly Effects

This is all about preventing code rot.

Builds may fail by a violation of your architectural design. You can make a .layer diagram and the actual solution is tested against this design.

The Architecture Explorer generates a diagram of the actual architecture of the solution and you can drill down into great detail in the diagram as well as jump to the code.

A sequence Diagram can also be created, making it easier to see where the butterfly might cause a storm.....

No More Regression

There is a new kind of test: The CodedUI test with a recorder for Web and it will be there for WinForms as well as WPF. Silverlight is regretably not planned yet.

Team Foundation Server 2010: Cool New Features

Protect Code Quality

Gated checkin

Buddy Builds or private builds: run on the server but without checkin

Workflow based build creation. Basically something like finalbuilder.

Parallel build tasks

Parallel Development

Branches have become real entities instead of folders and they are hierachically linked. The relations can be viewed visualy as well.

You can track changesets, workitems and annotations through merges; again with diagram.

Rollback is finally here..

Managing Projects

New excel workbooks, excel report generation from Query.

Workitems link and hierarchy improed

Query improvements