It’s a wrap!  PDC is all over for 2009 and now comes that hard part where you have to gather your thoughts, not get scared by just how wide development is these days and that you can’t learn it all, then try and remember and imbibe everything you saw so that it’s there in your head and ready to be called on whenever the need arises.  That’ll take at least a few days I think :-)  Personally, I had a great time at the conference, I learned quite a bit about what’s coming up next and met quite a lot of people I wouldn’t have had a chance to meet face to face otherwise. I also really enjoyed tweeting what was happening so that those who couldn’t make it could at least get some idea of what was happening (apologies if you though it was more like tweet spam!)

So let’s get to it.  Here’s my thoughts on the sessions I went to today…

Web Deployment Painkillers: Visual Studio 2010 and MSDeploy

Currently I tend to automate deployment using TFSDeployer and Powershell scripts, though obviously not everyone has TFS and not everyone wants to install team explorer on their target machines so MSDeploy is a really good move for Microsoft and fills a hole that has been growing larger and larger over recent years.

In a nutshell MSDeploy allows you to package up not only the content needed for a web site, but also the IIS settings, the database scripts, and the specific web.config settings needed for the target environment.

The initial demo’s showed deployment happening from a developer machine from within Visual Studio which really made me cringe, but thankfully Vishal Joshi moved on from there to showing how to do the deployment in a much safer way – i.e.creating a deployment package after a build server has built the app and all the tests have been run, giving this package to the server admins and allowing them to run and control the deployment of that package.  I wish that the Visual Studio team would just remove the deployment tab from all visual studio projects once and for all and leave us with just the “package” option.  The world would be a much safer place.

Deployment to servers is pretty well done, featuring a GUI interface in IIS7 and a command line interface for both IIS6 and IIS7.  Basically you open the package, and run the included batch file to trigger the deployment.  If you want to control the deployment you can pass options into the batch file to change it’s default behaviour.  My only concern/question here is why use a batch file!!? Surely everyone is moving to Powershell?  Isn’t that the direction of all the server and platforms teams?  It seems like such a backward step and glaring oversight in the packaging process.

Now one thing that I did think was quite cool and that I hadn’t seen yet was the way you control web.configs for deployment.  It’s done via a base web.config that everyone develops against and then you have web.debug.config, web.staging.config, etc files (one for each deployment environment) which Visual Studio nests under the main web.config file.  These environment config files are actually smaller XML files written to be merged with the main web.config file to produce the end result that you desire.  This is done using a new technology called XDT – XML Document Transforms, which is so much more approachable than XSLT for the basic add/remove/find & replace tasks that are required for doing this.

You simple take your web.staging.config and add to it elements that are decorated with attributes such as xdt;Transform=”RemoveAttributes(debug)” or xdt:Locator=”Match(key)” etc.  More information can be found on the MSDN site.

Finally Vishal mentioned that on click publishing (part of the MSDeploy process) can be trialled for free at a number of hosting providers – http://bit.ly/DiscountASP, http://bit.ly/OrcsWeb, http://bit.ly/MaximumASP, http://bit.ly/AppliedInnovations. You can even run live .NET 4.0 sites on these accounts if you want.  Cool! ;-)

Microsoft Visual Studio Lab Management to the Build Setup Rescue

This session was presented by Vinod Malhotra and I think was aimed at a 200 level audience.  Vinod gave a reasonable overview of the features but didn’t do that great a job at explaining how it all fit together and I found the pace fairly slow, especially as he let the audience ask too many questions mid presentation breaking the flow quite jarringly.  I ended up a little annoyed and frustrated at this since we didn’t seem to be getting to anywhere.  I ended up tuning out for most of the session.  Oh well.

by the way, lab management is itself very cool stuff.  The ability to take a whole bunch of hyper-v machines and snapshot them, restore them and control the environments in them without needing a much more than a few clicks of a button is very cool and really facilitates testing on more than just the standard specs you may work with.  Being able to take coded UI tests and run them automatically against specific environments is very cool.  Having these environments available to testers for exploratory testing is very cool.  I’m actually fairly excited by the lab management stuff, so don’t let a disappointing presentation turn you off – it’s well worth investigating.

Building Extensible Rich Internet Applications with the Managed Extensibility Framework

Apart from having a really long title this was a good session, presented by Glenn Block.  I’m going to assume you know what MEF is – if you don’t go find out.

Glenn did a good job of pacing things well, presenting not only the basics of MEF but also some of the more advanced usages such as those where you want to have strongly typed metadata provided by parts so that you can filter them in your applications, one line of code part initialization for Silverlight, the use of lazy loaded parts and dynamic recomposition when loading extra XAPs at runtime.  Good stuff, and something that if people use it, will really improve the architecture model and deployment story for silverlight applications..

He also brought up onto stage a few others (I didn’t get their names) to show how MEF and Prism can work together, and how MEF can also work in Moonlight (the linux port of Silverlight).

Scrum In The Enterprise and Process Customisation with Visual Studio 2010

This session, presented by Simon Bennet and Stuart Preston was effectively a presentation on what’s coming in the Scrum For Team System template, version 3.0 with an insiders view on how it all hangs together and what needed to be done during the customisation process.

The important things to note:

  • The template will support Microsoft Test and Lab Manager (MTLM)
  • It will use hierarchical work items and has specific linkages you should use between work item types to get the benefits of the reporting.
  • It supports “enterprise scrum”, where multiple teams work off cycle to each other on different length sprints, with different work streams, with multiple product owners, and multiple releases.
  • It supports the concept of a “ready for planning” product backlog – i.e. one where all the product backlog items have information such as business value and have been estimated.
  • It has a focus on including acceptance testing into the process and you can link acceptance tests to product backlog items for full requirements tracking.
  • Bug management is also tied more closely to product backlog items now, so for example when a PBI that is done gets a bug reported against it (say when an acceptance test fails) it’s state is changed to “Broken”.  If the test is broken because the requirement is no longer valid then the requirement can be marked as “Deprecated”.  Why does this help? Because at any time you can run a report and see from the “Done” product backlog items just what functionality is in the product.
  • We can expect a beta 2 version of the template towards the end of November or early December.

Automating “Done Done” with Visual Studio 2010 and Team Foundation Server 2010

Well, the proper session title was actually longer than that, but it just starts getting ridiculous when it takes longer to read a sessions title than it does to present it :-)

This was presented by Jamie Cool and Brian Randell and was a great way to finish PDC.  It turned into a 200 level session that basically walked through the creation of builds in TFS, the use of gated checkins, test automation from both a unit testing and functional testing perspective and then the deployment and running of the coded UI tests on MTLM.

The pace was excellent, the presenters did the straight man/funny man thing really well and also got through all the content they had planned.  For those in the room who were there just to see what “done done” meant I think it would have been eye opening.

I was hoping to see a little more about how they do things when they want to change the done criteria to things beyond automated deployment and passing acceptance tests, such as quality metrics, etc but I’m demanding like that, and even so they certainly showed to get from “works on my machine” and “deploy to production from the developers machine” to a much more stringent and higher quality practice of using build servers and automating acceptance tests.

It was a great session and may well have been my favourite of the conference. Well done!

 

And that is that.  If you’ve been reading the blog over the past few days or following on twitter, then thanks for sticking with me.  For now though, I think I need a sleep :-)