We recorded our chat and I’ve just made it available as Radio TFS episode 23.

Play Now: Radio TFS - Using TFS with Ed Blankenship

As well as talking about the challenges of rolling out TFS to a large, global organization, we also discussed some of the innovative integration work Ed’s team has carried out to integrate TFS with Microsoft CRM. 

It turned out to be a longer show than usual, almost a double length episode.  Hopefully people will find time over the holiday weekend to listen to it.  I’m keen to hear your feedback. We are trying to step up the number of Radio TFS episodes that we put out to two a month.  If you haven’t subscribed to Radio TFS then now is the time.

Photo courtesy of Barry Gervin.

TFS has a many strengths.  Two of them that I particularly like talking about are it’s performance over a wide area network and the strong IDE integration available for both .NET and Java developers (the latter via Teamprise of course).  Microsoft have just posted a new case study with iGate, one of the top 20 global outsourcing companies which talks about this in depth.

iGate has been assesed at CMMI Level 5, Six Sigma methodologies and is COBIT, ISO 9001 and ISO 27001 certified.  They have 8 offices in 12 countries and manage global delivery centers in Mexico, Australia, and India. Like most software development organizations, version control is critical infrastructure and they chose TFS to manage software development projects across all platforms.

“When we implemented Visual Studio Team System, we noticed immediate process improvement through automation. It reduces the administrative burden and reduction in administration efforts leads to significant cost savings of 55 percent.”

Chella Namasivayam M
Vice President IT & IS, iGATE.

iGate chose TFS ahead of tools such as IBM Rational ClearCase, MKS Implementer and CVS.  For more information on why and what benefits they have got from standardizing on a single platform take a look at the case study.

As of our launch, we have a variety of build tools, our check-in policy SDK and a source code management plugin to the popular TextMate text editor.

But check back - we've got some more exciting projects in the works that we can't wait to share with you.

From: Terry Humphries

My name is Terry Humphries and I work for EnGraph Software. I’ve been a developer for over 25 years the last three months at EnGraph. I came here to join a development team that was scaling up from a couple of developers to over 14 folks. Part of my job has been and continues to be leading EnGraph’s push into using Team System. I spend part of my time wearing a developer hat and part wearing the TFS admin, Build Sensei hat.

Having always been a strong believer in nightly builds and making sure everyone is aware of the status of the build, I’m always looking for ways to get the other developers invested in the status of the build.

Having seen Brain aka the Build Bunny and the Lava Lamp build indicator I decided it was time to create something unique for EnGraph to use.

I almost used a full size traffic light, but since all of the pcs here are named after guitar manufacturers, a Build Guitar seemed the way to go, and the search was on. It took me about three week to locate the used Warlock I used as the basis of the project. I didn’t want a run of the mill guitar, it need to be electric and it needed to have a unique look. When I got the Warlock it’s better years were behind it, the body was in bad shape. I had to end up stripping it, filling in a few dings and refinishing it with a purple undercoat and a bronze metallic pearlized overcoat.

I looked at several options for the switching mechanism for the LEDS. Basically, I wanted something that would provide the low dc power needed to drive the LEDS and a programmable interface for switching them on/off. I considered Ethernet based relays, Bluetooth based relays, Ethernet to parallel port converters, and USB controlled relays. Mostly because the other options were much more costly I settled on the USB controlled relay. I decided to mount this control circuit in its own box and use standard Ethernet cabling to get the power to the guitar from the relay. With this option the only things I had to mount in the guitar were the LEDs, the Ethernet jack, and wire connecting them.

Once I obtained everything I need I started build the controller. Wanting it to also be somewhat different I decided to mount the relay circuit old 3.5 diskette plastic case that was designed to hold 10 diskettes. After mounting the circuit board I added the ethernet jack and connected the power supply. Cut a few hole for the cables and bam the Build Guitar Controller was born.

Next, guitar time. I decided the best place to mount the LEDs was in one of the pickup coil frames, you see a Warlock comes with 2 Humbucker pickup coils each mounted in its own frame. I fashioned a piece of black plastic to fit the frame and drilled three holes for the LEDS. Then I wired the LEDS to the Ethernet jack I had placed in the jackplate.

Then I hooked everything up loaded the Phidgets drivers and using they’re control panel applet tested the wiring and after a few minutes I had everything working as planned.

The folks at Phidgets provide 2 way to interface with their devices, either directly or via a webservice, I used both. I couldn’t find a TFS event that fires when a build starts so I created a custom task that turned on the correct relay and hooked it into our build scripts via the BeforeEndToEndIteration target and then used Howard van Rooijen TFS Event Framework to react to the BuildCompletionEndpoint to set the red and green leds.

The basic code for manipulating the relays is only 9 lines:

InterfaceKit RelayPhidget = new InterfaceKit();

RelayPhidget.open("gibson", 5001);

System.Threading.Thread.Sleep(1000); //wait for the server to connect

RelayPhidget.outputs[0] = false;     //Set build start off

RelayPhidget.outputs[1] = true;      //Set build success on

RelayPhidget.outputs[2] = false;     //Set the other off

RelayPhidget.outputs[3] = false;

RelayPhidget.close();

RelayPhidget = null;

I’m not sure what else I can tell you about it other that it’s a big hit with the other developers. As for more about EnGraph you can visit our web site at www.engraph.com

Hardware:

• Warlock Electric guitar made by B.C.Rich vintage 1990s
• 10MM diffused LEDS in Blue, green and red
• Phidget Interface Kit 0/0/4 available here
• 5VDC 350milliamp wallwort power supply
• Various bit of wire, tape glue paint, etc.

Software:

• Team Foundation Server Notification Event project template from Howard van Rooijen
• VS2008
• Phidgets Driver

Thanks for sharing this with me Terry, and for allowing me to post your email.  For anyone interested, I’ll be talking more about integrating with Team Foundation Build API’s during my session at Tech·Ed North America 2009 next week.

DTL307 Brian the Build Bunny: Extending Team Foundation Server Build

Fri 5/15 | 9:00 AM-10:15 AM | Room 404

This session digs deep into customization of the Microsoft Visual Studio Team System Team Foundation Server Build system. Learn about the .NET API for Team Foundation Build and how to use it to create your own build status display or even have your team chastised about build failures by a robotic rabbit.

The easiest way to build a Maven project from Team Foundation Server is to install the Teamprise Build Extensions on your build server using the MSI installer provided on the download site (http://www.teamprise.com/products/build/).  You must also have a Java JDK and a copy of Maven 2 installed on the build server.  See the User’s Guide for full details.

You can then use a copy of Teamprise Explorer or the Teamprise Plug-in for Eclipse to create the build definition. 

Once you have given the build definition a name and specified what should be included in the build using the usual options, go to the Project File section. 

Just as in Visual Studio you can change the folder that you want the build configuration to be stored (1) but when you press the Create button (2) things differ a bit from  the Visual Studio interface.

As you can see, you are prompted as to what type of build you would like to create. When connected to a TFS 2008 server you will be offered two options, Ant and Maven.  In our case we are going to select Maven and then we get to pick the master POM file for our Maven 2 build

The wizard will then create the TFSBuild.proj file necessary to run the Maven 2 project and check it into the build configuration folder specified previously.  You can then define you trigger and build agent just as you would normally and you should be good to go.

As well as creating the build definition, the Teamprise client simply creates a TFSBuild.proj file in the following format which you could easily create yourself if you wanted to create the build from Visual Studio or something.

<?xml version="1.0" encoding="utf-8"?>

<Project DefaultTargets="DesktopBuild" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">

 

  <!-- Do not edit this -->

  <Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\TeamBuild\Microsoft.TeamFoundation.Build.targets" />

  <Import Project="$(MSBuildExtensionsPath)\Teamprise\v2\Teamprise.Build.Maven2.targets" />

 

  <ProjectExtensions>

    <ProjectFileVersion>2</ProjectFileVersion>

    <Description></Description>

    <BuildMachine>buildserver.mycompany.com</BuildMachine>

  </ProjectExtensions>

 

  <PropertyGroup>

    <TeamProject>Billing</TeamProject>

    <BuildDirectoryPath>UNKNOWN</BuildDirectoryPath>

    <DropLocation>\\UNKNOWN\drops</DropLocation>

    <SkipWorkItemCreation>false</SkipWorkItemCreation>

    <WorkItemType>Bug</WorkItemType>

    <WorkItemFieldValues>

      System.Reason=Build Failure;System.Description=Start the build using Team Build

    </WorkItemFieldValues>

    <WorkItemTitle>Build failure in build:</WorkItemTitle>

    <DescriptionText>This work item created on a build failure.</DescriptionText>

    <BuildlogText>The build log file is at:</BuildlogText>

    <ErrorWarningLogText>The errors/warnings log file is at:</ErrorWarningLogText>

    <UpdateAssociatedWorkItems>true</UpdateAssociatedWorkItems>

  </PropertyGroup>

 

  <ItemGroup>

    <!--  Maven 2 Call Configuration. 

          The POM file called should be included in the workspace of the build definition.

    -->

    <MavenPomFile Include="$/Billing/Main/billing-service/pom.xml">

      <Goals>install</Goals>

      <Properties>

         BinariesRoot=$(BinariesRoot);BuildDefinitionName=$(BuildDefinitionName);

         BuildDefinitionUri=$(BuildDefinitionUri);BuildDirectory=$(BuildDirectory);

         BuildNumber=$(BuildNumber);DropLocation=$(DropLocation);LogLocation=$(LogLocation);

         SourceGetVersion=$(SourceGetVersion);TestResultsRoot=$(TestResultsRoot);

         TeamProject=$(TeamProject);WorkspaceName=$(WorkspaceName);

         WorkspaceOwner=$(WorkspaceOwner)

      </Properties>

    </MavenPomFile>

  </ItemGroup>

 

</Project>

The Import statement at the top is calling the Teamprise.Build.Maven2.targets file. This safely inserts the call to Maven 2 into the Team Foundation Build process. It uses the MavenPomFile item group to specify the server path of the POM file to build – this is converted into a local path as part of the build process.

The Maven 2 integration will listen for surefire steps as part of the build process and automatically include those files in the list of JUnit results to publish to TFS. It will also automatically copy any files in the Maven 2 targets directory over to the drop location for build archival purposes.

The Teamprise Build Extensions are provided free of charge, and the source code is available under the permissive open source MS-PL license if you want to take a look in more detail at what they do and how they do it.

Internally, we also have a Maven SCM Provider for TFS coded up and we are about to submit this to the Maven project so that people using Maven will be able to perform SCM operations easily from inside their projects (and use things like the Maven Release plug-in to perform releases).  If you would like a copy of the SCM provider in the mean time then let me know and I can send you a copy.

Looking forward to hearing what people think.  Now that we have both Maven 2 and Ant support for building Java projects in Team Foundation Server this really helps Java development be a first class citizen in the TFS world. I’m always keen to hear feedback how we can improve the situation further if you have any suggestions then let me know.

Flexible Project Mappings in Eclipse
Many customers - especially those moving from other version control systems - want more control over the import process in Eclipse. In earlier versions of Teamprise Plug-in for Eclipse, we required that your Eclipse projects live beneath the Eclipse workspace root. While this restriction was mostly sensible, many customers wanted to be able to keep a hierarchical project layout. In Teamprise Plug-in for Eclipse 3.2, we allow you to set up your local project layout however you wish, then perform your Import from Team Foundation Server.

To take advantage of this new functionality, open up Team Explorer before
performing your import and map your working folders manually before performing
your input. Let's say your projects look like this in Team Foundation Server:

$/BigProject
$/BigProject/Client
$/BigProject/Client/com.example.bigproject.client
$/BigProject/Client/com.example.bigproject.client.ui
$/BigProject/Client/com.example.bigproject.client.ui.win32
$/BigProject/Client/com.example.bigproject.client.ui.gtk
$/BigProject/Server
$/BigProject/Server/com.example.bigproject.server
$/BigProject/Server/com.example.bigproject.server.soap
$/BigProject/Server/com.example.bigproject.server.core

Now you can set a working folder mapping for $/BigProject - say to
C:\BigProject - then open up the Teamprise Import Wizard and select all your
projects. They'll be imported relative to C:\BigProject:

C:\BigProject\Client\com.example.bigproject.client
C:\BigProject\Client\com.example.bigproject.client.ui
C:\BigProject\Client\com.example.bigproject.client.ui.win32
C:\BigProject\Client\com.example.bigproject.client.ui.gtk
C:\BigProject\Server\com.example.bigproject.server
C:\BigProject\Server\com.example.bigproject.server.soap
C:\BigProject\Server\com.example.bigproject.server.core

You can even do a Get Specific Version inside the Source Control Explorer:
the Import Wizard won't overwrite the version you download, so you'll be
able to import a historic version easily.

The only restriction is that you must map these projects outside of your
Eclipse workspace root - projects inside your Eclipse workspace root must
live in a flat listing. (This is an Eclipse restriction, not a
Teamprise-imposed one. Sorry!)

Kerberos Authentication
Teamprise clients now support passwordless authentication to the Team
Foundation Server on Linux and Mac OS X platforms using a Kerberos ticket.
This provides a convenient, and secure way to authenticate to your Team
Foundation Server.

Switch to Branch
This is a handy little feature that allows you to work with multiple branches more easy in Eclipse. Want to work in a different branch? Simply right click on a project, select "Switch to Branch" and select the TFS branch that you want to work in. Then you can make whatever changes you want in that branch and switch back to your main branch.

Command-Line Client Functionality
The Teamprise Command-Line Client adds a lot of new functionality in 3.2, most notably full support for merging branches from the command line. CLC also adds conflict resolution, diff support and improved navigational functionality.

Other New Stuff
3.2 offers much better controls in work item tracking -- native controls for Areas and Iteration dropdowns, autocomplete for other work item dropdowns, and a better history control on most platforms. Plus we've added support for a new IDE: IBM RAD 7.5, as well as a new operating system: HP-UX on Itanium processors.

Teamprise Client Suite 3.2 (and any of the component products) is a free
upgrade for existing Teamprise Client Suite 3.x customers, as well as
customers with a current maintenance agreement. We recommend upgrading to
get these great new features.

If you're interested in hearing a little bit about some of the difficulties in writing cross-platform code in general (or a cross-platform Team Foundation Server client in particular), then I recommend you give it a listen. It's an overview of the topic, and not a deep dive into some of the hairy monster you might encounter, but I have (and will continue to) blog about those topics more in depth.

Ouch. That's a question I didn't want to have to answer, since I haven't put up a post since last July, over six months ago. So this is that blog post where I apologize and make some vague assertions that I've been really busy since then.

To be fair, I have been really busy: let's not forget that Teamprise is a startup. And while we're not the sort of startup where the developers have sleeping bags^[1] under their desks and the owners crack the whips, let's make no bones about the fact that there are times when you're working frantically to hit your deadlines and you let the less important things slip. Like writing in this blog.

And although I'm apologizing, we're both probably happier that I'm not blogging when I'm in the midst of the writing lots of code or this would actually end up as a cross between twitter and a trainwreck. I can see it now:

Day 42: It turns out that xstream 1.1.3 is totally incompatible with the IBM JRE that ships with RAD 7.5. Fascinating, huh?

So keeping a little quietude on the blog front lets me get some perspective on what I'm working on, and I can write about the bigger picture instead of whatever tiny hunk of code has pissed me off that day. And the bigger picture is that 2008 has been a whirlwind of development at Teamprise:

Teamprise Client Suite 3.0 - 3.1.3
Client Suite 3.0 was released in March to complement Team Foundation Server 2008, and it included a lot of new features, big performance enhancements, and lots of little improvements^[2]. You can read more about 3.0 on Martin Woodward's blog, and more about 3.1 on mine.

Teamprise Remote Accelerator
I snuck away from working on Client Suite for a few months in the fall and focused on this handy application that provides developers a big speed boost when they're remote from their Team Foundation Server. This was an internal tool that we "productized" and released at the Microsoft Professional Developers Conference in October. I'll write more about it soon -- I really should have blogged about it back then, but instead I jumped right into...

Teamprise Client Suite 3.2
We haven't released it yet, but I'm including 3.2 on our year-end retrospective since we've put a lot of effort into its development this year^[3]. As with all the point releases, it's a free upgrade for existing 3.0 customers (or customers who have purchased maintenance), and we think you'll be very happy with it. We're really excited about 3.2, and I'll be writing more about it soon.

So that's my excuse, and while I feel like a guy who's turning in his homework late, there should be some potentially interesting stuff coming up.

1. jwz, of course, has the canonical tale.
2. I keep being told not to say "bug fixes" since they're not "bugs", they're "features", right? And "feature fixes" sounds really stupid, so I'll settle on "improvements". And the fact that I footnoted this illustrates why I am horrible at marketing.
3. Okay, well, me less so than most of the rest of the team, seeing as I snuck off to work on Remote Accelerator for a while. Sorry, guys.

The biggest new feature in 3.1 is support for working offline in both our Teamprise Plug-in for Eclipse and our Teamprise Explorer clients. Offline support is a big advantage for TFS users who have unreliable network connections - particularly telecommuters and road warriors, who might want to get some work done wherever they are, be it a coffeeshop or an airplane.

If you're an Eclipse user and wish to go offline from your Team Foundation Server (or if your network unfortunately takes you offline), just go to the Team menu and select "Work Offline". You'll be disconnected from TFS, yet you'll still be able to perform all the file operations like you expect -- you can add, edit, move and delete files just like if you were online. When your network connection returns, you can choose the "Return Online" menu option and pend all those changes to the server.

Working offline in Teamprise Explorer is even simpler, you don't need to specifically enter offline mode. Simply make whatever changes you wish in your workspace, and click "Return Online" from the Source Control context menu. Explorer will synchronize your local workspace with the server and pend any changes you made while you were offline.

The Command Line Client has had offline support since version 3.0, so that's nothing new, but it does get some cool features aside from that. We've added an XML output option for many commands so that you can parse the results easily from a script. The "brief" and even "detailed" formats tend to truncate output for easy interactive viewing, but this can be troublesome for scripts. The new XML output should be perfect for getting all the information out of Team Foundation Server.

Those are a few of the bigger features, but there are many more. And seeing as this is still a point release, there are a lot of bug fixes, too. If you want to see all the details, check out the 3.1 release notes.

We've spent a lot of time on 3.1, and we think you'll enjoy it, even if you're not the type of person to upgrade for "just a point release".

We'll be giving demos of the new Teamprise 3 and all it's great new features. Hope to see you there!

If you're in the greater Chicagoland area next week, I've been invited to the Chicago VSTS User Group to give a tour of the new version of Teamprise. If you're interested in how Team System can play nice with Java developers, I suggest you stop by and check it out:

The meeting begins at 5:30 PM at the Microsoft Chicago (Loop) Offices:
77 W Wacker Dr, Suite 2300

Please RSVP if you're going to attend.

Even if you can't make it next week, be sure to check out the Chicago VSTS User Group, or another user group near you. It's a great resource if you're a VSTS or Team Foundation Server user!

Teamprise will be exhibiting at the Chicago launch event tomorrow, March 11. We're in booth 47 - stop by and say hi if you're attending.

Even better -- our very own Martin Woodward will be presenting at the Dublin launch event tomorrow. Be sure to check him out if you're attending out there.

Otherwise, there are still plenty of events in a city near you - be sure to go check out what's new in TFS 2008!

Teamprise was invited to present at this month's Chicago VSTS Users Group to discuss using TFS from within the Eclipse IDE and from non-Microsoft platforms. I'm excited to make a fool of myself speaking in public (and excited to learn that a VSTS Users Group exists in Chicago.)

I'll be speaking with David Dugan who's a Senior Consultant for Sogeti. David will be discussing accessing TFS from older versions of Visual Studio.

Maybe I'll see you there!