Application Lifecycle Management and Team Development Tools
Application Lifecycle Management sessions center around using VSTS and TFS effectively in your organization. Topics include a sneak peek of Rosario, customization, reporting, load testing, releases, and add-ons.VLT3Beyond VSTS 2008: Rosario
Brian Randell
Tuesday, October 14 – 9:30 a.m.
As good as Visual Studio Team System 2008 is, there are many more features that could be added to improve your overall Application Life-cycle Management (ALM) experience. Visual Studio Team System code name "Rosario" is the version of Team System that follows Visual Studio Team System 2008 and is focused on three major areas: business relevance, quality focus, and improved collaboration. In this future looking session, we'll dig into the most current CTP of "Rosario" that is available and examine Microsoft's road map so you can prepare and plan for the future now.
VLT7 Team Foundation Server Customization
Benjamin Day
Tuesday, October 14 – 11:00 a.m.
You've learned how to customize work item templates. It was fun but now you feel empty inside and need new challenges. How about a custom TFS event handler? Or a power toy to eliminate some tedious linking operations?
Did you know that Team Foundation Server (TFS) has an API to control, customize, and consume almost any piece of TFS functionality, including version control, the build system, and work items? You need to learn how to customize TFS.
In this session, Ben will show you how the TFS Event Service works so that you can write your own event handlers. After that, he'll dive in to the TFS APIs so that you can start writing your own tools to connect to TFS, manage work items, and link them using the linking service.
VLT11De-mystifying TFS Reporting
Benjamin Day
Tuesday, October 14 – 2:30 p.m.
If you're using Team Foundation Server, it's capturing a whole lot of data for you about your projects -- code coverage, code churn, work item history, etc -- and it's all going into the TFS Data Warehouse. All that data is being captured so that you can easily figure out what's happening on your project using Excel or SQL Server's Report Builder. That's great. Ever tried to actually do it? Ever looked at the TFS Data Warehouse? (Yeah. Clear as mud, huh?)
Then there are the SQL Server Reporting Services Reports that come out of the box. "Actual Quality vs. Planned Velocity"? (Whuh?) What do these reports mean? Better yet, how do you fix them after you've customized your Team Project's Work-Item Templates? What are these "dimensions" and "measures" all about?
In this session, Ben will answer these questions and more and attempt to eliminate the mystery in the TFS reporting system. We'll cover the reports mean, how you can access the warehouse with Excel, and then show you how you can customize the TFS SQL Reporting Services reports.
VLT15Load Testing Your ASP.NET Applications
Chris Menegay
Tuesday, October 14 – 4:00 p.m.
Far too often performance and scalability testing is not performed until applications are ready to be rolled into production. At that point it is too difficult to correct what may be fundamental problems in application design and architecture. This session demonstrates how to create robust load tests and run them as part of a daily automated build process. This regular load testing allows you to see performance problems as they are created, and fix them in a much more timely manner.
VLW3 Team Foundation Server Work Item Tracking Use and Customization
Chris Menegay
Wednesday, October 15 – 8:00 a.m.
Complex software development projects require many team members working together towards a common goal. These activities need to be understood, and articulated, whether using Agile methodologies or more formal methods. Team Foundation can support a variety of methods for managing work; from Scrum to Unified Process to waterfall. The most popular processes will be reviewed as well as strategies, techniques and pitfalls for customizing work item tracking with Team Foundation Server.
VLW7 Enhancing Team System through Add-Ons, Add-Ins, and other Widgets
Richard Hundhausen
Wednesday, October 15 – 9:30 a.m.
Microsoft knowing that software developers are picky and demanding did a wonderful job providing extensibility points throughout Visual Studio Team System. After many years, scores of third party products are available to enhance Team System's capabilities. In this session, we will spend the time exploring the more interesting and useful tools and solutions from the ever-expanding Visual Studio Team System community.
VLW11 Managing Software Releases with Visual Studio Team System
Chris Menegay
Wednesday, October 15 – 11:00 a.m.
Team Foundation Server offers a wealth of tools to support new application development projects. But how do they apply to applications that are already released and need ongoing maintenance? What about the existing applications that you've migrated into TFS? Or even your new applications once they've reached production? In this session we'll look at branching, build and work item strategies to help with managing and auditing the rollout of releases and fixes for existing applications. Some of the techniques that we will examine are: promotion modeling, "merge by work item", cherry-picked merges, and builds based on branches. This approach will take into account application code, database schema and data changes.
VLW19 Efficient Branching Strategies (BP)
Jeff Levinson
Wednesday, October 15 – 4:45 p.m.
Are you working with multiple products, multiple releases or common code? Don't know what source code is actually in production? Maybe you have a complex branching structure right now and it seems harder to work with than it should be. This session will show you basic and advanced branching structures, tips and tricks for promoting your code from development to production and how schedule affects the branching strategy. Learn things that the books don't cover to make your development and release process better.
VLTH3 Using TeamBuild in the "Real" World
Jeff Bramwell
Thursday, October 16 – 8:15 a.m.
Out of the box, TeamBuild provides some generally useful features - e.g. compiling your Visual Studio projects and running unit tests and static code analysis. However, if you want to go beyond these basic features, you have to get out of the Build Type "edit" dialog and become very familiar with the XMLbased build script and all that it entails. This session will cover various build-related topics including:
- Deploying a build to another environment
- Utilizing custom build tasks to handle various tasks (e.g. running FitNesse tests, deploying MSI packages, etc.)
- Deploying web-based projects
- Debugging tips
- 3rd party and out-of-band utilities (e.g. TFS Power Tools, TFS Sidekicks, etc.)
- How to use queries to determine the current state of a build (e.g. what work item types are deployed and ready for testing?)
- Tips and tricks along the way
VLTH7 Managing Change with Visual Studio Team System
Jeff Levinson
Thursday, October 16 – 9:45 a.m.
Are your projects suffering scope creep before you write a single line of code? Do your users change their minds constantly - and developers update the code to accomodate them? Are the estimates for a change wildly inaccurate and cause other things to break? If so then come learn how to manage change on your projects. Changes shouldn't happen TO you, they should be managed BY you. Learn when to start a change management process and how to inject just enough process to make it work for you. Learn how Team System helps facilitate change with a minimal amount of work!
VLTH11 Implementing X-Language Builds in a Microsoft TFS environment
Steve Taylor
Thursday, October 16 – 1:45 p.m.
More and more Microsoft Developers are reaching out to develop enterprise applications that are both x-language and x-platform. This involves the sharing of components written in diverse languages. This session will review how to implement a x-language build process that supports the sharing of information between .Net and Java. Tips and techniques for using VSIP Partner tools that work well with Microsoft Team Foundation Server to simplify x-language and xplatform projects will be reviewed using real world situations.
VLTH15 Team Foundation Server 2008 – Migrate or Integrate?
Richard Hundhausen
Thursday, October 16 – 3:15 p.m.
So, Team Foundation Server 2008 is installed in your company. That's great news. Now what? Should you migrate your existing tools and processes, or integrate with them? In my opinion, Team Foundation Server 2008 can comfortably replace any of your existing ALM solutions. The trouble is management may not be ready to give them up – for ROI, political, or egomaniacal reasons. That's fine too. In this session, we will look at the latest technology options for migrating-from, or integrating-with, your ALM tools. So, if you do happen to be chained to a home-grown defecting tracking system, 3rd party requirements management system, or an obscure, open-source revision tracking system, come to this session and find out how to put Team Foundation Server in the center of it all.
VLTH19 Programming Team Foundation Server: Advanced
Brian Randell
Thursday, October 16 – 4:45 p.m.
In this session, you'll learn about the rich APIs available in Team Foundation Server. You'll learn how to access the version control, work item tracking, team build, and security APIs. You'll learn how to bring them together to build your own rich client application.
VLW15Test Driven Development
Philip Japikse
Wednesday, October 15 – 3:15 p.m.
Test Driven/Test First Development is more than writing your unit tests first. It requires a very different thought process. We'll dive into that process to cover Test First Best Practices, Dependency Injection, and Mocking.
VLTH20Open Source Tools Every .NET Developer Should Use
Javier Lozano
Thursday, October 16 – 4:45 p.m.
Wouldn't it be nice to assemble business applications quickly without reinventing the wheel? In this session, we'll use open source tools such as the Castle Project, NHibernate, log4net, NUnit/RhinoMocks and CruiseControl.NET to facilitate the building of business applications. If you have ever been curious of how these tools can work together or want to know how you can use them within your existing projects, this session is worth checking out!
