Brian Harry's blog

TFS Power Tools for the RC

2012-06-01T10:53:30Z

We won't be releasing a new build of the Power Tools with the Release Candidate. The Beta Power Tools that are available will work with the RC build. The next time we'll update the Power Tools will be along with the final release. Please let us know if you find any problems.

Brian

A Community for Storyboard Shapes

2012-06-01T01:47:27Z

A while ago, I wrote a post about the importance of feedback in the software development process. In that post I introduced a new storyboarding tool that we’ve built as part of the VS 11 wave of products that enables you to collect feedback on your designs before you write a line of code. In the product, we ship a bunch of pre-canned shapes – Windows, Web, Sharepoint, Windows Phone, Windows 8, etc. But once you start storyboarding, your imagination can run wild with all of the different ideas of shapes and visuals you might want to use in applications. Of course, you can use any PowerPoint shape or bitmap in existence but tailored application shapes are valuable.

One of our aspirations is to create a community of people sharing shapes they’ve built – thereby helping everyone else design better, cooler apps. To assist with that, we’ve added a new category on the Visual Studio Gallery for Storyboard Shapes. We’ve also prepopulated it with some additional shapes that we’ve built (we hope you find some of them creative ). Here’s a screenshot of what the Gallery site looks like.

We’ve created subcategories and tried to make shapes easy to find. The shapes templates can be free or paid – all the ones we’ve created so far are free. Installing them is super easy. Just…

Pick the shapes template you want
Click download to load them on your system
Click the 'Import Shapes' button on the Storyboarding ribbon in PowerPoint and select this file

Then you can start designing new storyboards with the shapes.

We’ve also tried to make the download site easy to find. Inside PowerPoint, on the Storyboard shapes window, we’ve provided a “Find more Storyboard Shapes online” link that will take you to the VS Gallery and land you on the Storyboard shapes page.

You can use these shapes libraries with the storyboarding tool in the VS 11 Release Candidate we released today and with the RTM version when it is available. In addition we are working on some additional libraries that we hope will be available soon – like iPhone and iPad but we hope you all will come up with lots of great ideas and share them.

So using them is really easy, but what about creating them? Well, it’s a hair more complicated. Our storyboarding tool is a PowerPoint plugin and our shape libraries are just PowerPoint shapes, right? Yes and no. Yes, they are PowerPoint shapes, but, we’ve added the ability to annotate them with metadata the storyboarding add-in uses.

The most important of these is sizing behavior. When you size a PowerPoint shape, just stretches everything. If you are resizing a list, you don’t want to stretch the list contents, making the individual items, scrollbar, etc. unnaturally bigger. You want to stretch it and have some aspects stretch and others stay the same. To do this, you annotate your shapes with sizing metadata that tells the tool how you want your shapes to stretch. For some shapes, uniform stretching is fine and you don’t need to bother. For others, it’s pretty important.

We also use metadata to annotate shapes with search keywords, category information, etc. to make your shapes easier to find.

All this metadata is just entered as notes on the PowerPoint slides containing your authored shapes. When you’re done with your shapes, you use our “shape compiler” (which admittedly is a goofy command line tool for now) to compile your shape into a shape library (.sbsx file) that can be imported into PowerPoint and used for Storyboarding. The Storyboarding tool download also includes instructions on how to annotate your PowerPoint shapes.

The shape library can also be uploaded to the Visual Studio Gallery by clicking on the Upload link towards the upper right hand corner of the VS Gallery page. You will then be asked to choose what Extension Type you are uploading (in this case Storyboard Shapes).

You can then either upload the shapes file or enter a link to your shapes.

In the event you want to charge for your shapes, you can advertise them on the Gallery but you’ll need to enter a link to your own commerce site. The Gallery doesn’t have any way to collect money directly.

Lastly, you can fill out the information for your VS Gallery download page:

We hope all of you find the Storyboarding shapes on the Gallery useful and we hope some of you take the time to demonstrate your creativity and share some of your own designs.

Thanks and happy storyboarding

Brian

Visual Studio/TFS 2012 Release Candidate Available Today

2012-05-31T19:05:00Z

Today we released the Release Candidate for VS, TFS and .NET (and, of course, Windows also released their RC). You can learn more about it and download using the following links:

Visual Studio Product website
Eclipse update site for the latest Team Explorer Everywhere preview or the download page
Overall summary of changes since the Beta
Jason’s blog post on the RC release
For filing bugs: Visual Studio and TFS, LightSwitch, or Blend Connect sites
For asking questions: Visual Studio and TFS or Windows forums

Here are a few notes on the changes in TFS since the Beta. Of course, we’ve done a ton of testing and fixed a lot of bugs. So it should be even more stable than the Beta. Here’s some of the feature enhancements:

Feature Enablement – This is a new capability in Web Access that allow you to enable new features (like Code Review, feedback, the Taskboard, etc) in your process template without having to break out your favorite text editor and start hand editing your process template XML.

Query launcher in Pending Changes – We heard the feedback that people wanted an easier way to associate work items on checkin. We added a Queries drop down to pending changes allowing you to launch a query and then drag & drop a work item into the associated work items list.

Changes to Version Control context menus – We’ve received plenty of feedback that some of our context menus – particularly Solution Explorer and Source Control Explorer, are just too long? Remember the horrible scrolling menus? We made some changes to move some of the less frequently used version control menu items into a tear off menu. Of course if you want them back on the main menu, you can use VS menu customization to move them back. We think, though, this will provide a better default experience for people.

Color, theming, and icons – We made some additional improvements to our colors and theming – a particularly good example is Source Control Explorer in dark theme. It looked horrible in the Beta and it looks pretty good in the RC. Some of our tool windows still don’t look good in dark but we’ve tried to get the most common ones for now and will get the remaining ones as soon as we can. There are still a few improvements to come for RTM but we’re getting close.

Keyboard accessibility for drag/drop in backlog – use Alt + Up arrow or Alt + Down arrow to move items around in the backlog.

Improved upgrade guidance – It’s still work in progress but we’re working hard on untangling the mess of possible upgrade combinations and making it easier for people to choose a path and have clear concise guidance for it. Check the current draft out here: http://go.microsoft.com/fwlink/?LinkId=245977

Improved TFS database restore – Knowing that a lot of people will choose to take the opportunity to move their TFS server to new hardware as they upgrade to TFS 11, we’ve build some new tooling to make restoring your database easier. You no longer have to figure out how to use SQL Management Studio to restore one database at a time. Our new wizard can easily restore all of your TFS databases at once. You’ll find it on the welcome page of the upgrade wizard.

Improved Task Board for touch – We’ve made a bunch of improvements to make our task board more touch friendly.

Filter for areas/iterations in Web Access – For teams that have lots of areas and iterations in a Team Project,, they can be hard to wade through and find what you are looking for. We added a simple filtering ability to the Web Access pages that show them to filter them to just the ones that apply to your team.

Team Explorer Everywhere improvements

Bring more of the new Team Explorer experience -

Moved Pending Changes view into Team Explorer, aligned with VS11 experience including candidate detection,
Implemented Favorites in Team Explorer. Storage of favorites is now in your TFS Server so that are synced between VS, Eclipse and the Web
Provide a quick way to switch workspaces and detect local changed in the new Team Explorer

Easily convert between Server and Local workspaces – This is now available in both TE and TEE.

Shared .tfIgnore capability between VS and TEE – enabling you to fully share workspaces between VS and TEE

Improved build report

Hosting of web work item form - Ability to use an embedded version of the work item editor from web access (handy if you have custom work item controls that you don’t want to have to write for both web and Java)

TFSPreview support on latest Mac OS X - Work-around for a WebKit bug in the latest Mac OS X update (https://bugs.webkit.org/show_bug.cgi?id=79206) which was preventing authentication against tfspreview.com

Support for the latest Eclipse Juno RC1 build on Windows, Mac and Linux – Juno will RTM in a few weeks and we support it starting now.

As I mentioned above, there will be a handful of additional things coming between RC and RTM but it has settled down pretty well and at this point we’re just polishing of testing and bug fixing and getting ready to ship it. I’m excited to be so close the the end of another really good release. I’ve got a set of posts coming over then next couple of weeks on related announcements (Power Tools, etc). Stay tuned as we tie a bow on this wave of products.

Brian

Progress on CodePlex pull requests

2012-05-19T11:35:05Z

If you checkout the CodePlex suggestions and feedback, you’ll see that the #1 top voted item involves improvements in pull request workflows.

For the second week in a row, we’ve released some nice improvements (along with other bug fixes and minor improvements).

We’ve got several more weeks of work to do to continue to drive improvements in this experience and then we’ll pick another thing off the list of feedback and continue to improve. If you are a CodePlex user, follow the CodePlex blog and please share your thoughts on the most important things we could do to make the CodePlex experience great for you!

Brian

that CONFERENCE

2012-05-16T17:10:39Z

I got a request from a friend to mention a new conference that’s coming up this fall in August in Wisconsin. It looks like a good opportunity to stay up to date on the latest technologies and rub elbows with your peers. Check it out if you are interested.

http://www.thatconference.com/

Brian

Formal Requirements with TFS and InteGREAT

2012-05-16T13:21:57Z

Over the past couple of weeks I’ve spent a fair amount of time our visiting with customers and potential customers. Much of it was spent talking about the new stuff coming with TFS/VS 11. One question that came up at probably 1/3rd of customers I visited is how to do formal requirements with TFS. If you’ve looked, you’ve probably noticed TFS doesn’t have a built in formal requirements solution. We did some work in VS/TFS 11 and Test Professional 11 to support what we call “Agile Requirements” – important feedback loops with your stakeholders. But for some organizations, formal requirements are a must – Requirements documents, detailed traceability, requirements baselining, business process diagrams, etc, etc.

Several years ago we found a company called eDevTECH with a product called InteGREAT. It looked a very capable and promising product so we approached them about partnering with us to turn it into a really terrific formal requirements management tool for TFS. InteGREAT continues to evolve and is now a terrific companion product for business analysts wanting to do formal requirements with their TFS based development/test team. It is also complements well the Agile Requirements capabilities we added in TFS 11.

I’ll give you a very brief overview of the kinds of capabilities in InteGREAT. If you want to learn more check out their website links above or this joint webinar we did recently.

InteGREAT connects directly to TFS the same way all the rest of our TFS client products do and stores its data in TFS.

It has a broad set of requirements management capabilities…

It enables you to enter requirements in a simple tree grid form…

Or you can edit them in a semi structured document form…

You can also caption business process diagrams…

All of these requirements are stored in TFS, available for the development team to see through requirements work items. They are bi-directionally synchronized. And all of you development team work artifacts – user stories, tasks, test cases, etc can be linked to the TFS requirements.

Not only does InteGREAT provide a seamless way to get requirements into TFS, it provided some great capabilities to help you build good requirements, like a library of predefined spec templates…

And questionnaires to help you make sure you are collecting all the relevant information…

And, of course, InteGREAT provides some good tools for establishing and visualizing dependencies, creating and reviewing baselines, etc….

Further InteGREAT can help you by automatically generating test cases for your process models…

As you can see, there’s a lot of great capability here. It’s a great solution for teams looking for formal requirements. Check out the links at the top of this post to learn even more.

Thanks,

Brian

Team Explorer Everywhere in the Eclipse Marketplace

2012-05-15T21:09:00Z

Several weeks ago, I announced that we’d be removing the price on the Team Foundation Server Eclipse plug-in. One of the benefits of this change (aside from begin cheaper ) is that it’s easier to keep your plug-in up to date because we can use the standard Eclipse update mechanisms.

Team Explorer Everywhere is now on the Eclipse Marketplace…

http://marketplace.eclipse.org/content/tfs-plug-eclipse

and we have an Eclipse update site…

http://dl.microsoft.com/eclipse/tfs

Of course, update site links are to be entered into Eclipse for update notifications, etc – not viewed with a browser.

Brian

Some insight into our 4/26 deployment

2012-05-15T21:08:19Z

This is a post I wrote about a week ago and somehow left it in my drafts folder. Though it’s “old” now, I think there’s still some good stuff here… The good news is the deployment we did today seems to have gone off without a hitch (knock on wood)!

We did a TFSPreview.com deployment on 4/26 and you may have noticed that we suffered a few hours of down time. It’s the first upgrade we’ve had go really bad in a long time – the last several have suffered little or no down time. I wanted to share a little bit about what happened and what we learned from it.

Some context

First, let me set some context. In my post the other day about changes, I mentioned that there were a lot of non-visible infrastructure changes. There’s a bit of backstory there, that’s provides some context. We’ve generally taken a fairly incremental approach to moving TFS into the cloud. We’ve also been evolving our thinking what what the offering/business model would look like. One of the changes in our thinking is that the service will be lower cost and have more free accounts than we had expected from the beginning. No, I don’t have any details to share on that now we’re still working it out. Suffice it to say that just merging Codeplex with the service (which I’ve alluded to in previous posts) shifts the model a good bit. The result is that the straight port of TFS where every project collection is a separate database wasn’t going to work from a cost perspective. We concluded a few months ago that we needed to move to a multi-tenancy model, for at least a portion of our accounts.

We implemented database multi-tenancy over the past couple of months and we finally rolled it out in this last update (though the dial on tenancy is still set to 1 tenant per database for now – we will begin to turn that dial in the coming weeks). As you might imagine, this was a pretty impactful change. It affected virtually every feature area to, at least, some degree. And more than that, it was a pretty big schema change to the database – logically, we had to add a partitioning column to every table in every database.

Add to this that we also had some sizeable changes in the communication protocol in the build farm and this was a big release. In fact big enough that we missed our deployment windows 3 weeks before (the first scheduled deployment we have ever missed), but that’s a story for another day. Suffice it to say that this was the biggest and most impactful deployment we’ve done in the last 6 months.

And things didn’t go well

Because it of the nature of the update, we knew we were going to have to schedule some downtime – most of our updates are fully online and only individual tenants are down at any given time, and generally only for a couple of minutes – the overall service is not down. But this update was different because we also had to make significant changes to what we call the “config DB” – it’s the one central database we have that stores global service configuration and data. So we decided to start this update at 4:00am to minimize the impact (of course, on a global service, there’s really no convenient time).

At 6:28am PDT the upgrade failed. We quickly got devs investigating.
By 7:06am we had a fix
At 7:20am the upgrade was resumed.
At this point the upgrade was running slower than expected and we were investigating.
At 9:07am we patched a query plan to improve performance
At 9:23am the offline portion of the upgrade was complete.

All told, it was about 3 hours and it should have been less than 1 hour. Clearly not what we want and there’s some good stuff to learn from here. However, I want to say that I’m very proud of how well the team handled the problem. The right people were on top of it, quick to respond and quick to move the issue to the next stage. Their diligence is what kept it to only a 2 hour delay.

It turns out that the root underlying problem had to do with the way the upgrade scripts were authored. We did not pay enough attention to how the upgrade steps were arranged into transactions and the primary failure was caused by one of the upgrade scripts on the config DB doing too much work inside a single transaction. It exceeded the capacity of the SQL log and caused the transaction to roll back. The remedy in this case was to clear out the offending table – it turns out the data in the table that pushed it over the tipping point was transient data that was only relevant while the service was active. Since the service was down for upgrade none of the data was necessary and could just be deleted. To be safe, we also reviewed and made other defensive changes to the upgrade scripts.

Things like log space and temp db space are bigger considerations on a shared database service like SQL Azure than than might be on an enterprise SQL Server. The shared service has to limit carefully how much resources a single tenant can use to prevent them come compromising other tenants.

So what did we learn?

Every one of these is a learning opportunity. Every time we do something new (in this case a large schema change with a fairly large production data set) we learn new things. Some thoughts…

Be thoughtful about transaction size. As we go forward we’re going to make sure we include careful consideration about transaction size in any of our database upgrade scripts. Our current default authoring mechanism groups all upgrade steps into a single transaction. In the future, we’ll require developers be explicit about how upgrade steps are grouped.

New insights on upgrade testing. This one is more complicated that you might imagine. There’s a saying “There’s no place like production.” It means that no matter how hard you try, you’ll never be able to fully simulate your production environment – things will still go wrong. There’s diminishing returns on your effort to simulate production with increasing fidelity. However, that doesn’t mean you shouldn’t do anything. We don’t try to fully simulate production. It’s 10’s of thousands of databases and a ton of data. Just creating the simulation might take longer than our whole development cycle. However, given that config DB is such a core dependency for our system, there’s no reason we couldn’t have tested the upgrade scripts against that database. In the future we will. We did, of course, test it against other config DBs but they were smaller.

Listen to your gut. One of the ironic things here is that the day before the upgrade, the team considered truncating this table as part of the upgrade. It was discussed and ultimately discarded because the upgrade process hadn’t been tested that way and they were being risk averse. Often, in these kinds of situations, your instinct is good. There’s no question you have to be careful about last minute changes but all too often I’ve seen production teams there error on the side of being too change averse resulting in lower overall application health than necessary. When your gut says you may have an issue don’t dismiss it just because “it’s not in the plan”.

Stuff will go wrong. You can’t stop it. Sometimes your best offense is a strong defense. Be ready to jump on things quickly. Have the right people ready.

Communication. I’m a very strong advocate for communicating clearly and openly with your customers when you have issues. It’s something I’ve practiced religiously with our internal service. This incident has made me realize that we don’t have great mechanisms set up for this for our public service. We have a service blog that shares status and we update Twitter. But it’s not good enough. Issues include:

We need a better way to give notice about upcoming significant servicing events. It can’t rely on you trolling Twitter or watching our blog. It needs to be evident in a tool you are likely to be using.
Our blog format is not great. The information isn’t structured well enough to help you understand what you really need to know about and it’s too focused on current status without enough about why it’s happening or what to expect.
Our error messages are not helpful in this scenario. “TF30040: The database is not correctly configured. Contact your Team Foundation Server administrator.” just isn’t going to cut it.

Conclusion

It’ll be a while before we make another change of this magnitude. so we’ve got a little time to work out some of these issues before we’re like to have another test like this. Thank you for bearing with us as we work through the learning process. We know an increasing number of people are relying on our service to get their work done and outages are simply not acceptable. Our goal is clearly no outages – ever, for any reason. 6 months ago all upgrades were “offline”. Now most are online. Our goal is for all of them to be online.

Always interested in your feedback and appreciative of your patience,

Brian

Team Foundation Service Updates – 5/15

2012-05-15T18:39:00Z

**UPDATED 5/15 @9:21EDT** Drag and drop of tiles has been enabled now for a few hours and I just updated the "Improved logout section" with a screenshot.

It’s that time again. Our next sprint is complete and today we’ve updated hosting service with new bits. In general, the list of new capabilities is still modest. Much of our attention is still focused on tying a bow on TFS 11 and some continued hosting infrastructure work – some of which I’ll mention here. So, the notable changes in this release include:

Copy capacity from previous sprint – Setting up a new sprint can be tedious and one sprint is often a lot like the previous. So, one step we’ve taken (and you’ll see more next sprint) is to enable you to copy your sprint capacity from the previous sprint. You can then tweak it if you have changes for the current sprint.

Reorder homepage tiles – In TFS 11, we added the ability to have summary tiles on the project homepage that rendered some useful info from your various “favorites” (queries, checkin history, builds). We’ve now added the ability for you to organize the tiles the way you like best. You just drag and drop the tiles where you want them. Note this particular feature is under a feature flag (see the item below) and won’t be enabled until late in the update cycle.

Expand/collapse query results – We added buttons to easily expand all/collapse all hierarchical work item query results.

Improved logout – If you’ve tried using multiple LiveIDs with TFS then you know that switching can be a pain because you have to logout both from our service and from live.com. We’ve improved that – though it’s still not perfect. Now we chain the logout of live.com so, if you log our from TFS, we’ll automatically log you out from Live. Unfortunately you still get an ugly browser page that says you haven’t completely logged out yet. We need some additional support from Azure Access Control Services before we can fix that but we will fix it. Here's what the less than ideal final logout screen looks like.

Feature switches – Feature switches are an important piece of infrastructure that allow us to deploy features and not have them visible. We can then selectively enable features for different accounts. This enables us to test features in production and to run beta/preview testing with select groups of customers. It will enable us to better understand the impact of new features before unleashing them on the world :)

Improved performance for the job scheduler – As the service continues to grow, we started to hit scalability problems with the background job scheduler (it executes any long running background tasks – project creation, upgrade, identity synchronization, etc). We’ve change the way we dequeue jobs and partition them across agents that has resulted in about a 10X reduction in the overhead and should generally improve the performance of the background jobs and reduce load on the system.

Build agent reimaging – Until now our build service used Windows login profiles and ACLs to isolate one build customer from another. In reviewing this with the Azure team, we concluded that this was not fool proof enough. We’ve moved to a model of completely reimaging each VM after a tenant’s build completes. This way there is no chance that anything is left over for a subsequent tenant to try to “sniff”.

Multi-tenancy – Until today, every tenant in Team Foundation Service got their own Team Project Collection SQL Azure database. As the service scales, this is not going to be cost effective for the full range of customers we expect to have. In the last sprint we deployed some key infrastructure changes that would enable us to store multiple tenants in the same database (with no leakage of information). In this sprint, we will actually start combining some of the tenant databases. This will be a multi month effort and, in the long run, I expect we’ll offer varying levels of quality of service at various price points. This is one of many dials we can turn to adjust cost vs quality of service.

There were, of course, lots of other small changes.

It’s great to have another deployment behind us. It will take several hours for it to roll through all the accounts and update them all. You may go to the service and not see the new changes. If you don’t see it by tomorrow morning, let me know and we’ll investigate.

Brian

Update on building Win phone projects on the build service

2012-05-14T12:56:48Z

It doesn't work right now because the Phone tools SDK isn't installed on our build agent images. We've been talking with the phone tools team about this. The blocker that we have is that the Phone tools SDK can't be installed on a server edition of the OS (it's blocked). Add to that the fact that you can only run server OS editions on cloud environments and you have a recipe for "no-worky". The Phone tools SDK team has commited to doing the work to unblock the Phone SDK on a server OS edition. I don't yet have a timeframe for that but I'm guessing within the next couple of months.

Brian

Update on the VS 11 UI

2012-05-08T17:23:00Z

There was quite a lot of feedback after we released the Beta about the new UI style in VS 11. We've been processing that feedback and working to improve the look and feel. We've just released a new blog post on changes to the VS UI in our upcoming Release Candidate. Check it out and please share any feedback you have.

Brian

Codeplex UI Refresh

2012-04-30T21:27:46Z

Today we launched our new Codeplex look and feel that I previewed a few weeks ago. As I said then, we’ve redoubled our effort on Codeplex and you should expect to see it evolve fairly rapidly. First Git support, now a new look. What’s next? Stay tuned and you’ll see.

Check out Mark’s blog post to see how we’ve both improved the look and simplified the experience. Or visit Codeplex and check it out for yourself.

Brian

TFSPreview update

2012-04-30T19:50:06Z

Last week we rolled out an update to TFSPreview. The majority of it was underlying plumbing changes to improve operations, diagnostics, cost, etc. As we roll off our TFS 11 work, we’ll see more and more of our effort show up as new service capabilities. That will mean more improvements, faster.

The two biggest things we did in this latest release were:

Rewire some plumbing for the build service to reduce the amount of time it takes for a hosted build to start. There used to be some queue delay but now it should generally get started faster
Implement some capabilities that will ultimately allow us to have different levels of quality of service for different customers and overall increase the density, lowering our costs.

But beyond that, there were a few visible changes as well.

Some styling changes – particularly around sign in/out. This is a tiny glimpse into a much bigger set of changes that are on the way. Here’s what the sign in screen looks like.

Keyboard control for the backlog - You can now hold down the Alt key and use the up and down arrows to reorder items on the backlog.
Better touch support for the task board – Tiles are now single click enabled and, in general, we made the taskboard much more touch friendly.
Filtering of areas & iterations – It’s a small thing for most people but now, when you are configuring your areas and iterations on a large project, you can filter them to just those that are relevant for your team.
No more identity provider screen – You used to get a screen to choose the identity provider – with only LiveID as an option. Seems kind of silly. Now we just skip that screen in many scenarios (though not the logout flow where I took the screenshot above). This has highlighted a bit of a nasty issue for people who switch between LiveIDs. That’s never worked great because you actually have to go to live.com to really log now but now if you use the “Use different credentials” link in the VS connect dialog, it does nothing. That’s because it tries to invoke the login page but live.com says you are still authenticated and automatically logs you back in. We have plans to fix the multi-LiveID scenario in the next few months.
Updated to Azure 1.6 SDK on our build service images.

As I said, the visible changes in this release were pretty modest. We’ve got a bunch of cool stuff in the queue.

Brian

Preemptive Analytics in Visual Studio and TFS 11

2012-04-11T14:19:42Z

Over the past couple of years there’s been a growing connection between development and operations. The “old” world where development teams throw applications over the wall at ops is disappearing the same way the world where developers threw applications over the wall at test did. Whether you’re talking about continuous deployment, DevOps or “Build, Measure, Learn”, these are all catchy phrases that are various aspects of getting the development team connected more closely with the customer and with the application in production.

I’ve had the privilege of living this life for the past couple of years as we’ve been bringing the Team Foundation Service to life. It’s really challenged me to think about the world in a different way. Over the next couple of months, I’m going to try to write a series of posts that shares some of the things I’ve been learning along the way. One of those things, though, is that you have to have very good visibility into production. Without it you will have a low quality, expensive, undesirable service. With it you can solve problems before your customers even realize they exist, prioritize work based on what people actually use, test changes to see how it affects user behavior, drive your costs (both hard and soft) to the lowest level possible and much, much more.

In the last year or so, we’ve started to make some significant investments to help with this. The first was the Team Foundation Server and System Center integration we announced about a year ago that enables production tickets to be “escalated” to TFS along with all of the diagnostic information. Another coming in the VS 11 release is Intellitrace in production that allows you to get detailed diagnostic data from your production environment. We’ve also announced some follow on improvements coming to Intellitrace in production that will be available this fall.

Another area we’ve been working is in production telemetry. We’ve partnered with Preemptive (the makers of Dotfuscator) on a basic telemetry included with Team Foundation Server/Visual Studio 11 called PreEmptive Analytics for TFS Community Edition. This built in capability allows you to instrument your application and receive reports from your users on any crashes they experience. The reports are analyzed, correlated with other reports and distilled to a set of “production incidents” that appear to be the same underlying cause. These show up as work items in your Team Foundation Server database. You can also purchase the Pro edition and get additional capabilities like the ability to analyze what features of your application get the most use, etc.

This kind of telemetry has been an important part of our process in Visual Studio for many years. We view it as a critical part of understanding the experience real customers are having, addressing the issues they are having and measuring our progress. We create a number of reports and set goals for every release. For instance, here’s a list of the top 10 crashing bugs in the VS 11 Beta reported by real user telemetry and the current status of the bug.

Bug Info:	Watson Info:
Rank	TFS ID	Resolution	PU	Hits	CABs	Details
#1	358582	Fixed	VS: Pro	1010	6.0%	45	MSENV.DLL!== [Crash32_Normal: 0xC0000005]
#2	276670	(Active)	VS: Ultimate	454	2.7%	9	VSDEBUG.DLL!CAddressPosition::UpdateMarker [Crash32_Normal: 0xC0000005]
#3	378926	(Active)	NDP: WPF	326	1.9%	42	NVD3DUM.DLL!unknown [Crash32_Normal: 0xC0000005]
#4	372955	(Active)	VS: Pro	313	1.9%	21	UNKNOWN.DLL!Microsoft.VisualStudio.Editor.Implementation.Find.FindTarget.CalculateWrapping [Clr20r3: system.nullreferenceexception]
#5	374532	Fixed	VS: Ultimate	226	1.3%	8	VSDEBUGENG.SCRIPT.DLL!ScriptDM::CProviderEventCallback::AttachToProgramImpl [Crash32_Normal: 0xC0000005]
#6	362918	Fixed (excluded)	VS: Pro	181	1.1%	18	MSENV.DLL!EnableBrowserSecurityFeatures [Crash32_Normal: 0xC0000420] [Exclude reason: internal only]
#7	373304	External (excluded)	VS: Ultimate	161	1.0%	9	MICROSOFT.VISUALSTUDIO.ARCHITECTURETOOLS.PROGRESSIVEREVEALPROV!Microsoft.VisualStudio.ArchitectureTools.ProgressiveReveal.ProgressiveRevealProvider.Finalize [Clr20r3: system.missingfieldexception] [Exclude reason: unsupported install]
#8	378927	(Active)	VS: Pro	123	0.7%	12	MSENV.DLL!CDelayProjectLoadManager::LoadProject [Crash32_Normal: 0xC0000005]
#9	376355	Fixed	Expression: VS Integ	116	0.7%	28	SYSTEM.RUNTIME.REMOTING.NI.DLL!System.Runtime.Remoting.Channels.Ipc.IpcPort.Read [AppHangB1: 0]
#10	354401	(Active)	VS: WinC++	113	0.7%	30	MFC110U.DLL!CView::~CView [Crash32_Normal: 0xC0000374]

We also create visualizations to show how we are doing overall. Here’s a bar chart – 1 bar for each bug, height indicates number of reports and color is current status of the bug.

So, with VS 11 & TFS 11, you get get the same kinds of telemetry on your applications. Both the server side and client side components for the Community Edition come in the box. The installation for the server side pieces have been integrated to the TFS administration console and the client side pieces are available on the VS tools menu.

In short, you install the server side pieces. Then you instrument your app (including with an url to an exposed server side collector). When customers run your app and experience a crash, it will automatically send data, including things like a stack trace to your server and the aggregation service will file or update bugs on your TFS service.

Once you’ve got it all configured and have an app reporting failures, you’ll start seeing production incidents in TFS that look like this:

Then you can start looking at the built in reports like these. Here’s an overview of incidents by application, including the status of the incidents.

Or trends of incidents over time.

Conclusion

Telemetry and Analytics are increasingly important aspects of the software development process. They enable you to “close the loop” and ensure you are delivering a great experience for your customers. They are important regardless of whether you are building a mission critical server or a client running on desktops in your organization or PCs and phones around the world. For the past several years, we’ve been investing in making Visual Studio a great tool for developers to get good insight into application behavior and you can expect a great deal more in the coming years.

Everything you need is in the VS 11 and TFS 11 beta releases we published last month. We’re still working to streamline and improve some of the experiences but I think it’s starting to get to where we want it to be. I encourage you to check it out.

You can visit these sites to learn more:

Brian

TFS 11 Power Tools Beta Available

2012-04-02T20:28:00Z

About a week ago, we shipped a Beta the first version of the Team Foundation Server Power Tools that work with VS 11 and are optimized to work with TFS 11. This will be a bit shorter than a full announcement post because it’s a Beta and it’s not complete yet. I’ll do a comprehensive post when we get closer to a final build.

This Power Tools release is designed to work with a VS 11 client (they’ll actually work with Team Explorer 11 too) but you won’t get the VS integration in a VS 2010 or earlier client. If you want that integration, you need to install the 2010, 2008, etc Power Tools – they’ll run side by side. As a general rule, the Power Tools will work with any version of the server, however, some specific features require specific server versions. I’ll comment on some of those here.

Our goal with this Beta was to get the most critical Power Tools up and running with VS 11/TFS 11. We’ve also removed some of the Power Tools that have now been integrated into the product and changed the implementation of a few to take better advantage of new server features. We haven’t added any new Power Tools at this point.

The features included in this release are:

TFS Power Tools

TFPT Command Line
The Team Explorer extensions – All are included except work item templates.
Windows Shell Extension – It’s been enhanced to support local workspaces meaning no more read-only files and need to checkout, better offline support and everything else that comes with local workspaces.
Process Template Editor – We’ve added support for all of the new process features in TFS 11, however some of the implementation is place holder – for instance, editing the agile project management configuration involves editing XML.
Best Practices Analyzer
Test Attachment Cleaner
TFS Powershell commands

Build Extensions
MSSCCI (32-bit) & MSSCCI (64-Bit)

There are some known issues:

An incorrect error can come up on SxS install of the Power Tools with the VS2010 tools suggesting and issue with Back-up and Restore. This in fact related to the Windows Explorer plug-in you need to uninstall the VS2010 version first or choose to not install to leave VS2010 version in place via custom install options.
2. In some places we have not removed power tools functionality that is in the product, for these issues there is no functional impact and these will be resolved for RTM e.g. you will see the Check-in policy for Comments appear twice.
There is no Alerts Explorer in the TFS 11 Power Tools because we added that as a web experience to the TFS 11 product. The result is that, if you are using VS 11 with the TFS 11 Power Tools but an older TFS server, you no longer have the Alerts Explorer Power Tool - you would need to use the TFS 2010 Power Tools.
Installing Windows Shell Extensions is “last one wins” – if you install 2010 Power Tools after TFS 11 Power Tools, the 11 ones will be overwritten.
To install the Best Practices Analyzer on Windows 8, you must install .NET 2.0 manually first.
The docs need lots of updating.
We’re doing a significant rethink of the Team Members Power Tool now that we’ve got much better extensibility of Team Explorer and new server side functionality – as such much of the functionality hasn’t been added yet.
The Backup & Restore Power Tools are not included yet

The list of Power Tools that have now been removed due to having been included in the product include:

Work Item Search – we added this to both Web Access and Team Explorer
Work Item Templates: Bulk Edit – you can multi select work items in a Web Access query and set a value
Team Members: Team – we added the concept of teams to the core product
Alerts Explorer – we integrated Alerts and their admin into web access
Team Explorer: Rollback – we added this as a right click menu item where appropriate
Check-in Policy: Comments – we added this policy to the set shipped in the server

We’d appreciate you giving them a try and letting us know about any issues you find.

Brian

New Agile guidance

2012-03-27T18:13:59Z

We've been working with some of the Agile & Lean thought leaders to gather their perspectives on the state of the art - past, present and future. It's some good reading. Check it out here: http://msdn.microsoft.com/en-us/library/ee889983(v=vs.110).aspx

Brian

Announcing a Build Service for Team Foundation Service

2012-03-27T12:45:00Z

Today in my VS Live keynote, I announced and demonstrated a new cloud based build service for our Team Foundation Service on Azure. From the beginning with tfspreview, you’ve been able to do builds, but – you had to install, manage, patch, etc the build machines yourself. With this new service, we’ve made it possible to skip that and just use a pool of build machines that we manage in the cloud (though you can still install and manage build machines if you like). And, of course, you can do more than just build – like with on-premises TFS, you can run a default workflow that includes, compilation, testing, etc or you can create a custom workflow that does whatever you like. This represents the next step in getting your project/team started and productive in the shortest time possible.

Our new build service works by maintaining a pool of Azure VM roles that can expand and shrink as needed. When you start a build, a VM is allocated from the pool to run your build. Your build is run, the build output is copied off the build machine then the VM is restored and it is returned back to the pool for someone else to use.

After my announcement today, we will be enabling the new build service for all new and existing accounts on Team Foundation Service. It will take a few hours to enable them all but you should expect to see it available on your account by early afternoon. If you don’t have an account but would like to try it out, you can request access.

Visit http://www.tfspreview.com.

Click Create Account

If you have an invitation code (you can get one from someone who already has an account), you can just sign up or, if not, click the “Click here to register” link and it will take you to a page where you can leave an email address. How much demand we see will influence how fast we send out new invitation codes. We’ve been fulfilling them within 1 to 2 weeks and I hope we can continue at that rate.

Using Team Foundation Service

Using Team Foundation Service is very much like using an on-premises TFS server – it looks the same from Visual Studio (or Team Explorer Everywhere in Eclipse, for that matter). The only difference is that you use LiveID to login rather than a Windows login. Once you are in, it’s transparent to you. This includes the new build service. You can create a new build definition, queue a build, etc the same way you would if you managed the infrastructure. The one difference is that you need to pick the “Hosted Build Controller” in your build definition rather than a local build controller.

And (because we don’t have UNC shares in the cloud), you configure the build output local (Staging location) to be a path in version control ($/BuildsTests/Drops) in the example above. I’m not sure we’ll continue to have version control be the only drop location for the service but for now, it was an easy solution that provides an efficient place that is secure and easy to manage. In addition it enables you to use the Team Foundation Server Proxy locally to improve download speeds for teams. Build retention policies still work and will clean up old, unwanted drops.

The Build VM Image

The only major limitation is you don’t control the build machine. That simply means that if you have an external dependency in your project that is not in the default VM image, you will either need to check it in, enable your solution to download it from a public NuGet feed, or install it as part of your custom workflow.

The exact set of supported frameworks will continue to be refined, however with this release we have the following installed on the build image:

Visual Studio 2010 SP1
Visual Studio 11 Beta

This should allow you to build any of the project types that ship in the box for both of these releases with the exception of Windows Metro Style applications in VS 11. Once we have support for Windows 8 in Azure, we’ll add that additional support. This is just a starting place – a minimalistic one, and we’ve very interested in your feedback on what you’d like to have us install on the image by default.

In the near future, we will also enable Java builds. It’s possible today but a bit manual. The problem is that, by default, Java builds use the upgrade template and we haven’t added support for the new version control drop locations to that template yet. So, if you really want to get a Java build working on the cloud, then you can customize the default build workflow to enable Java builds – that’s what our Team Explorer Everywhere team has done. They’ve been using Team Foundation Service for their development for months – including cloud based builds for the past several weeks.

Unit Testing

As I mentioned above, the new build service does more than just compile. The default workflow supports unit testing (and you can modify the workflow to do almost anything you like). If you want to use the unit test frameworks in the box – MSTest or the new native C++ unit test framework, you can just checkin your tests and, by default, the build service will pick them up and run them as part of your build. The test results will be included in the build report.

You can also use any of the newly supported 3rd party Unit Testing Frameworks in VS 11 – XUnit, NUnit, etc. There’s a bit more configuration there so I encourage you to keep an eye on the Visual Studio ALM blog for more detail.

Clients

The new build service works seamlessly with the recent VS 11 Beta. In addition, last week, I blogged about a patch for the VS 2010 client that enables it to work with the new build service (though I didn’t mention that in the post because we hadn’t announced the new service yet ). The Team Explorer Everywhere client that includes Eclipse support will also support the new build service. And lastly, stay tuned for an update to VS 2008 that will enable Team Foundation Service support.

Conclusion

Team Foundation Service is still a pre-release offering. We’re working very hard on it and you should stay tuned to a lot more improvements in the coming months. We are releasing new capabilities to the service about every 3 weeks. In one of our recent updates, we changed our Terms of Service to more clearly express that the service can be used to “go-live” production projects and not just test and experimentation.

I hope you like the new build service and I look forward to hearing any feedback you have.

Thank you,

Brian

Keeping your TFS 2010 up to date as of March 2012

2012-03-23T15:54:00Z

**UPDATE** It looks like Grant Holliday wrote a nice post that covers more than mine does. It's not quite as up to date with the Compat GDR but it's good reading too: http://blogs.msdn.com/b/granth/archive/2012/01/03/tfs-2010-what-service-packs-and-hotfixes-should-i-install.aspx

We've been releasing a variety of updates to TFS and the VS support for TFS. I realize that it can be dizzying and I want to start by apologizing. For the past year, we've been in a transition from a more ad hoc process to a more structured process of quarterly cumulative updates. I've been trying to push us generally forward in that direction while not overwhelming the team with too much change while we are, at the same time, trying to deliver VS/TFS 11 and the Team Foundation Service. Unfortunately, the result is that what you have to do to stay up to date has been confusing - quite honestly, even for me. With in the last couple of weeks, with the VS/TFS 11 Beta out, I've finally said, I want to finish that transition and move to a pure quarterly update model. We'll still do one-off hot fixes for customers who need them but the majority of customers can stay up to date by just installing the latest Cumulative Update and those updates will be produced quarterly.

In the mean time, I want to share with you the best info I have as of right now on how to be up to date. All of this info is for 2010 because not much has changed on earlier versions recently.

First, I assume you have installed either VS 2010 or TFS 2010 or both and possibly an assortment of other components - Test Professional, Build controllers/agents, test controllers/agents, etc.

Starting from there here are the updates that you should be aware of:

Update	Where to install	Why install	Download location
Visual Studio 2010 Service Pack 1	Anywhere you install a client - VS, Test Pro, Test Controller/Agent, Build machine (if you install VS there as many people do)	Lots of client fixes	http://www.microsoft.com/download/en/details.aspx?id=23691
Team Foundation Server 2010 Service Pack 1	Anywhere you install server components - TFS App Tier, Build machine, Sharepoint extensions, Project server extensions, ...	Lots of server fixes	http://www.microsoft.com/download/en/details.aspx?id=20506
TFS 2010 SP1 Cumulative Update 2	VS, TFS AT, Build machine	Latest roll up of client and server fixes since SP1	http://www.microsoft.com/download/en/details.aspx?id=29078
Visual Studio 2010 SP1 TFS 11 Compatibility GDR	VS, MTM, Test Controller	Changes to enable 2010 clients to work with Team Foundation Service (http://www.tfspreview.com)	http://www.microsoft.com/download/en/details.aspx?id=29082

Going forward I hope to improve several aspects, including - consitent naming of updates so it's easy to tell what they are, better aggregation so fewer packages get you everything you need, better notification of what to install, easier to tell what you have or don't have, etc. We've got some work to do and we've made some changes in VS 11 that's going to enable some of this to be markedly better.

Thanks,

Brian

The Future of CodePlex is Bright

2012-03-22T20:11:10Z

The last 6 months or so have been really busy around here. Over the next several months, you’ll see a lot of what’s been keeping us busy come to light. Clearly a big part was unveiled recently with the launch of the VS/TFS/.NET Beta.

In this post I want to talk about CodePlex.

As you probably know CodePlex is a software development/open source collaboration site that we’ve run for several years. From the beginning it’s been based on Team Foundation Server – and for a long time, it was really the only way to experience TFS hosted “in the cloud”. When we first began development of what is now Team Foundation Service, I knew we were eventually going to want to reconcile that with CodePlex. It only makes sense to me for us to operate a single public service with a combination of public & private projects, community that spans them and a pricing structure that runs from free to premium (sometimes called “freemium”).

In the early days of developing the new service, I wasn’t ready to think through all of the ramifications. I just wanted to focus on getting the base service up and going and scaling on Azure. We’re there now – and you’ll see a bunch of exciting announcements around the service in the coming months.

Last fall, we were finally ready to take the plunge and begin figuring out what the long term roadmap to a unified service would be. We made the decision to move responsibility for CodePlex to my team in November of last year. We’ve spent a few months now working out where we want to go, prioritizing and beginning to build the future. Today I’m excited to talk about the first wave of the results.

We intend CodePlex to be the premier site for open source development – particularly for anything related to Microsoft platforms. It’s clear that in the past few years CodePlex has suffered some from lack of care and feeding and the result is that it has fallen behind some of the alternatives. So as we began to layout a roadmap for the future, it became clear that priority #1 is to demonstrate that CodePlex is alive and kicking and we are committed to evolving the service in a direction that our community loves.

So, the first task is to take a look at the CodePlex community feedback. As you can see, the #1 most requested CodePlex feature is Git support. Today, we are unveiling Git support on Codeplex (alongside the existing TFS and Mercurial support). To demonstrate the lack of momentum in recent years, if you look closely, you’ll see that suggestion has been there since 2008. I’m very happy to say that we plan to be much more responsive and you can expect us to continue to work actively on the list of suggestions. I’m not promising we’ll do them all nor that we’ll work precisely in the order of the voting but we will be working to make CodePlex a site you love.

You can read more about the Git support we are introducing today. It is live and you can create your new Git based CodePlex project now.

As we are rolling out the Git enhancements, we are also putting the finishing touches on a new look and feel for the CodePlex site to give it a more modern look that is pleasing to they eye. I’ve included a screenshot here to give you some flavor for the style we are looking at. The design isn’t finished but you should see a draft of it go live on the site in the next few weeks. After that we’ll iterate based on feedback.

And, as I alluded to earlier, we’ll be working to align CodePlex and Team Foundation Service into a single, scalable offering. This work will be happening partially in parallel with the efforts to revitalize CodePlex and respond to community feedback. It will also happen in stages rather than in one big milestone. It will likely start by having newly created CodePlex projects hosted on the Team Foundation Service Azure infrastructure. Then, over time, we’ll integrate the user experiences. This isn’t a concrete plan, but rather a flavor of how we are thinking about it.

I hope you are as psyched as I am about seeing new life poured into CodePlex and into the community. I encourage you to watch closely and participate in bringing the experience forward.

Brian

VS ALM Rangers Beta Content

2012-03-19T18:51:26Z

Along with the VS/.NET/TFS Beta, the Visual Studio Rangers created a whole bunch of new readiness content to help you be successful with the next generation of our tools. Real on their blog for more details: http://blogs.msdn.com/b/visualstudioalm/archive/2012/02/29/welcome-to-visual-studio-11-alm-rangers-readiness-beta-wave.aspx

Brian

Even Better Access to Team Foundation Server

2012-03-09T03:35:49Z

About 2 years ago, we first introduced Team Explorer Everywhere. In doing that we enabled diverse teams to work closely together regardless of platform or technology stack. We provided organizations a substantially improved ability to manage all of their projects and get consistent visibility across them. And we gave a new group of people access to a comprehensive set of software development collaboration tools.

Over the last two years, we have consistently improved on that initial release. These improvements include an SP1 with some nice improvements that also introduced localized versions, a Java SDK that enabled people to start automating and extending more of their process in Java, and a Developer preview followed by a Beta of Team Explorer Everywhere 11. Each release has advanced the solution, working to keep rough parity with the Visual Studio tools, while at the same time providing an experience that feels “native” for Eclipse developers.

Starting today, we are eliminating the requirement to purchase Team Explorer Everywhere separately. Before today, Team Explorer Everywhere users had to purchase both a Client Access License (CAL) and the Team Explorer Everywhere software, whereas Visual Studio Team Explorer users only had to purchase a CAL – the Visual Studio Team Explorer software has always been a free download (TE 2008, TE 2010, TE 11 Beta) for users who had a license to access a TFS server. Starting today the story is the same for Team Explorer Everywhere (TEE 2010 with SP1, TEE 11 Beta).

I’m not going to try to fully explain every scenario but let’s pick a few interesting ones:

Team Foundation Service or CodePlex – Both of these provide online hosted versions of TFS that can be used by anyone (no CAL purchase necessary – subject to change when Team Foundation Service leaves “preview” but true for now). This means that regardless of whether you use the Visual Studio based Team Explorer or the Eclipse based Team Explorer Everywhere, you can use these services without having to purchase any software.
Team Foundation Server “Standard Edition” – You can acquire the standard Team Foundation Server with the full set of TFS capabilities a number of different ways – through MSDN, as a separate purchase, etc. Having purchased it and a CAL, where necessary, you can use either the Visual Studio based Team Explorer or the Eclipse based Team Explorer Everywhere with no additional purchases.
Team Foundation Server Express – I recently announced the availability of a Team Foundation Server Express 11 Beta that enables a team of up to 5 people to experience much of the power of TFS for free. You can now use TFS Express along with Team Explorer and/or Team Explorer Everywhere all for no charge (up to 5 users – additional users will need to purchase CALs).

You’ll notice that not only are we making this licensing change for TEE 11, but we are also applying it to TEE 2010 SP1 today.

Lastly, this change will enable some other cool scenarios – like now that we’ve eliminated the licensing of TEE, we can finally set up a standard Eclipse update site that will enable you to keep Team Explorer Everywhere up to date just like you do the rest of your Eclipse extensions!

We remain committed to making TFS a great solution for all developers in your team/organization.

OK and now I have to admit this is sounding a bit like an infomercial – “wait, there’s more”

This is just part of a number of licensing issues we’ve been revisiting and trying to clean up, simplify and adjust based on customer feedback.

Team Foundation Server Reporting – We have removed the TFS CAL requirement (you still need whatever Sharepoint/Office licensing is appropriate) for viewing reports in TFS. This addresses a long standing concern that it was not reasonable to require a CAL for the occasional stakeholder who wanted to check a report to see progress or issues. Add this to the Work Item Only View CAL exemption that we added a couple of years ago and you get a pretty comprehensive solution for the occasional, loosely connected stakeholder.

And lastly, at least for now…

Using TFS from within Microsoft System Center Operations Manager – With the upcoming release of System Center 2012, you will be able to connect your operations team to your development team, allowing them to better collaborate on production issues. Operations Manager 2012 includes the ability to escalate tickets and all the associated diagnostic data to development by connecting it to Team Foundation Server. You can learn a bit more about it in this interview with Jason Zander. The news here is that we have updated our licensing to enable your Operations Manager users to take advantage of this integration without also needing a TFS CAL.

We continue to actively evolve the product and the licensing to address the most pressing needs of our customers. Hopefully you’ll find these licensing changes as helpful as some of the cool new features coming in TFS 11.

Brian

VS 11 Beta and Windows 8 Consumer Previews Available

2012-02-29T16:03:00Z

As we said earlier this month, the VS 11 Beta and Windows 8 Consumer previews are available. In the next couple of weeks I’ll write more about things to look for in the TFS Beta. In the mean time, checkout Jason’s blog for a good overview of what you’ll find. Here’s a bunch of useful links to learn more:

Visual Studio 11 Beta & .NET 4.5 Beta Announcement by Jason Zander

Windows 8 Consumer Preview Announcement (on the “Building Windows 8” blog)

Visual Studio 11 Beta Downloads (includes Visual Studio 11 Beta, Team Foundation Server 11 Beta, and .NET Framework 4.5 Beta)

Windows 8 Consumer Preview Download

Submit bugs to the Visual Studio, LightSwitch, or Blend Connect sites

Ask questions on the Visual Studio or Windows forums

Brian

SCRUM in a more formal organization

2012-02-24T03:52:40Z

Here’s a nice article on how you can integrate SCRUM and other agile practices into a more formal project management process by combining TFS and Project Server.

http://www.mpug.com/News/Pages/Exchanging-Project-Data-with-Your-Development-Team.aspx

Brian

VS Announcements Today

2012-02-24T03:42:59Z

I’m trying hard to keep up with all of the news. I’m in India this week and the time zone difference is making it tough. Here I’m going to give you a bunch of links so you can follow all of the news.

The Road to Visual Studio 11 Beta and .NET Framework 4.5 Beta

Sneak Preview of Visual Studio 11 and .NET Framework 4.5 Beta

Coming Soon: Team Foundation Server Express

Introducing the New Developer Experience – Part 1

Learn more about Visual Studio 11 Beta

What's New in Visual Studio 11 Beta

Hopefully you’ll find all the answers you want in these links but, if not, let me know and I’ll try to help. I’m going to be flying back to the US tonight so I may be a little slow in answering but I should get to it this weekend.

Brian

Coming Soon: TFS Express

2012-02-23T15:35:00Z

Soon, we will be announcing the availability of our VS/TFS 11 Beta. This is a major new release for us that includes big enhancements for developer, project managers, testers and Analysts. Over the next month or two, I’ll write a series of posts to demonstrate some of those improvements. Today I want to let you know about a new way to get TFS.

In TFS 11, we are introducing a new download of TFS, called Team Foundation Server Express, that includes core developer features:

Source Code Control
Work Item Tracking
Build Automation
Agile Taskboard
and more…

The best news is that it’s FREE for individuals and teams of up to 5 users. TFS Express and the Team Foundation Service provide two easy ways for you to get started with Team Foundation Server quickly. Team Foundation Service is great for teams that want to share their TFS data in the cloud wherever you are and with whomever you want. TFS Express is a great way to get started with TFS if you really want to install and host your own server.

The Express edition is essentially the same TFS as you get when you install the TFS Basic wizard except that the install is trimmed down and streamlined to make it incredibly fast and easy. In addition to the normal TFS Basic install limitations (no Sharepoint integration, no reporting), TFS Express:

Is limited to no more than 5 named users.
Only supports SQL Server Express Edition (which we’ll install for you, if you don’t have it)
Can only be installed on a single server (no multi-server configurations)
Includes the Agile Taskboard but not sprint/backlog planning or feedback management.
Excludes the TFS Proxy and the new Preemptive analytics add-on.

Of course, your team might grow or you might want more capability. You can add more users by simply buying Client Access Licenses (CALs) for the additional users – users #6 and beyond. And if you want more of the standard TFS features, you can upgrade to a full TFS license without losing any data.

In addition to the new TFS Express download, we have also enabled TFS integration in our Visual Studio Express products – giving developers a great end-to-end development experience. The Visual Studio Express client integration will work with any Team Foundation Server – including both TFS Express and the Team Foundation Service.

When we release our TFS 11 Beta here shortly, I’ll post a download link to the TFS Express installer. Installing it is a snap. No more downloading and mounting an ISO image. You can install TFS Express by just clicking the link, running the web installer and you’re up and running in no time.

Please check it out and pass it on to a friend. I’m eager to hear what you think!

Brian