Showing posts with label TFS. Show all posts
Showing posts with label TFS. Show all posts

Friday, June 7, 2013

Upgrade from TFS 2010 to TFS 2012

Even though there is talk of TFS 2013, with the first CTP due towards the end of June, I’m still doing quite a few upgrades to TFS 2012 at the moment.

When considering upgrading to TFS 2012, there is basically one of two approaches, namely an in place upgrade or a migration.

The in place upgrade is probably a bit less “complex”, even though it can be quite involved. You need to get the environment to a TFS 2012 friendly state (note those service packs!) and then do the upgrade which can take some time.

I highly recommend doing a test upgrade first, work out and document all the kinks before you shut down and attempt a production upgrade.
The test will give you an indication of what can happen before you start, and how long the upgrade will actually take.
With an in place upgrade there is not much you can do to reduce the amount of time that the upgrade will take, you would need to go through all the steps, which will involve uninstalling TFS 2010 and installing TFS 2012 and then upgrading the databases.

You do gain some time in that you would not need to change the SharePoint or reporting services links.

Personally I prefer doing a migration as apposed to the in place upgrade. This means that I can spend the time and configure a new “fresh” environment, then take a TFS 2010 database across and make sure everything works. Any problems can be sorted out in the new environment and you most probably won’t need to keep an extensive log to remind yourself of the problems during the actual upgrade.

On D-Day you just need to take over the TFS 2010 database, and do the post configuration steps. This will also retain the TFS 2010 environment in case anything goes wrong.

Some things that you need to take note of with the migration are:

1) Rebind SharePoint

Have you opened up the project’s SharePoint portal and it has red block strewn all over it?

image

I have found that “Repair Connection” will in most cases sort out the links adequately. If however you have not stuck to the default SharePoint sites or you use sites that are located on different servers, you would need to manually “correct” these bindings.

Open up Visual Studio, go to Team explorer Settings and open up the “Portal Settings”.

image

Re-establishing the connection here works as a last resort (for example uncheck the “Reports and dashboards…” checkbox , click OK , open it back up and then select it, click OK again ) .

2) Reporting Services

If you are considering moving SSRS there are a couple of steps that you need to take into consideration:

  • Restore both the ReportServer and ReportServerTempDB on the target server
  • Make a backup of the SSRS encryption key from the source server and then restore it on the target server
  • In Reporting Services Configuration Manager, make sure that only the target server is in the “Scale-Out Deployment” section. If the old server is still there, remove it.
    • If it won’t simply remove by selecting it and clicking “Remove Server”, then open up the ReportServer database and remove it from the Keys table
  • Make sure that the top level security ( in http://<report server>/Reports ) is set adequately
  • Make sure that your TFS data sources ( “Tfs2010OlapReportDS” and “Tfs2010ReportDS”) points to the correct server
  • And finally, in the TFS Admin console, make sure that on the Reporting view, you are pointing to the correct SSRS server

3) Build Template

Make sure that your build templates have been updated correctly and any custom activities are referencing the new TFS 2012 assemblies.

4) Finally

Upgrade the project templates from TFS web access admin site and setup the team members.

 

Depending on the hardware that you are doing the upgrade on a 15GB TFS database can take 40 minutes to an hour and a 45GB database can take in the vicinity of 3 hours.

If you are looking to upgrade TFS to TFS 2012, feel free to give us a shout

Friday, May 17, 2013

Quality Management with Visual Studio

I have had a couple of discussions around the various aspects of managing quality, I even have a section dedicated to quality management in the training that I offer.

I like to break down quality management as follows:

We all (should) know about the Agile testing quadrant that was initially discussed by Brian Marick and then used to form the basis of Lisa Crispin’s book on Agile Testing.

Agile Testing Quadrants

A lot of people have asked me “where do I start”?

I want to take this and break it down into a practical, technical approach.

image

The basics or the bottom of the pyramid is about inspection. Does the code look right?

This is the easiest accomplish. The tools are already built into Visual Studio and it is a matter of a few clicks to get the results. You can make this a part of the review process or even automate it using TFS Build to produce these reports every time someone checks in code.

The next step is t verify or test that the functionality of the application / code works as expected. There are a couple of methodologies (TDD, ATDD etc) that you could look to to get the unit testing in place. A personal favourite are the SOLID principles with regards to how to go about designing the application to be test friendly. Overall, my advice is just start.

Next is a subtle, yet important step. Even if it is just to separate the concept of a Unit vs an Integration test. The unit test focuses on the smallest piece of code in isolation. The integration test will combine these units together and see how they perform in unison.

UI Testing can be quite difficult in many organisations. They tend to be fairly brittle and need maintenance (which puts a lot of people off).
I like the approach of having manual test cases executed during the sprint or iteration (using something like Microsoft Test Manager ), and then in the next sprint or when the functionality has stabilised a bit, decomposing those to Coded UI tests for eventual automated execution.

Finally, load and performance testing. This usually only happens when there are problems or when a big client requests the stats, right !?
Including this type of testing is very much dependent on the application and when/where the application is used. A simple 5 user, limited data, desktop application has much less of a performance requirement than, for example, a large, customer facing ecommerce site. So consider this when and where it is appropriate.

So from basic inspection to performance and load testing, it is a journey that you need to travel. Using tools (such as Visual Studio) that incorporate this functionality is a big help. It merely becomes a matter of getting to grips with what is already there for you to use. Combining this with TFS to automate the tests when ever a change is made or even on a scheduled build, will greatly increase quality, flexibility and agility.

Friday, March 8, 2013

Run Application through Coded UI Tests

I have always liked the idea of using automated testing as a part of a full testing strategy. It makes sense to automate as much as possible to exercise the application thoroughly and repeatedly.

Obviously if you can run these automations in a scheduled, automated build( using TFS) this is better suited to increase quality all round.

Here are some tips that I wanted to share after getting a Coded UI strategy in place recently.

The high level steps in setting up and executing the automations can be broken down into:

  1. Configure TFS Build to execute automated tests
  2. Deploy all the assemblies and files that is required to run the application
  3. Setup tests
  4. Configure Build definition
  5. Execute the build and watch magic happen

Configure TFS Build

Remember that automation tests is exactly that, it automates the end user’s actions on the application. This means that it will run the application and perform clicks and type text in text boxes “as a user does”. This means that you would need to have the application run in the desktop.
How do you do that in an automated build you may ask?

Simple: when configuring the TFS Build Service it is as simple as checking a checkbox.

image

Deploy assemblies

This can get a bit involved. So let’s assume that you need to have the application run and you need files copied to the application directory, but under their own directory.
Something like this:

image

 

 

 

Deploying files can occur in one of two ways:

  1. Use “DeploymentItem” attribute on the tests or
  2. using a testsettings file

Even though Microsoft recommends using the “DeploymentItem” attribute for performance reasons, I had enough hassles with it in the CodedUI test cases to abandon it and rather opt for the test settings file.

The test settings file is also a bit more involved than one would expect, but it is manageable.

  1. Add a test settings file to the solution if you do not already have one
    image
  2. Open the test setting dialog and navigate to the “Deployment” tab
    image
  3. Enable deployment and add the files and folders that are needed to execute your tests
    image
  4. If you had to execute the test now, you may notice that everything in those folders would just be included into the deployment directory. It does not replicate the folder structure automatically
  5. Apply the changes in this dialog and then open up the test settings file in notepad or an XML editor
    image
  6. Edit the “DeploymentItem” nodes and add a “outputDirectory” attribute like this:
    image
    This will cause the folder structure to be maintained in the deployment folder
  7. Finally, select this as the default test settings in Visual Studio ( “Test->Test Settings->Select Test settings File” )

Setup tests

You can go ahead and start recording the tests now.
Obviously you can record the steps to execute the application and then kick off the automation or you can edit the test and use “ApplicationUnderTest.Launch("application.exe");”.

Configure Build Definition

Create a standard build definition using Team Explorer but when defining automated tests in the Process tab remember to use the test settings file that you created and committed to version control
image

 

Now all that is left is to execute the build and watch the magic happen.

Tuesday, February 26, 2013

Moving TFS from SQL Enterprise to Standard

I have come across a couple of TFS installations that have been deployed using SQL Developer Edition recently. This is problematic when upgrading or migrating TFS to a “proper” production environment (SQL Developer Edition may not be run in production environments!)

Considering that TFS comes with a restricted SQL Standard Edition license, there should never be much of a reason to install TFS on Developer Edition.

Getting back to the problem… SQL Developer Edition is basically Enterprise Edition. This means that it comes with a lot of goodies that obviously are not included in Standard Edition. TFS will happily enable and use the following Enterprise Edition features:

  • Online index operations
  • Page compression
  • Table and index partitioning
  • Larger read - ahead buffering & Cube perspectives

The one that could cause problems when moving to different versions of SQL is the Page compression. Once you have page compression enabled on a database, you cannot just backup and restore the database to a Standard Edition instance. You will end up getting an error to the tune of:

Database ‘<TFS Database name> cannot be started in this edition of SQL Server because part or all of object ‘<Table Name>’ is enabled with data compression or vardecimal storage Format. Data compression and vardecimal storage Format are only supported on SQL Server Enterprise Edition.

One little trick that I have picked up is running the following stored procedure BEFORE you create the backup of the database:

EXEC [dbo].[prc_EnablePrefixCompression] @online = 1, @disable = 1
(see here for more detail)

This will disable the compression on the relevant tables and allow you to carry on with the migration. You would need to run this for each of the databases that you are intending to move across (including the Tfs_Configuration database if you are indeed doing a migration).

Hope this helps

Feel free to contact us if you need to perform any upgrades or migrations to TFS 2012

Thursday, January 31, 2013

Team Foundation Server as DVCS

Just yesterday I had a discussion with a client of mine about some of their teams that would prefer to use GIT as apposed to TFS. I mentioned that TFS will definitely be moving that way (looking at GIT-TFS that was brought out a while back), it is just a matter of time.

Low and behold this morning Brian Harry announced that TFS Service can now actually host GIT repositories with full support and integration coming in VS 2012 update 2 with VS tools for GIT.
As I mentioned it is already available on TFS Service and will be heading to “on premise” with the next major release of TFS.

You can read more on how to get started here.

Exciting times!!!

Wednesday, January 9, 2013

Connecting to TFS 2012 from older versions of Visual Studio

Just in case you were wondering, it is absolutely possible to use TFS 2012 from previous versions of Visual Studio.

All you need to do is get hold of the Future Compatibility Patches.
For the sake of ease, here they are:

VS 2010
VS 2008
VS 2005

For earlier versions, in fact anything else that supports MSSCCI providers there is even a free provider for TFS 2012 in both 32 & 64 bit.

Just note that you would need at least service pack 1 for each version of Visual Studio.

Monday, January 7, 2013

Setting a User Story In Progress through My Work

One of the cool new features in Team Explorer 2012 is the My Work page. It has a bunch of useful and context specific functions that makes interacting with TFS a lot more streamlined.

One of these features that has been introduced is the ability to “Start” and “Stop” or even “Suspend” work.  You can decide on a work item query that displays the available work for an iteration and then with a single click, you can “start” working on the work item.

image

It works very well if you are using tasks for your work backlog. When you start a work item, Team Explorer will change the task to “active” and assign that task to you.

There are however two instances where things may need a little manual intervention:

1) When you are not using Tasks

I always recommend using Tasks to break down User Stories or Product Backlog Items, but I do have a client that breaks up the work into fairly fine grained User Stories and they don't see the need to create additional Tasks.  We found that creating a query to return the current iterations User Stories allowed you to “start” the User Stories, but it did not change state or assign the user to the work item.

After a little digging I found that unlike the Task definition,  the User Story does not define the “StartWork” action on the transition between the “New” and “Active” states. Luckily it is a fairly simple process to update the work item definition.

Use the witadmin to export the work item definition, update the “New” to “Active” transition to include the “Microsoft.VSTS.Actions.StartWork” action and, hey presto, when you start work though the My Work page, it automatically assigned the User Story and sets its state into “Active”. Take a loot at the “Adding the StartWork and StopWork action” section of this post for step by step instructions.

2) Upgrading from a previous version of TFS

When upgrading a project collection instance, a lot of the “new” functionality needs to be added manually.This post does a very good job of taking you though the steps to enable some of the new features in TFS 2012.

Thursday, January 3, 2013

Microsoft System Center and Team Foundation Server

Recently I spent quite some time getting to grips with Microsoft System Center  (SC). I have a client that has a very large IT infrastructure environment and relies quite heavily on SC to monitor and manage it.
SC is one of those products where the question “What does it do” will prompt an answer “What do you want it to do?”. If you have not heard of System Center before, it is basically a suite of products specifically aimed at corporate IT administrators, assisting them in managing Microsoft server and desktop infrastructure.

MSSC

This means that you can leverage SC (making use of the various aspects or applications ) to do everything from AD account provisioning to virtual machine creation and deployment.

TFS does have a management pack which integrates TFS very nicely with System Center Operations Manager (SCOM).

“The Team Foundation Server 2012 Monitoring Management Pack provides both proactive and reactive monitoring of Microsoft Team Foundation Server 2012. It monitors TFS components such as application tier server instances, team project collections, build servers, and proxy servers. “

So we can monitor TFS and report failures and even go as far as “escalating issues” to TFS in the form of work items.

This post however, centres around System Center Services Manager (SCSM). SCSM with its “out of the box” integration with a number of SC applications, including Orchestrator, makes it a very capable application for managing, automating and adapting your IT services.
It also provides built-in processes for incident and problem resolution, change control, and asset lifecycle management.
Has the penny dropped?
What if I mention that TFS work items provide built-in processes for incident and problem resolution, change control, and application lifecycle management.

The client that I mentioned earlier is using SCSM to manage everything from infrastructure to software requirements and changes.
The development team is using TFS and they wanted to “integrate” SCSM with TFS, reducing the effort involved to manually copy work items and progress from one system to the other. They also wanted to reduce the context switching between the applications, specifically in the development environments.

So where to start…

As I mentioned earlier, SCSM integrates very comfortably (using connectors) with a number of the SC applications. One of which, Orchestrator (previously Opalis), is basically a workflow management system. In SCSM you can invoke and execute Orchestrator workflows through a number of processes and via a number of hooks, and in Orchestrator you can configure “monitors” that poll target systems. Through Orchestrator and custom “Integration Packs” (IP) you can basically have SCSM integrate with any number of 3rd party applications.

The guys over at the Orchestrator Codeplex project had already built some IP’s for various applications and fortunately for me there is even one for TFS.

So, how did we get this going..

Firstly you need to get hold of the Integration Packs and deploy them to the Orchestrator “Runbook” server.
Then we can create the workflows that monitor SCSM for any changes in the Requirements and Manual Activities.
When a requirement is created or changed we push over that change to TFS as a User Story.
Next we find associated Manual Activities and then create or update them in TFS as Tasks that are linked to the User Story.

 

image

The same approach is followed when a change is made to a work item which is then updated in SCSM.

One problem that I did have was that the TeamFoundationServer IP was built using TFS 2008 and updated to TFS 2010. This means that work item links were not taken into account when the initial activities were created.

Fortunately it is very easy to code these custom activities (think activities in Windows Workflow Foundation) in the IP’s, and being a codeplex project I was able to grab the code and create the additional activities (I did submit a patch with the changes)

This was a very interesting learning experience, delving into yet another one of Microsoft’s application suites. This also takes TFS’s capability and makes it available into areas that you would not necessarily have considered possible, further establishing TFS as a true ALM suite.

If you would like to know more, or would like TFS integrated into SCSM. Give us a shout..

Thursday, November 29, 2012

What does TFS cost?

Ever been given the run-around on what it actually costs to have TFS running?
Let’s see if I can break it down.

Note: I’m using retail prices for these examples, so this is the ABSOLUTE maximum that you would pay. There are a couple of licensing agreements that could see you paying a great deal less.

We all know that you get a TFS Server license and CAL when you have an MSDN subscription, right? So if you license your developers with MSDN subscriptions you have the right to install TFS and each developer with an MSDN subscription is allowed to access TFS. If you do not have MSDN subscriptions or have a “Partner Action pack” then you would need to purchase a $499 Server license and a $499 CAL per person accessing TFS unless they fall into an exempt list (discussed a bit later)

What the TFS Server license includes is obviously the ability to install and run TFS and it grants “limited rights” licenses to use:

  • SQL Standard
  • SCVMM if you have any of the following subscriptions
    • Ultimate
    • Premium or
    • Test Professional 

The “limited rights” means that you are only allowed to use SQL for TFS and SCVMM for Lab Management. If it is going to be used for anything else, you need to license it separately and obviously if you already have SQL or SCVMM licensed you can use those.

So now you have TFS and some of the components, but you need to install it on an operating system which will need to be licensed separately. If this is going to be a production server (basically the definition of “production” is that there are big problems if you lose it), the OS licensing is NOT covered by MSDN, you would need a separate server license ( About $882 for Windows 2012 Std ).

So we have TFS and we can install it on a server. Here is the tricky part…regardless of the fact that Windows 2012 is a per-processor license, you still need a Windows Server CAL ( $199 for a 5 CAL pack) for anyone who is going to connect to TFS (whether they are exempt from a TFS CAL or not)

So we end up with something like this:

image

TFS CAL Exceptions

As mentioned earlier, there are a couple of exceptions with the requirement of a TFS CAL. You do NOT need a TFS CAL when (snipped from the VS 2012 licensing white paper):

  • Entering work items through any interface, and viewing and editing work items you created. This enables users to enter and edit their own work items of any type.
  • Accessing Team Foundation Server reports. Any read-only data that comes from the Team Foundation Server SQL data warehouse or is surfaced through SQL Server Analysis Services would be a report, but custom reports could also be written to call into Team Foundation Server APIs and could also join that data with other data sources.
  • Accessing Team Foundation Server using Microsoft System Center Operations Manager. This enables operations staff to take operational issues encountered in production and raise them as issues to the development team, automatically creating a work item in Team Foundation Server.
  • Accessing Team Foundation Server using the Feedback Client for TFS. This allows the user to provide Feedback about an application into Team Foundation Server.
  • Viewing static data that has been manually distributed outside of Team Foundation Server.
  • Up to two devices or users that only access Team Foundation Server to perform system administration, such as creating Team Projects or Project Collections.

TFS Express

Microsoft has also brought out TFS Express which runs on SQL Express and is limited to Version Control, Work Item Management and Build. TFS Express does not provide any of the reporting capabilities or allow for SharePoint integration.

It does however allow up to 5 users without the requirement for a CAL, only the 6th person and up will require a CAL. So this makes a good starting platform for smaller teams. The OS still needs to be licensed though.

Levels of CAL

It also needs to be noted that there are “levels” of CAL’s when looking at TFS. To use the Backlog and Sprint Planning Tools and the Request and Manage Feedback features you need to have either a VS Ultimate or Premium MSDN or a Test Professional MSDN subscription.

Summary

So let’s take a simple scenario. You are 5 developers with MSDN subscriptions. To run TFS in a production environment the costs look like this:

TFS $0 (covered my MSDN)
TFS CAL $0 (covered my MSDN)
Windows Server $882
Windows Server CAL $199

Total:

$1081

If you do not have MSDN subscriptions the picture would look like this:

TFS $499
TFS CAL $2495 ($499 * 5)
Windows Server $882
Windows Server CAL $199

Total:

$4075

I hope this clears up some of the questions that I get posed fairly often.

References:

Thursday, August 2, 2012

Visual Studio and Team Foundation Server 2012 Launch Dates

Microsoft has finally “lifted their skirt” regarding the release of the much anticipated VS and TFS 2012.

For more info Jason Zander is the man

Friday, June 1, 2012

Visual Studio & Team Foundation Server 2012 RC

Yes, Visual Studio vNext or VS 11 has finally got a name.
Microsoft has dropped the release candidate for Visual Studio 2012 and Team Foundation Server 2012.

There seems to be quite a significant amount of changes, and I’m glad to see that a lot of them were requests and issues raised from the “community”.

For more information have a look at these:

Download the bits over here.

So much goodness, so little time…

Thursday, May 17, 2012

Rename or Clone TFS 2010 Server

Ever been in the situation where you wanted to make a clone of a production TFS environment, or just needed to rename the server?
Well, I needed to do exactly that for a client recently and spent a couple of hours banging my head on SharePoint in particular.
SharePoint is a very problematic renamer, and I will need to cover that in a separate post, but the rest is fairly straight forward.

Note: I’m assuming that the the login used to perform these tasks is a administrator on the server..

MSSQL Server:

Open up SQL Server Management Studio (or your favourite SQL tool) and connect to the database server. You will notice that if you execute “select @@servername” it will return the “old” or previous server name.

To update this you need to execute the following (replacing the <<oldserver\instance>> and <<newserver\instance>> with your appropriate server names (and instances if applicable):

exec sp_dropserver ‘<<oldserver\instance>>’
GO
exec sp_addserver ‘<<newserver\instance>>’, local
GO

Reporting Services:

Open up “Reporting Services Configuration Manager” and connect to the server, then select “Database”.
Select “Change Database” to display the change wizard.

Select “Choose an existing report server database”, enter the new server name in the next page. Next select the “ReportServer” database and then “Next” until you can “Finish” after verifying settings and applying security scripts.

That should take care of SQL and Reporting Services

TFS 2010:

If you were to open up TFS Administration Console you would find something like this:
image

I must admit that I was surprised (after a bit of digging) that the only change needed to point it to a new server was in the web config file. So go to the TFS web services directory ( By default : %system drive%\Program Files\Microsoft Team Foundation Server 2010\Application Tier\Web Services) and open up the web.config file. In the config file, find the <appSettings> and change the connection string for the “applicationDatabase” to point to your new server name.

Open up TFS Administration Console and you should see some values pulling through now.

The next step is to change the url’s for TFS. In the TFS Administration Console under “Application Tier” select “Change URL’s” and update accordingly.

Now we need to “fix” reporting services. Select “Reporting” in the tree view and click “Edit”. Go to the “Reports” tab of the edit dialog and change the server name. Select “Populate URLs” to reload the correct config.

image

If you do have “schema problems” with either the warehouse or analysis services database, you can change the name and TFS will re-create the databases for you.

Now all that is left to do is to make sure that the project collection’s SharePoint site bindings are correct and you should be A for away..

If this is too dodgy, the next option would be to create a new server from scratch and “port” your existing environment over. I can tell you from experience that is is also not as straight forward as you may think, after all “it is just SQL databases…” backup and restore – right?! …. wrong - but I’ll leave that for another post.…

Tuesday, April 17, 2012

VS 11 : Team Explorer

One of the many things that has received a redesign in VS 11 is Team Explorer.

image

(Notice the “Search Work Items”)

Yes – if you are sharp, you may have noticed that this is from the “dull” Visual Studio 11 Beta.

Now this is a tricky one to get to grips with. I’ve been using it almost daily for the last 2 or so months and I’m yet to get used to the navigation between the “pages” or views.

Where we were used to having everything in a tree view, things have changed a bit and everything is grouped into its own page.

Take the work item view for example:

image

One thing that I’m sure the TFS guys will still work on is the association between work items and the check in.
To associate a work item (if you do not know it’s id) to the check in you follow the following steps:

  1. Go to the work item view, select the query to run and display all the work items
  2. Navigate to the home page and select the “Pending Changes” option
  3. Drag the selected work item from the result view into the “Related Work Items” section

A bit laborious if you are new to TFS.
Now in all fairness, and after you figure out how to use it, there is (yet) another view that manages your “work” a bit better. It does work like a charm if you are using TFS and follow the conventions that the work item flow imposes on you.

image
One thing that I think is absolutely amazing is the code review functionality. Like I said before, I’ve been using VS 11 for a couple of months and primarily work in a distributed team environment. The code review works like a charm for us – especially when you are not available to do the review at the point in time that it is requested.

You go to the “Pending Changes” or your “My Work” view and select “Request Review” to open up the request view.

image

Select one or many reviewers from the team members assigned to the project and then submit the request.

This sends a request to the reviewer, and when he/she opens up the “My Work” view, the request is waiting. The reviewer can then accept the request and use the brand spanking new diff tool to perform the review, adding notes on a line or file level and finally send the resulting comments back to the requestor.

image

Behind the scene this process is achieved by using a mix of work items and shelve sets, and this was one of the big drivers that I had to adopt TFS 11.

I’m sure that there is still going to be some work involved and this is not the absolutely final version, but it sure does make me excited for when the RTM lands…

Friday, March 9, 2012

TFS For everyone…

Some really cool news from Brian Harry this week. The licensing model for Team Explorer Everywhere (TEE) has been changed to reflect Team Explorer’s model. This means that TEE is now freely downloadable (previously you had to purchase the software). All you need is a CAL for TFS (same restriction as on Team Explorer).

This really opens up the TFS environment to non Microsoft developers out there..

This licensing model combined with TFS Express means that you can setup an environment using VS Express and/or Eclipse with TEE connecting to TFS Express, free for up to 5 people.

Microsoft Analyst / Tester event in Cape Town

Anyone that is interested in an overview of managing and tracking requirements, bugs and test cases with Team Foundation Server, Visual Studio and/or Microsoft test Manager, I’ll be presenting an event at the Cape Town Microsoft offices next week.Check it out

Calling all Analysts and Testers: Improve the delivery and quality of your projects (CPT, 13 Mar,free)

This event is in CPT. The equivalent JHB event, which has been blogged about before, can be found here

Are you a tester or analyst on your team? Do you still track your requirements, test cases and bugs manually using Word, Excel and Outlook? Are the bugs you find difficult to reproduce and you have challenges on getting visibility on the quality and project status?

As software grows increasingly complex, quality assurance can no longer be an afterthought. An inefficient or isolated testing process can hinder software quality, reduce time to market and drive up costs. Microsoft is hosting an event to help your organization avoid these potential pitfalls by making testing and quality assurance an active part of the application lifecycle.

DATE/TIME: 13 March - 08:30: -10:30

VENUE: Microsoft South Africa, Golf Park 3 ,Engen HouseRaapenberg Road, Mowbray

COST: FREE

REGISTER : https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032505806&Culture=en-ZA

see you there…

Friday, February 24, 2012

Visual Studio 11 & .Net 4.5 Beta Imminent

Finally the BETA release for Visual Studio 11 has been announced. I wonder if it is going to be a good or bad omen, releasing it on the 29th !?

In addition to this Brian Harry has also covered an Express version of TFS making it easier for smaller teams to start adopting TFS. This should also make the decision a lot easier for start-ups considering version control systems that will be able to grow with them.

If that was not enough, another BIG bonus is that Visual Studio Express will be able to integrate with TFS!

For a list of links and announcements around this development check this out

Things are starting to heat up now!!!

Monday, January 23, 2012

Visual Studio vNext or VS 11

I started playing around with TFS 11 and Visual Studio 11 shortly after the announcement of the Developer Preview. Unfortunately (or fortunately) things started getting pretty busy with the business and the time disappeared.
Finally I have been able to polish off some of the posts that I started and will be posting these as time allows. So let’s start at the beginning:

 

Convert Project

The first thing most people do (I’m sure) is to open a solution, and the first difference shows itself. Thinking back, conversion from one version of Visual Studio project file to the next became a “blind” next, next, next operation. The new dialog almost took me by surprise. The standard csproj or vbproj files does not need to be converted (this is actually a feature in VS 11) and the smaller projects that I opened worked fine. Obviously something has changed with the Modelling Project and the Database Project (I’ll get to that in a later post).

clip_image002

 

Solution Navigator Explorer

Once your project files are up to date, the next thing you will notice is that Solution Explorer has changed a bit. Anybody familiar with the “Visual Studio Productivity Power Tools” would recognise this as the “Solution Navigator”.

clip_image003
Finally the “Collapse All” image is a standard feature (It took long enoughWinking smile ). Other nice features include the search box, the ability to navigate “into” the file, class and method definitions and the Back and Forward “Navigation” image buttons allowing you to “navigate” from one search result to the next.


Tuesday, November 1, 2011

Visual Studio and TFS extensibility

I came across this post by David Baliles listing a whole range of add-on’s to TFS and Visual Studio.

Whenever I speak to anyone that will listen I keep on re-emphasising the extensibility of TFS and Visual Studio. It really opens up the potential that lies within the applications, making it available to people and environments that no-one would ever have thought possible.

Together with this there are the people that actually take the time to solve their problems and then make their solutions available to the world. I really commend these individuals for their passion and effort.

David’s list just emphasises the extensibility and the community that surrounds it.
Have a look – it is a really interesting list, I’m sure you may find something that you have been struggling with…

Monday, October 24, 2011

Customising TFS Work Items

Work Items in TFS forms one of the primary “abilities” that Team Foundation Server exposes. A work item is a generic object that you use to record various “things” in TFS. The type, structure and workflow is defined as part of the process template as a work item definition or type. The MSF for CMMI process template has different work item definitions than for example the Scrum template would have. Work item definitions is also the closest that TFS will get to “exposing” or modelling a methodology.

In my business I often get requests to change or adapt work items to include fields that are important to the customer or to alter the workflow to better represent the process that is used internally in the customer’s team.

The work item definition is at its heart an xml schema containing fields, rules, form layout and workflow associated to the specific work item.
If you have a good xml editor you can export the work item definition using the witadmin utility, make your changes and then import it back into TFS using the same tool.

Of course if you don't feel like wading through all those angle brackets you can get hold of the TFS power tools and use the process editor.

After installing the power tools, select “Tools –> Process Editor –> Work Item Types” from the Visual Studio menu. You have the option of importing or exporting work item types (WIT),  editing types directly on the server or locally (using an exported WIT).
Good advice would obviously be to first export a WIT, make changes and then import the changed WIT if you are using a production  instance of TFS.

A note: As mentioned previously, the different types of work items are defined as part of the process template. For example the MSF for Agile template would yield the following work item types:

image

After selecting a work item the work item editor will open

image

You are now free to add new fields, change the work item form and alter the workflow.

It is simple enough to change the work item definitions using the process editor but you still need to take note of the following:

  • Make sure you know the difference between the a Dimension, Measure and Detail when setting the “Reportable” field
  • Make sure that you have a good understanding of, and cover all paths when changing the workflow for the work item
  • When customising a work item it is important to remember that if you change the work item definition on a team project, the change will not be reflected on other team projects unless you manually update them. One way to overcome this is to alter the process template and include the changed work item definition in the process template. Next time you create a new team project those changes will be present.

 

Friday, September 30, 2011

Team Foundation Server is Version Control

This is a part of the blog posts surrounding the misconceptions that surround TFS. For the first post see TFS is expensive.

Team Foundation is Version Control…

There are a lot of debates raging (and have been for a long time) about how inferior TFS is when it comes to version control. Obviously the favourite comparison has always been between TFS and SVN, but these days the comparison is also shifting to the DVCS style of version control systems.

TFS version control (IMO) has always done what was needed. There are a lot of nit-pickers who look at the specific functionality that TFS does not support, but once again – I have used SVN and TFS and found that a lot of these features were really just “nice to haves”, and in most cases TFS did have a work around in one form or another.

The main thing that I feel is not addressed when people make these comparisons is the fact that TFS “IS NOT” version control. Version control is merely a feature, one of the components that make up TFS.
TFS is an ALM suite. It covers a much broader spectrum than just version control.

There are a lot of misconceptions around ALM as well. In fact, one of my large corporate clients was very keen to check the “we do ALM” checkbox after they started using SVN. Using version control does not mean you are addressing the full ALM!

So that said, one of the things that really excites me about TFS is the rate at which it is evolving. The “problem areas” are being addresses as the product matures. I’m sure you would have heard of TFS 11 & VS 11 by now.

Just looking at the changes that Brian Harry and his teams are making to TFS version control, it is going to be yet another game changing release:

I’m off to get my hands dirty with the TFS & VS 11 developer previews…