So I splurged recently and picked up one of the new Western Digital 300GB SATA VelociRaptor drives. I also happened to be in Las Vegas, and there was a Fry's nearby. I think that was the cause, and the effect was me ending up with the drive, but I digress. Every so often, I wonder how fast my various 5400, 7200, and 10000 RPM drives are, especially taking USB 2.0 and ESATA into account. I downloaded the latest version of HDTach and went to work with my not-very-scientific performance tests:

  Hardware used: Dell D820 laptop, 4gb RAM, Windows XP/SP2

BTW - the numbers in bold make me happy, and here's the graphic that went along with the final test (the VelociRaptor drive):

I taught another week long class on Team System last week and as always, I learned a lot. It's a definite truth that if you want to learn about something, teach a class on it.

The other thing about is that each client you work with is looking to solve a different problem and you get introduced to new scenarios when you work through the "How can I solve that problem" discussions. This week included a lot of those types of discussions, and I therefore had to dig a bit.

What pearls of wisdom did I come away with?

1. There is no apparent command line tool or GUI tool to get ONLY the files that changed as part of a change set.
   
   Scenario: I have files A, B, and C in a folder, and I change file B as part of change set 43. When I do a get (tf.exe get 43) I am going to get all 3 files.
   
   What to do if I only wanted the delta (file B)? Well, there's a freeware utility waiting to happen.
   
2. In TFS 2008, I can create a new Team Project and as part of that installation, I can choose to create the new source control library as a branch of a code line in another Team Project.
   
   What happens to the history in case I delete Team Project A, which was the head for Team Project B's branch in SCC? Well, Team Project B just became the head.
   
3. There is a PowerTool set for the Database Professional SKU (now packaged with the Developer SKU) that adds T-SQL code analysis. Maybe this will cut down on:
   select * from customer

I attended Seattle Code Camp 2008 in Redmond this weekend and it was a fantastic experience! I will definitely be back next year.

This is certainly not the largest Code Camp out there, with only 125 attendees at the peak over the weekend, and the after party was a simple affair in a room on the MSFT campus. It wasn't the frilly stuff that mattered, it was the content and who was giving it.

It was not uncommon for the presenters to be either the guy who wrote the book on the topic, or the guy who actually made it! We were a stones throw from the MSFT campus and one example of the proximity effect was the fact that in Steve Borg's talk on Ruby, John Lam was sitting in the audience. No pressure, Steve.

In fact, I found myself at dinner talking to someone about Enterprise Library and it turns out I was talking to Chris Tavares. You know, that Chris. The lead developer for EntLib in P&P and the guy who write Unity? Look for an Elegant Code Cast soon, folks.

And thanks to Chuck Sterling for the good tips on the VM configuration for the laptop. I am going to try one better and go for a SSD external. We'll see.

My Sessions

I did 3 talks in all, one of them rather spontaneous. I think they went great, and I had a great time talking to people. Everyone seemed to enjoy the sessions. This link goes to a ZIP with the materials from all of my sessions.

1. TDD with WCF Services
   This is talk based on a HOL I wrote for the Connected Systems Division at MSFT a few months ago. We spent an inordinate amount of time looking at mocking as a tool and got a little sidetracked on it. That was fine with me, because it was what the people in the room wanted.
   
2. Agile Estimation Techniques
   In this workshop, we basically learned and practiced planning poker. I was convinced no one would even be there. I was up against Ted Neward, after all. Turns out, I had almost 30 people and received a lot of compliments on the workshop. People really seemed to get a lot out of it.
   
3. Silverlight 2 for Developers Who Don't Do Web Apps So Good and Want to Do Other Stuff Good, Too.
   I did this talk on Silverlight after learning Saturday night that the real Silverlight experts weren't going to show on Sunday. So, I went home and hit refresh on my Silverlight demos and did the session at 9:00 AM Sunday. People seemed to enjoy it.

Hope to see you at the MSDN event in Boise this afternoon. I am doing a session on Silverlight in the IMAX theatre and other topics include VSTO and SQL 2008.

C'mon over at 1:00 for the afternoon.

I am in the TFS 2010 cool features talk at PDC with Brian Harry. I'll stream notes into this post, but please be aware that this discussion focuses on Team Foundation Server, not the full compliment of tools that make up Team Suite.

Also important to note is the significant size of this release. True to form for any given significant software product, version 3 (in this case 2010) is a tremendously significant release. Team System is a good example. The 2010 release will be HUGE. Brian Harry notes that it takes about 8 hours just to demo all the new features.

OK, onto the conference bullets you have come to expect from my fly-by conference posts.

• There is a high degree of focus on improving the story of TFS for large enterprises. This is a little conc
• Team Build
  • Gated Builds
    • Gated check in allows a build to run and tests to pass BEFORE the check-in is committed to the SCC tree.
    • New Build Definition | Trigger | Set as Gated Build
  • Build Agent Pooling
    • Define a pool of build machines instead of individual build servers. This feels a lot like pulling your build machines from the cloud.
    • New Build Definition | Build Defaults | Build Agent Properties.
    • Wow, this is impressive. I can configure multiple build agents per machine.
    • Build agents may be tagged with their capabilities. This allows a build definition to say, "Only build on a build agent running on this OS, or with this COM DLL installed, etc."
    • Can specify a collection of Test Lists to run as part of the build definition.
  • Build Workflow - Wow
    • New Build Definition | Process
    • Define the build in a visual designer with customizable targets. Think Final Builder here. No it isn't all the way there, but this is a nice start. It is basically a visual editor for the team build script.
      • EX: Copy Outputs to Drop Location.
    • Parallel Activity: Allows me to build 2 different ways on 2 different build agents (among other things). For example I want a single build definition to build for Debug and one to build for Release, each build occurring on a separate build agent. Done. And I only labeled once. Nice. And each one has its own drop location (of course).
  • Retention Policy: Define what will be deleted when a build fails: the bits, label, the test reports, etc.
• SCC
  • Rollback. Thank you.
  • Branches are first class citizens. Not just another folder visually. Nice. Branches have lots of meta data on them.
  • Annotate now tells me what branch a merged change came from. This is a big deal for many regulated customers.
  • I can see the history of a change set across many merges to see where it really came from. This is cool, but Track Change Set actually shows me a nice visual graph of how the branches relate to each other in time and as parent/children. Sweet.
  • This trend of visually modeling information is powerful and promising.
  • Viewing a conflict no longer results in a modal dialog. Now conflicts are seen as pending changes, which allows me to iterate through them and examine code while looking at the conflict item itself. Handy.
• Work Items
  • Linking them together is no longer horrible.
    • AND THE RELATIONSHIPS ARE HIERARCHICAL!
    • Hierarchical Work Item relationships.
    • Hierarchical Work Item relationships.
    • And round tripping through MS Project works. Yes!
  • New Agile process template. This is no longer MSF, and by golly it just might work.
  • Rich text formatting capabilities in all text area type inputs on work items now.
  • Excel integration in much nicer, showing hierarchies and allowing a persisted worksheet to hook back up to TFS cleanly.
  • I can query against hierarchies. The sample query was "Show me all User Stories with no associated Test Cases." There is a lot implied in that query and all of it is goodness.

That's a lot of bullets, but it's a big product. This set likely doesn't scratch the surface of what's coming, but it does show that the product team is addressing many of the most painful things that team's deal with today.

Boise area .NET folks have no shortage of community events these days and November is shaping up with some particularly good gems. These events are free to attend and you get to mingle with same jovial crew you know and love from your favorite user group meeting (ok, that was a stretch).

Thursday, November 06
MSDN Event - Silverlight 2.0, SQL Server 2008 and VSTO
This half day event looks at the 3 technologies named in the title. Good stuff, that. I did my duty with VSTO last time, so I appreciate that this time around I will get to look at Silverlight 2.0.

Thursday, November 13, 2008
Boise MSDN Unleashed
This should be a good event looking at some of the unveilings that inevitably come out of PDC as well as going deep (way deep) on SQL Server 2008.

At a client site this week, and having to generate the same initial folder structure for many team projects, so I thought I would create a script (.BAT file, no PowerShell sorry).

Below is the script, but here are a few details to point out:

• I assume that my workspace name and local folder name is the same as the team project
• I put my local workspace folders under a common D:\Workspaces folder
• You can set the team project name easily by tweaking the SET line below
• I could have, and should have parameterized the folder root, TFS, comments, etc.

Hope you can make use of it:

@ECHO OFF

SET TeamProject=Sample

ECHO Create folder Structure
ECHO.

D:
CD\
MD D:\Workspaces
MD "D:\Workspaces\%TeamProject%"
MD "D:\Workspaces\%TeamProject%\Code"
MD "D:\Workspaces\%TeamProject%\Code\DEV"
MD "D:\Workspaces\%TeamProject%\Code\QA"
MD "D:\Workspaces\%TeamProject%\Code\PROD"
MD "D:\Workspaces\%TeamProject%\Documents"
CD "\Workspaces\%TeamProject%"

ECHO.
ECHO Drop existing workspace
ECHO.

"C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\TF.EXE" workspace /delete /noprompt /server:TFSSRV1 "%TeamProject%"

ECHO.
ECHO Create workspace mapping
ECHO.

"C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\TF.EXE" workspace /new /noprompt /computer:TFSSRV1 /comment:"Created by Richard Hundhausen" /server:TFSSRV1 "%TeamProject%"
"C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\TF.EXE" workfold /server:TFSSRV1 /workspace:"%TeamProject%" /unmap $/
"C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\TF.EXE" workfold /server:TFSSRV1 /workspace:"%TeamProject%" /map $/"%TeamProject%" D:\Workspaces\"%TeamProject%"

ECHO.
ECHO Adding folders to version control
ECHO.

"C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\TF.EXE" add Code /recursive /noprompt
"C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\TF.EXE" add Documents /recursive /noprompt

ECHO.
ECHO Check in
ECHO.

"C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\TF.EXE" checkin /comment:"Created by Richard Hundhausen" /noprompt /recursive "D:/Workspaces/%TeamProject%"

PAUSE

Download the MP3

On this episode of the Elegant Code Cast, Glenn Block tells us about life inside Microsoft for the ALT.NET crowd. Glenn has been with Microsoft for several years and has worked in several departments during that time, trying to bring the ideals of ALT.NET to the company. His experiences in MS Learning, P&P, and now in the framework team, make for some great stories.

In addition to Agile stories from inside the mother ship, Glenn spreads the good word on MEF.

This discussion should finally draw the curtain on the idea that ALT.Net is anti-Microsoft.

By now I you've likely heard the term ALM. For the uninitiated, here is the latest from Wikipedia.

Application lifecycle management (ALM) regards the process of delivering software as a continuously repeating cycle of inter-related steps: definition, design, development, testing, deployment and management. Each of these steps needs to be carefully monitored and controlled.

Does this sound familiar? It should. This is YAW2QH2DS (Yet Another Way to Quantify How to Deliver Software). This smacks of other big acronyms you may be familiar with like CMMI or *UP.

I don't mean to trivialize this with curmudgeonly developer attitude. The idea of measuring our organization's maturity level in the software delivery craft matters. It matters because successful small companies typically get bigger, and the challenge to every one of these organizations is how to stay successful as they struggle with issues of scaling up. It matters because it isn't good enough to compile and run software. It needs to work well, solve a good problem, and actually be delivered into the hands of users.

Measuring our organization's mastery of delivering great software is also important for organizations needing to get back to a good solid quality baseline. When things get big quickly without a control mechanism (companies, code bases, my belly, etc.) they trend toward entropy. ALM maturity can help provide that control mechanism.

Don't take that the wrong way. It am not saying, "Let's use a manager's tool to measure and manipulate those pesky developers."

Quite the opposite, what I am really saying is closer to, "Imagine never having to explain to management that unit tests are a good thing and worth the effort."

If we have a common reference for measuring our collective skills, we can agree collectively that we can improve in certain areas.

What if (brace yourself) the framework itself (the one your CIO bought off on) required that unit tests, measured code coverage, automated builds, and automated testing were present in your delivery cycle on order to be level 2? Now we're cooking with a little more gas, eh?

Microsoft and ALM

So, guess what? Microsoft makes tools for software developers. Big news, but there are lots of tools that others in your organization use to complete the delivery cycle: System Center, MS Project, Project Server, Portfolio Server, etc. These are the tools used by people in your company up and down stream of developers in the delivery lifecycle. Go ahead and resent them, but wouldn't it be nice if these things were used well and worked more cohesively with your tools?

There isn't a terribly cohesive story when flowing things between these tools (phases of the ALM cycle) but they are getting there. The real value here should be:

• Tools that are frictionless to their primary users.
• Tools optimized for the specialist using them. Whether this is developers, project managers, program managers, IT helpdesk, system administrators, developers, or testers.
• Tools that seamlessly integrate, allowing passing the products of these tools between each other.

Obviously, Microsoft has a strong story for these tools as individual solutions. In the last few years, Microsoft tools have actually started to integrate more easily and this is why. Integrating them up and down stream to complete the ALM story will be a significant effort going forward. The Visual Studio Team System story is a particularly strong start for Microsoft in pursuing an integrated ALM line. The effort is underway to integrate the ALM story across all disciplines.

It's Not Just a Tool Story

"Great," you're thinking. So this is a part of world domination through tooling? Not exactly. The fact is that the tools themselves are being built these days to embrace many different processes or methodologies (read TFS Process Templates here). Project Management tooling is certainly due for an overhaul, but System Center has some shiny newness that is heading in the right direction.

As long as the base tools themselves continue supporting extensibility hooks, the community should be able to plug and play as desired. The key will be in getting full integration supported in the community tools. As an example, we really should put in the hooks for nUnit to integrate with Team Build for integrated reporting.

The bottom line here is the tools are getting more extensible along the stack as well. This means that we should be able to support any wonderful, decrepit, promising, or ill-advised silver-bullet process or technique that comes along. "Now don't that make you sweat chickens", my dad would say.

The ALM Maturity Model

So what about the model itself? Exactly what is this all about?

The basic ALM model endorsed by Microsoft includes the following Practice Areas.

• User Experience (UX)
• Requirements Management
• Quality & Test
• Code Quality
• Architecture & Design
• Project Management
• Software Configuration Management
• Deployment & Operations
• Data Management

What I like about these areas is that it doesn't really matter whether you are a waterfall-driven Inicorp Employee or dyed-in-the-wool Agilista, these Practice Areas can typically be agreed upon as important. We can also all agree that being mature (read: competent) in these areas is important.

How mature are you? Microsoft provides an online survey for evaluating the ALM maturity in your organization where you can see a measured range of maturity for each Practice Area and specific competencies within each area.

Think about the questions you would ask to gauge competency in these Practice Areas. I was surprised to learn that the online survey asked many of the same questions I would have asked. Nice.

So?

So, what's the big deal and why is this different? I find a couple of things interesting.

• Several tool vendors are embracing similar ALM models, not just MSFT.
• CMMI is so 8 years ago.
• It's not about tools. It is about tools that support the business we need to do.
• There's a boatload of money coming behind this. Your executives will hear about this. This ALM TLA will come up in a meeting.
• This framework actually embraces, rather than eschews, Agile Software Development practices. Seriously.
• It gives your department lead something to brag about when you write unit test (don't undervalue this one).

This has a chance. This has a chance to actually improve the craft and to improve the bottom line at the same time, and that's a powerful combination.

The Seattle developer community is holding Seattle Code Camp November 15-16, 2008 at the DigiPen campus in Redmond, Washington (close to Seattle). Please pass this notice on to folks you think are interested in either attending or speaking. Speaking of speaking, they are looking for speakers. If you hit the code camp site, you will see that they don't have sessions or tracks listed at this point. This 'camp is a blank page at this point that needs to be colored in - which is a great venue for presentations. If you have something you are passionate about but have never done any public speaking I encourage you to give it a try. If you are an experienced speaker, this is your time to get involved in your local community and share some of your experience.

What types of topics are they looking for?  Pretty much anything goes as long as (A) it involves code, and )B) It isn't a direct advertisement for a product or service. This means that this isn't limited to .NET or even Microsoft technologies. Past 'camps have included sessions on XBOX 360 development, Java, PHP, Delphi, and Rails. Submit your sessions here. Alternatively if you have no desire to get up in front of a bunch of developers and impart your wisdom, they could still use your help. Please promote this code camp at your user group meetings, post it on your blog (like I did), email it to interested locals and encourage your friends and coworkers to submit sessions.

Finally if you plan on attending please register so that we can get some idea of the required space and food needs.