Reasons to do this vary, but the reason I have is that I like using the Scrum for Team System process template as a Master or Enterprise backlog and holding all work items in there. For that Team Project, I have no source control, as it is just for Work Items. Correspondingly, I need Team Projects that have no work items in them.

There are several ways to pull off a “Source Control + Build Only” TFS Team Project.

1. Create a Process Template with no Work Items, Queries, or Reports in it and install it on the server to create new Team Projects. I have done this and it works.
2. Spool up a Team Project using an existing Process Template . Lock down permissions on the Team Project to not allow any new Work Items to be created by anyone. This works, but is a bit ghetto, IMO.
3. Spool up a Team Project using an existing Process Template and then pull out everything you don’t want.

This article will demonstrate how to accomplish #3.

Killing Everything But Source Control and Build

This example uses the MSF for Agile process template as the basis for the Team Project we will customize.

Creating the Team Project

1. Create a Team Project as normal.
2. Open Team Explorer

Delete the Queries

1. Open PROJECTNAME |Work Items | Team Queries
2. Highlight all the queries
3. Right click | Delete

Delete the Reports

1. Open PROJECTNAME |Reports
2. Highlight all the reports
3. Right click | Delete

Delete WI Type Definitions

Here we need to use the Team Foundation Power Tool available here. Ensure it is installed on the server and the machine you are working on to execute this work.

Create a .cmd file with the following commands in it, supplying your own params for the correct server and team project:

tfpt destroywitd /server:http://tfsrtm08:8080 /project:PS_SCC /workitemtype:Bug /noprompt

tfpt destroywitd /server:http://tfsrtm08:8080 /project:PS_SCC /workitemtype:"Quality of Service Requirement"  /noprompt

tfpt destroywitd /server:http://tfsrtm08:8080 /project:PS_SCC /workitemtype:Risk  /noprompt

tfpt destroywitd /server:http://tfsrtm08:8080 /project:PS_SCC /workitemtype:Scenario  /noprompt

tfpt destroywitd /server:http://tfsrtm08:8080 /project:PS_SCC /workitemtype:Task  /noprompt

Run that sucker!

Now, when I try to add a Work Item in the Team Project, this is what it looks like:

Notice there is no option for creating a new Work Item. It simply vanished!

I like to leave the ability to create queries because teams will often create queries looking back the Work Items in other Team Projects and simply use the SCC only project as a means of isolating their queries.

Ever notice that no matter what shenanigans Beaver would get into, June always believed everything was fine? No matter how many scotches Ward had after dinner, there was no problem, according to June. June Cleaver is the classic enabler with a bad case of denial.

So is the TFS Source Control Shelving feature.

Don’t get me wrong. Sometimes everything really is okay. Sometimes I just want to push my code into a shelf set because I have to go to my kid’s play in 5 minutes and I just want to make sure I am backed up in case the building burns down in the next 2 hours. Sometimes.

More often, Ward is shelving his code because he hasn’t checked in for 3 days and can’t be bothered to do the necessary merges before he heads home to that scotch bottle.

I would go so far as this: Frequent shelving is a smell.

Reasons you don’t need shelving include:

1. Team members are checking in frequently as they make changes to code, passing tests and keeping code coverage high. Frequently means every few passing unit tests or so.
2. Team members are in the habit, nay, are required to check in the day’s work and get a clean build before they go home for the day.
3. When a team member is looking for a code review, that person has direct (as in “within voice range”) access to other team members who can perform said review. Even better, they are pairing.

   Note for distributed teams: Microsoft’s SharedView works great for remote pairing.

I find it best to think of the Shelving feature as SkyDrive for source code. It isn’t sufficient as a source control strategy, but can be pretty handy on occasion.

One more way that Shelving is like June Cleaver? Pretty. Not smart.

ALM is the enterprise software development holy grail that IBM sought for years and invested in with the Rational tools. And although there is a tremendous value in prescriptive guidance in enterprise development models, there is a natural tension between the ALM crowd and Development as a Craft advocates. ALM, after all, is all about quantifying, measuring, predicting, planning, and economies of scale. Ironically, the kind of transparency and predictability called for by the minimalist Agile community is the same goal of ALM tooling offered by Big Blue and now by the new blue in Redmond.

How are Microsoft products staged to lay across the ALM model? The story today is mixed.

Your familiarity with these products may lead you to the same conclusion that many have already reached. The products in the stack currently fail to integrate cleanly and many provide only a starting taste of the functionality needed to realize the ALM vision. The story is obviously a little muddy today. But what’s next?

Team System Rosario promises much improvement in the areas of tracking, design, quality assurance, and development. Significant bridges are also being started toward improving the release management story.

That won’t do it all, of course. There are other pieces needed in the stack that will need to be freshened up including operational support tools. Microsoft is in hot pursuit of filling this gap with a host of products under the System Center umbrella of products. An actual helpdesk management system to displace the TechExcels and Remedys of the world is essential here.

The point is, MS has its sights set on a complete ALM story and are focusing on the midsize market, as Microsoft is so good at doing.

The Good

A focus on ALM in the Microsoft stack will have a tremendous impact on software development and delivery as we know it. Interoperable components in the pipeline will help bridge those gaps in midsize organizations that are typically only filled in large enterprises. Transparency will be ubiquitous.

Given the open nature of products being developed at MS these days, I have high hopes that these systems will truly be pluggable, so that if you want to bridge TFS to Remedy (for example) doing so is not rocket surgery. Web services are great, aren’t they?

Concerns

There is a fine line between managing for predictability and ‘command and control’. Tools like those in this stack are like guns. They can be used for good, but misuse is more common than not.

Tooling like this gives every non-tool Agilist out there genuine pause, and with good reason. The history of stewardship in complex models like this is less than stellar. That is to say, this tooling can provide huge value, and the basis for crushing souls. Let’s be careful how we wield them.

• Simplified the user experience through cleaner “Add to Source Control” dialogs, drag and drop support to the Source Control Explorer and a much easier to use “Workspace” dialog for working folder mappings.
• Version control now automatically supports non-solution controlled files.
• Various changes to the Source Control Explorer such as a new checkin date/time display column, local path hyperlink support and en editable source location field.

I am not a big fan of installing a beta SP on may dev laptop, but I gotta tell ya, I did it for that feature alone.

Go here:

And get this screen.

Why? Because if you have made some changes to a file while it wasn’t checked out, you will not have the option to merge to your local machine. This option will simply overwrite your local code file.

Why does this feature exist? Because oodles of people asked for it because they were used to it in Source Safe, and the team relented.

Repeat: This is a bad idea!

If, however, you are a person who simply must have this turned on in order to feel snug, there is a way to do it without making your entire team experience the hell that will be yours.

In Visual Studio, go to Tools > Options > Source Control > Environment and do this:

I warned you.

We know that the modeling tools in Team System 2008 are, well… there’s room for improvement. How valuable is a Logical Data Center Design Model when we can’t derive it from a reverse engineering action? There has also been much frustration with the lack of standard UML support in Visual Studio. Guess what?

Rosario proposes that we promote modeling to a first class citizen of the complete Application Lifecycle Management model. Here’s my major takeaway: The way modeling is being supported enables visual exploration of your code base in a way that is seamless with the development process. This can honestly change the fundamental code development experience.

Also, I can plan on sun setting all my organizations Sparx licenses. Cool.

• UML 2.1 at the logical layer
• DSLs at the physical layer
• Generate models from existing assets. This is being discussed as “Architectural Discovery” which is a hilarious term in itself.
• The April CTP has the following
• UML Class Diagram
• UML Use Cases Diagram
• UML Sequence Diagram
• UML Component Diagram
• UML Activity Diagram
• Architecture Explorer
• There is a unifying model underlying all of this, the diagrams are simply views upon that model.
• Newer versions will have some of the features we got to see today. These will come in another CTP later this year.
• Layer Diagram
• Seriously cool, this allows to separate concerns of our tiers in a system.
• I can bind my namespaces to logical layers of my application
• Also has some seriously cool visualization tools for looking through your code.
• Using these views, we can see our cohesion and inheritance in physical form.
• How about namespace visualization using a graph model? Dang, this is cool.
• How about a dependency visualization? NDepend better look out because this one isn’t half bad.
• AND, all views enable us to click right through to our source code. Neato.
• XMI support (seriously, wow). This means we can export models from other applications like Sparx EA, Altova, and Rational and bring them right into Visual Studio. Oh, and it will pull Visio models as well.
• Round tripping of component models to code
• Peter actually built some sequence diagrams and I gotta say that this UX is going to be MUCH better than Enterprise Architect, which will soon loose it’s Market Share. Even use cases look neater.
• Sequence diagrams can be round tripped with classes and even methods. This means we can examine the complexity of our code at a usable level, and do it visually.

What if you could prescribe separation of tiers and limit leaky abstractions?

Nuggets

“Any system should be possible to represent on a white broad in no more than 13 boxes.”

“Using model is simply a way of managing complexity.”

“There will be a model store capability that means we don’t need to keep our models in the same solutions with our code.” But you can

Because the models are all built on DSLs, there is someone out there who has automated the process of building test cases from activity diagrams. That is hotter than a 2 dollar pistol.

We can attach other files like Word files to your model itself.

What if we could could light up the models in the debugger to see highlighting of current activity in a sequence diagram? Neato.

They are trying to figure out how to include support for generating design patterns like found in EA and Rational. This is fun because you can generate domain specific code with a fundamental implementation in a known design pattern like Forward Controller or something.

I need a bigger monitor. Seriously, boss. I need a bigger monitor.

It is clear (and stated) that other RDBMS vendors will follow suit as MS has provided a fundamentally pluggable model for vendors to integrate their DBs into Visual Studio with a provider model. Can you smell Oracle, boys and girls? I can. Gert is being vague about who they are working with. MySQL will be cool.

There are several levels of extensibility:

• DB Provider
• This is the actual connectivity to your own RDBMS. This provider is responsible for talking to the VS model layer for the DB project and translating between your DB and the model.
• VS Features
• The ability to alter features in Visual Studio, like:
• Refactorings available for a given provider.
• Syntax highlighting
• language formatting rules for reverse engineering operations
• Static analysis rules for your particular SQL language
• Yes, you get static analysis rules for TSQL. This is the death clock for select * from …
• Static analysis in BD2 SQL may be different than that in MS TSQL
• You can write your own static analysis rules in .Net by inheriting from the provided Rule class or *yeah* implementing an interface (are we hearing a theme out of MS?) I suppose if your company were anal enough, you could actually implement your proprietary naming convention rules as static analysis rules. Gert actually did this is an demo by writing a rule that checked column names to ensure they were in Pascal case. Neato. The funny part is when some of the developers in the room started telling him how his demo code could be refactored. Lol.
• Model Extensibility
• VS actually works against a model of the data store and lets the provider do the translation.
• Using the model paradigm for DB development provides full round trip model to implementation support for any given DB.
• Gert actually showed a little command line app that looked at a Northwind DB in Access and a different Northwind DB in SQL Server and compared them. There would be very different SQL syntaxes if we were simply comparing creation scripts. The DBs showed as the same. More accurately, the models checked as the same. Cool.
• So, I could script the process of taking a DB2 database and migrating it to SQL Server, or visa versa, in this model paradigm.

This session signaled several things to me.

1. MS products really are being designed with extensibility and integration in mind. No really, this time.
2. The Data Dude model of working with databases has genuine merit. The days of SSMS (SQL Server Management Studio) and the Query Analyzer fan base are numbered. Treating DBAs as developers really is a better model.
3. Something different is occurring at MS with the changing of the guard.

Ward Bell is the Vice President of Product Management at IdeaBlade, which makes a .Net ORM product called DevForce. I met Ward and had a great discussion about ORM solutions and the evolving world of ORM and business tier technologies from MS and others.  Ward was good enough to share 30 minutes or so on the mics and you’ll be hearing hi interview on the Elegant Code Cast in the weeks to come.

Platforms for SOA and Business Process Management: Comparing .NET and Java

This session looks at the worlds of Java and .Net while paying particular attention to the problems found in the ESB space. For example, how does each stack solve for workflow, rules, messaging, etc.

David Chappell has presented this session at the Java One conference, so it is important to remember that this information as been vetted through the Java community.

The basic message came down to this: Sun’s stewardship of Java has promoted a fragmentation of technologies implemented in the Java language. This is great news for MS, who provides a unified stack of solutions in these spaces. The presenter asked the room this question, “Who believes that many solutions to workflow is good for the Java community?” About half the room went one way, the other half went another.

This gets to the core truth of the whole 1 vs. many solution discussion. Developers obviously love choice in their tools. After all, developers like to tinker and play with new technologies. Are these people also the ones most capable of making core platforms decisions for an enterprise? Typically not, because there is a bias toward new technology adoption over uniform practices.

As an example, the speaker told a story:

A Java developer asked him at a conference, “Help me construct an argument for my management to get permission for me to use Spring.”

“Why do you want to use Spring?” asked David.

“Because it’s cool, man,” answered the developer. “I want to play with it because everyone knows it is a better way to write applications.”

“You should be fired,” he answered.

The point here is that executives and logical decision makers who choose platforms are interested in the long game, not what technology is cool. Can I depend on vendor support? Will the product continue to evolve and grow? These are the questions that yearn for an answer of a unified platform that can be depended on to carry the business forward.

David actually cited the Garter quote that predicts the ultimate death of the J2EE platform in favor of vendor supported Java platforms by IBM and Oracle. If that actually comes to fruition, it is fascinating not just for its technical implications, but also for the comment this makes on the ultimate viability of community-based technology stewardship.

Maybe this 3 legged race of IBM v. Oracle v. MS offers an easier soup to stir than one consisting of many open source implementations. Interesting talk. The most interesting part of that discussion is the notable absence of Sun as a player in the Java discussion. What a weird world.

My favorite quote of the session, “Model Driven Architecture is where the rubber meets the sky.” Awesome. This comment on the huge abstraction of MDA feels right on.

FDD With Team System

Joel Semenuik provided a great overview of how his organization uses a formal Feature Driven Development process in conjunction with Scrum to deliver software. They do this using of Team System, which is no surprise since Joel is the co-author of Managing Projects with Microsoft Visual Studio Team System with Martin Danner.

I later learned from Martin, who used to be my office mate, that he and Joel are sponsoring a CodePlex project to aggregate open source process templates. What a nice idea! One stop shopping for process templates. I went hunting for it, but couldn’t find it on CodePlex yet.

How I Became a Team Build Muscle Man

Steve Borg blew packing material all over me when the build failed in his demo. To be more precise, he had a build monitor application hooked to a fan that blew packing peanuts all over me when his build failed. Nice. It tok 10 minutes to get all the stic clingy bits off me.

Anyway, Steve ran through a demo on using Team Build for CI and for deployment. It was pretty good, although I think many of us could have done without the Richard Simmons imitation.

Deploying to IIS

Steve used the MSBuild tasks found in the SDC CodePlex project to deploy his web application to IIS on a deployment and smoke test machine.

Deploying SQL Data

Even better, he used Visual Studio 2008 DB Pro to create a DB sample data loading script and deployed that to his test DB server via the SDC task DeployDatabase. This ensures that his web tests will always be run against his app with the same underlying data. This makes writing and running automated web tests as part of your build MUCH easier.

Misc

Also in 2008, we get the new BuildStep task that we can use to emote nice messages into our build log to provide some debugging information. Handy.

Implement the ITask interface to create your own tasks BTW. This is easy, I’ve actually done it!

WIX (Windows Installer for XML) is an open source tool that MS actually wrote and released to CodePlex. It is a nice little tool that helps us build MSI installers for our application. This utility is actually used by MS to create their installers like the MS Office and other binaries. This is basically a Visual Studio project that works like MAKE, but better. You can use WIX to accomplish all kinds of things like prepping your target machine’s dependencies as part of the MSI. Nice.

Source Control Branching Strategies

This was a great after-hours Birds of a Feather session that deserves a post of its own and will get it.

Here’s the takeaway: I had no idea source control strategy was a religious issue or that one can see an organization’s dysfunction in a source control system’s folder structure.

Now I know.

Colin Bird, CTO for Conchango, showed the 2.1 version of the process template today. It solved almost 100% of the problems I had been struggling with in my customized versions of the template.

1. Support for different teams on every work item type. This is HUGE because it allows for all teams to pull work from a single backlog.
2. Burn down reports for sprint, product, and release, that all split against teams. This is the biggy. If you haven’t tried working with reporting in TFS, you don’t know how HUGE this is. Awesome.
3. Code churn reporting
4. Value flow diagrams
5. Elimination of the Sprint data element in a work item in favor of using a release model based on iterations. Thank you.
6. Bugs as work items that appear on the product backlog

Honestly, there is very little left to do! I can only think if a few things I will be adding to this already existing functionality.

• Epics and Themes as work items and reports to support them. Even this will get better in Rosario with hierarchical work items.
• Tagging

That’s about it.

Colin also showed us an awesome new product that Conchango will be charging for and I would happily pay for. It is a WPF application that is a Scrum board working right off of TFS directly. There are other attempts at solving this same problem in the open source world, but this one is fully baked and soon to be available. It looks very usable. I can’t wait to see this thing in my shop. It will help the daily standup so much, and the overhead of making out physical cards will be a thing of the past.

I took a picture of it with my cell phone, but I don’t think I was supposed to do that. Oh, what the hell. Here it is.

You can actually drag the cards around and they change state and work remaining. If Colin weren’t English I would have hugged him. And then tickled him.

Guess what? SilverLight, Visual Studio, Unified Communications, surface computing, and robots are going to save the earth. So will WCF.

Brian Harry on TFS Now and Future

This was a great session. I know we are all tired of hearing it, but Rosario really is the release of TFS that will be the ONE. We are all struggling with Work Items and being able to manage our work the way we actually think of our work.

The one question I posed was simply how may an organization manage one single backlog of work within TFS and parse out that work to separate teams? The answer is that for right now, there isn’t a good story here. I will be blogging later in the summer about how I am solving for this in our organization.

Open Q&A on TFS – Jeff Levinson

Jeff is a Team System MVP and trainer and consultant for NW Cadence. He talked people through a lot of the typical questions that get asked soon after you install TFS in your organization.

1. What source control branching model makes sense for me?
2. How can I customize my work items?
3. What’s in the service packs?
4. How should I deploy for my build environments?

You get the idea. Here are some likeable nuggets I took away from this session.

• If you are installing TFS into an organization with fewer than 500 active developers, install it all on one box.

  I have installed on one machine for simplicity’s sake and recommend the same model , but I had no idea the scalability of that model went as high as 500. Jeff claims that this kind of load will only flutter the CPU. Bear in mind, though: This is NOT regarding the build machine. Build machines need to be separate and preferably virtual.
  

• Microsoft will be paying closer attention to X in Rosario. X can equal any of these things:
  • Project server integration
  • Portfolio server integration
  • Query-able link control in work items
  • Tooling for testers, and that doesn’t mean test tools for developers.

Application Lifecycle Management Panel Discussion

An entire stage of Team System MVPs, discussing Application Lifecycle Management. Rich Hundhausen, Jeff Levinson, Mike Azocar, Steve Borg, Jeff Beehler,  Mickey Gousset, and several others.

This is about ALM which includes all phases of the lifecycle, so how are we helped by rapid delivery.

I only asked one question of the panel. “What’s the view forward for integrating the entire ownership lifecycle? Don’t we really need tooling like support in TFS for System Center to get where you are all talking about?”

Answer: It turns out that MS is solving for different phases of the overall ALM problem at different phases with different tools. TFS for developers, System Center for I.T., Project and Portfolio Server for the business folks. What ties it all together? Nothing yet. Maybe BizTalk will do the trick, eh? Right.

Scrum-tastic Process Template

Presented by, Mike Azocar, the author and project manager of the actual CodePlex project for the Light Weight Scrum Process Template for Team System (whew).

I am particularly interested in this work because of the aforementioned focus I have on customizing the Scrum process template from Conchango.

Nuggets:

• An interactive system can never be fully specified – Wagner’s Law
• Scrum is appealing to many organizations because it is:
  • Simple
  • Free
  • Transparent
  • Common sense
• “No one runs beyond 3 or 4 sprints before changing their out-of-the-box process template.” – Mike

Lastly

Keep a watch on this page, which hosts videos from the Tech Ed floor.

Oh, and I met Richard Campbell of DotNetRocks. I told him it was sort of like meeting Madonna. He asked me not to follow him into the bathroom.