I’m happy to share the release of the second book I’ve been involved in. This time the subject is the Team Foundation Service and how it can be used to setup a complete development infrastructure in just a couple of minutes. Oh, well, at least that’s what it takes to create an account… To fully take advantage of all its capabilities obviously will take much longer but hopefully the practices and experience we share in this book will help you get going quickly.
I’ve had the opportunity to work with a great team to author the book, with co-authors Jakob Ehn, Mattias Sköld and Joachim Rossberg. We’ve got great input and feedback from people in the product group, thanks Jamie, Will, Ravi, Anu, Vijay and Ed! And not to mention our most thorough reviewer Terje Sandstrøm. And thanks to Brian Harry for writing the foreword!
You can read more about the book at Amazon: http://www.amazon.com/Team-Foundation-Service-Mathias-Olausson/dp/1430259957.
Hope you find the book useful, I definitely learnt a lot from writing it!
- eller hur din applikation beter sig i produktion.
Om ett par veckor (3/5) kör vi ett seminarium tillsammans med Informator på ovan titel, ett i mitt tycke aktuellt ämne där vi tittar på hur vi med rätt verktyg kan få kontroll över hur våra system fungerar i drift och vad vi kan göra för att snabbt åtgärda problem när de uppstår.
Buggar och prestandaproblem kan vara nog så svåra att hantera i en utvecklings- eller testmiljö. Men när de uppstår i produktion så kan det verkligen bli otrevligt.
Under detta seminarium tittar vi på verktyg för bättre applikationsanalys och hur dessa kan användas för att hjälpa oss förstå produktionsbeteenden på ett bättre sätt. Vi utgår från .NET och Visual Studio 2012 och tittar på tekniker som:
- Run-time analys Arbeta proaktivt med prestanda och felinformation så vet vi vad som funkar och inte, innan våra användare gör det.
- IntelliTrace Om fel trots allt uppstår kan IntelliTrace hjälpa oss få detaljerad information om felsituationen.
- Profiling Profileringsverktyg ger oss nödvändiga detaljer om minnesläckor eller prestandaproblem, så vi snabbare kan hitta källan till problemet.
- Prestandatest De integrerade verktygen i Visual Studio låter oss enkelt simulera produktionsförutsättningarna, så vi kan säkerställa att applikationen kommer prestera som det är tänkt.
Yesterday the ALM Rangers released a new guidance project, this time around how to use IntelliTrace to enable better developer-operation scenarios. I’ve had the opportunity to work in this project and I recommend you take a look at what the team has put together. IntelliTrace can be difficult to get started with but these guides should help get the concepts right and get started in a good way.
I’ve worked on a couple of hands-on labs to walk you through setting up IntelliTrace, capturing IntelliTrace logs in production- and test environments and finally analyzing the IntelliTrace logs in Visual Studio.
Download the guide and tell us what you think.
The latest update for Visual Studio 2012 was released today. The most noticeable new features from an ALM perspective are
Charles Sterling has written an excellent summary of the new features, if you want to read more about the new features there’s a nice link collection at the end of the post.
Go get the update here!
At the ALM Summit earlier this week Brian Harry announced that TFS will host Git repositories. This is a great step forward for cross-platform development, native Git support will make it easy to use the team platform TFS gives us without having to compromise the development experience when working for instance in Xcode on iOS.
Microsoft will also provide integrated tooling inside Visual Studio for Git, which means not a separate set of tools but instead tools right inside the Team Explorer where we as Visual Studio users are used to work. Matthew Mitrik (MS), Andy Lewis, and Martin Woodward has written a great introduction to getting started with Git in Visual Studio using a Git repository in the Team Foundation Service.
Read the full announcement here.
As planned Mike Fourie published the January 2013 release of the Community TFS Build Extensions. This must-have pack of TFS build extensions has now gotten another set of new features added as well as issues fixed.
The January 2013 release contains
- VS2010 Activities(target .NET 4.0)
- VS2012 Activities (target .NET 4.5)
- Community TFS Build Manager VS2012
The Community TFS Build Manager can also be found in the Visual Studio Gallery here where updates will first become available. A version supporting VS2010 is also available in the Gallery. Please note that we only intend to fix major bugs in the 2010 version and will concentrate our efforts on the 2012 version of the TFS Build Manager.
At a high level, the following Issues and Features have been addressed
11237 Add support for /project switch on VsDevEnv activity Feature
11256 VsDenEnv : error if no DropLocation is specified Issue
11136 NUnit Result Publishing Issue
11423 NAnt activities Task
11250 The CodeMetrics activity throws an exception if DropLocation isn't set Issue
11307 vb6 project compilation - add time out Feature
11360 Statlight publish to TFS Issue
10635 Allow additional parameters for StatLight activity Issue
11212 StyleCop build activity doesn't write true to Succeeded on success Issue
11373 Issue with the TransformConfig-Activity Issue
11544 Statlight does not work with VS2012 Issue
TFS Build Manager
11515 TFSBM - Don't show deleted branches for Cloning Issue
11113 Exception if no projects in collection Issue
11226 Clone to branch with spaces in name throws BuildServerException Issue
11309 TFSBM -- Retain All Builds Feature
11407 TFSBM - update icons and add to Team Explorer Feature
11495 TFSBM - TE Navigation Link opens TFSBM in wrong VS instance Issue
11114 Manage Build Resources Context Menu uses wrong icons Issue
11241 No vertical scrollbar Issue
Note: If you are using the Azure Activities in VS2010 you should continue to use the April release. We will release a new build of this activity once we resolve the current VS2012 dependency which has been introduced.
I just pushed an update to the Custom Controls for TFS (WITCustomControls) project today. The project has been idle for a while but I decided to do a some work to enable the controls to work with TFS 2012. Soon after that pseranne contributed with a TFS 2012 Web control for the MultiSelectList control, which is the reason for the latest release.
These are the two recent changes:
220.127.116.11 release added support for TFS 2012 Windows Controls.
18.104.22.168 release added the MultiSelectList as a Web Control for TFS 2012 making the control available seamlessly in all TFS clients:
Microsoft Test Manager
Read more and download the controls from http://witcustomcontrols.codeplex.com/
Last week I did a presentation on agile development practices with Visual Studio 2012 together with Informator. An interested crowd turned up and they brought lots of good questions. The features around agile planning and the new development tools seemed to have made the biggest impression, not suprising since they are really nice tools adding direct value to the users.
For those who want to take a deeper look at the new features I recommend downloading the official Visual Studio ALM 2012 evaulation virtual machine. All you need to try out the tools with great hands-on labs to go with ut in one package. Note: you will need a Hyper-V host to run the VM, I recommend using Windows 8 with it’s native support for Hyper-V.
These is also good getting started content on the Microsoft ALM site.
Förra veckan hade jag och min kollega Magnus Timner den stora glädjen att få prata med Dag König på Microsoft om det kära ämnet Visual Studio ALM 2012.
Dag spelade in våra diskussioner i en Pod Cast som finns att lyssna på här: http://buzzfrog.blogs.com/zabrak/2012/10/devcast-08-nyheterna-i-visual-studio-2012-alm.html.
Så lyssna in och hör mer om vad som är nytt i senaste versionen av Visual Studio och TFS!
Microsoft Patterns and Practices just release a new "blue book”, this time covering many testing practices using Visual Studio ALM 2012 as the foundation. The book has a nice scenario-oriented approach with good practical examples to get you started.
The book is available for free and can be downloaded here: http://www.microsoft.com/en-us/download/details.aspx?id=35380
Update: Ed Blankenship correctly pointed out to me that the control model is only changing for web client controls so there should be little work upgrading existing windows work item controls to 2012.
I’ve been hearing requests for some additional work item control types for TFS 2012. Years ago I added a few controls to the open-source project at http://witcustomcontrols.codeplex.com/ and these have been maintained up to TFS 2010. With TFS 2012 the model for web client custom controls on the web has changed and with that in mind I’ve been considering putting some effort into implementing a few common controls for both Windows and Web.
I’m curious what the most wanted set of custom controls would be. My guess is that atleast these would be useful:
- Multiselect control
- Aggregation control. Based on rules show a sum of values (i.e. time remaining for a user story based on the sum of child tasks).
- Data-bound list. Based on a data source list a set of values (i.e. customer names from a CRM system)
Ideas? Comment this post or discuss at http://witcustomcontrols.codeplex.com/discussions.
I dag är sista benet i den road show jag varit på tillsammans med Microsoft senaste dagarna. Kul att se bekanta och nya ansikten och inte minst att se det goda intresset kring Visual Studio 2012 och ALM. Hoppas ni alla fått vatten på er kvarn att gå vidare i erat förbättringsarbete och kommer ta nytta av många av nyheterna i 2012!
Jonas Torstendahl har bloggat om evenemanget och har även med länkar till inspelningarna från tillfället i Stockholm: http://blogs.msdn.com/b/utvecklarlicenser/archive/2012/09/26/roadshow-dev-days-microsoft-visual-studio-2012.aspx
Det finns fortfarande platser i Göteborg och Malmö för Visual Studio 2012 lanseringseventen jag och Peter kör tillsammans med Microsoft Sverige. Det kommer att bli massor av demos av den nya produkten, givetvis med fokus på ALM;
Dev Days: Visual Studio 2012
Microsoft och Transcendent Group AB presentera nyheterna i Visual Studio 2012 och lägger extra fokus på ALM. Vi går igenom applikationslivscykel kedjan från ide till verklighet. Applikationslivscykeln (ALM) ger dig möjlighet att utveckla bättre lösningar och applikationer på kortare tid.
Skaffa dig insikt om ALM-processen och dess fördelar. Visual Studio 2012 med Team Foundation Server ALM ger dig möjligheten att driva och följa upp dina applikationer och kvalitén. Med Test Professional kommer du säkerställa att dina krav testas.
Visual Studio 2012 ger dig möjligheten att bygga applikationer som adresserar Windows Phone, Windows 8, .NET framework.
Evenemanget är kostnadsfritt och körs mellan 9 och 16.
- 25/9 – Stockholm (fullt)
- 26/9 – Göteborg
- 27/9 – Malmö
Registrera dig här: https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032518053&Culture=en-SE&community=0
Since TFS first came out it has been easy to create an automated build solution based on the TFS services. With Visual Studio 2010 it also became easier to create an on-premises continuous deployment solution using the new Lab Management component in TFS.
With Visual Studio 2012 there are several improvments which further improves the build-deploy-test scenarios together with the introduction of hosted TFS services for those interested in a cloud based ALM solution.
Recently Microsoft announced a very sleek solution to enable continuous integration to Azure using the hosted Team Foundation Service. Mike Fourie has written about Using Continuous Deployment to Azure with Team Foundation Service that is a great start if you are interested in Azure deployment.
But what about projects not using Azure? It sure sounds nice to have the option to host the entire development infrastructure in the cloud. So in this post I want to show how we can use the new features in Visual Studio 2012 to build a complete continuous deployment solution using Visual Studio 2012 and cloud services.
The image below illustrates the environment I would like to create to support a continuous deployment scenario in the sky for a generic application:
- The Team Foundation Service (tfspreview.com) is used to manage code and build assets.
- Windows Azure is used to host virtual machines that we compose to a test lab.
- Microsoft Test Manager (MTM) is used to create lab environments and to run tests on the lab environment in Azure.
- The Hosted Build Service runs the builds, including the lab management builds.
- As part of the lab management build process the hosted build controller will deploy a build to the test lab and run automated tests on the lab.
So the questions now is how much work is needed to get this up and running? Let’s go and implement the core components of this vision and see for ourselves!
Configure Team Foundation Service
The Team Foundation Service is TFS in the cloud. It’s currently available for free in a preview form but the service has been running for a while now and is very stable. Go to www.tfspreview.com to read more about the service and to create an account.
Since the Team Foundation Service is a hosted service the configuration we need to make is minimal for our scenario, just create an account, create a project and add the code.
Configuring a Build Service
A build service is currenty an integrated part of every Team Foundation Service account. This may of course change once the service is commercially available but for now it’s there for free.
Brian Harry has a great post that describes how to setup and use the hosted build service here: http://blogs.msdn.com/b/bharry/archive/2012/03/27/announcing-a-build-service-for-team-foundation-service.aspx.
This means we don’t have to do anything to get builds working with the Team Foundation Service.
Create Lab Machines in Windows Azure
So with the TFS infrastructure solved we now need to create a lab machine (or more) to run our tests on. For this example I created a simple Windows Azure worker role and enabled remote desktop in order to be able to log on to the machine to configure it and to install additional software as needed.
For information on how to create a Windows Azure machine and to configure it for RDP the following resources can be useful:
Configuring a Test Controller
The Team Foundation Service comes with an integrated build service but unfortunately not a test controller. We need a test controller to be able to setup a Visual Studio 2012 Lab Environment and also to control the test runs in the remote environment.
We can install the test controller wherever we want as long as it can access TFS and the lab machines. A simple solution for this scenario is to install the Test Controller on the lab machine itself. I used RDP to connect to the VM and then downloaded and installed the Test Agent directly on the Azure machine.
Note: It’s generally not recommended to install the Test Controller inside a Lab Management environment so you should setup a dedicated machine for this purpose.
The setup is simple but in order to use it with the Team Foundation Service we of course need to connect it the the TFS collection. But we also need to authenticate using an account that has been setup to access the TFS service, therefore I’ve used my local account from the Azure VM to both run the test controller service and as the lab service account:
Create a Visual Studio 2012 Standard Lab Environment
Visual Studio 2012 has a great enhancement to the way we create Lab Management envioronments; it is not required to install the System Center Virtual Machine Manager to create a lab instead we can build one from any physical or virtual machine. So in this case we will create a lab environment from the Azure VM created earlier.
With the test controller configured as described in the previous step we can now use MTM and create a new environment. The most interesting parts for our scenario is the Machines tab where we specify the Azure machines (getting the hostname for the VM is probably the most challenging part) and also an account on the VM that has permissions to configure the environment.
The next interesting configuration is the Advanced tab. Here we need to specify the test controller the environment should be connected to. We can also configure the environment to run UI tests and if so provide the account the test agent should be run under.
Completing the wizard will then start the environment creation process which can take some time. The most time consuming part is when the Visual Studio Test Agent gets installed but after a while the machine should be in a ready state:
Take a look at the following guide if you want more information on how to setup a Lab Management environment with Azure machines: How to get VS11 Lab Management to work with Azure VM Roles and Azure Connect.
Create a Build
Next we need to create a TFS build to compile a version of our project that we can deploy to our test lab and use for testing. Setting up a TFS build to create a deployment package can be very simple or quite a challenge depending on what kind of application we have.
We will just assume we have a TFS build called ExpenseIT Dev that creates a deployment package for us. The build has only one different thing in the hosted build scenario and ther is where the build is dropped. With the hosted build service we can choose to drop the build in TFS, something that makes sense in a cloud scenario where we don’t have access to a file share.
If you want to learn more about creating automated builds with TFS 2012 then The Visual Studio ALM Rangers TFS Build Customization Guide is a great resource.
Create a Test Suite for Automated Testing
Continuous Deployment requires more than just an automated build and deployment process to work. We also need a way to verify that the deployment actually works and what better than to do so by using automated tests built into the process?!
We can implement these build verification tests (BVT) using any automated tests. We can then add the tests to a test suite in Microsoft Test Manager and use that test suite later in the automated deployment workflow, the image below shows how we have created a test suite called ExpenseIT:
If we open the test case we can see that it is an automated test that is associated with the CreateStandardExpenseReport method in the ExpenseIT.UITests.dll assembly:
Create a Build-Deploy-Test Build Workflow
Now we are ready to do what we were aiming to do; create a continuous deployment solution using cloud services. Visual Studio 2012 Lab Management has a build template to setup a build-deploy-test workflow in a simple way using the
First we create a new build definition using the LabDefaultTemplate11.xaml process template.
On the Process tab we just select the LabDefaultTemplace.11.xaml build process template:
Next we edit the Lab Process Settings using the Lab Workflow wizard. The first step is to select the Azure Lab environment we created for this scenario:
Next we specify which build to deploy. We use the ExpenseIT Dev build and use the <Latest> available build.
Note: we cannot Queue a new build option together with the hosted build service because currently we are only assigned one build agent per account. The logic in the LabDefaultTemplate11.xaml build template is to queue a new build and wait for it to complete before running the deploy and test stages. With only one agent this workflow will be blocked and eventually timeout.
In the Deploy tab we get to add scripts to run locally on each machine in the environment:
In our case the deployment is very simple. just an xcopy of the build result and we’re done. So the deploy.cmd script contains the logic to clean the existing deployment folder and then xcopy over the build result:
RD %DeploymentPath% /S /Q
XCOPY %1 %DeploymentPath% /S /Y /I
Finally we select a test suite containing the automated tests to run on the environment, in our case the ExpenseIT suite in the ExpenseIT test plan:
That’s it! We have now set up a complete build-deploy-test workflow using only hosted services!
To test the BDT workflow we just make sure we have a build to deploy (the ExpenseIT Dev build) and then queue a new build.
If this had been setup on-premises with a build drop on a file share the BDT process could access all would have worked just fine. But having the drop folder in TFS unfortunately causes the deploy and test steps to fail:
As we can see in the build report the application sees the drop folder from the build to deploy in TFS but the activities in the lab workflow doesn’t know how to handle that and instead treats it as a local folder.
So to fix this we need to customize the BDT workflow to download the build result so the workflow can find it and use it as expected.
Customizing the BDT Workflow
To customize the default BDT workflow we just make a copy of it and open up the workflow in Visual Studio. If you want to learn how to customize a build template see the TFS Build Customization Guide.
First we will change the deploy and test activites to use a configurable location to find the build result. Then we can extend the deployment script to first download the build result to TFS before performing the deployment tasks.
We add a custom argument to the process to be able to specify the LabDropFolder from the build definition:
To show the configuration argument in a proper way in the build definition we add it as metadata in the process parameter metadata editor:
Next we find the “Run Deployment Task” activity and change the BuildLocation to the LabDropFolder:
And then the “Running Tests” activity and set the TestDirectory to the LabDropFolder:
Now we checkin the customized lab build template to TFS and update our deployment build definition to use the new template including specifying a Lab drop folder (on the Azure VM in this case):
With the build definition using the new build template all that remains is to update the deployment script to download the build result from TFS to a folder on the lab machine. The following script does just this. First we clean the target folders, then create a temporary TFS workspace and download the build result there. Finally the build result files are copied over to the deployment folder and the workspace is removed.
RD %DeploymentPath% /S /Q
RD c:\temp\drop /S /Q
tf workspace /new Temp /collection:https://alm.tfspreview.com/defaultcollection /noprompt
tf get %1 /recursive
REM --- Deploy App
XXCOPY drop %DeploymentPath% /S /Y /I
tf workspace /delete Temp /noprompt
With this we can now queue a new build and this time the entire build-deploy-test workflow will succeed since the deploy and test activities in the workflow are now using a local directory for the build result:
That’s it! You have now seen how you can use Visual Studio 2012 with the hosted TFS and Build Service together with Windows Azure VMs to create a complete build lab in the sky.
The last year or so I’ve been spending lots of time working with the Visual Studio 2012 product and as part of that I’ve been writing a book together with my friend and colleague Joachim Rossberg. The result is now soon available in stores:
It’s been an interesting project and I’ve learnt a lot – about the product of course but also about the process of book writing. Thanfully we have had a great book editor to help us! As for the writing itself probably the most challenging part was to write about a product that does not yet exist. Yes, that means writing and then go back and update after the release of the Beta, RC, RTM…
The book covers the whole ALM lifecycle so it’s a lot of content, we ended up with the following chapters:
Application Lifecycle Management
1. Why Application Lifecycle Management Matters
2. Introduction to Application Lifecycle Management
3. Development Processes and Frameworks
4. ALM Assessments
5. Working with TFS to Enhance the ALM Process
Planning (Agile Project Management)
6. Introduction to agile planning
7. Work item tracking and process customization
8. Agile Project Management with TFS
9. Metrics and ALM assessment
10. Prototyping, storyboarding and feedback tracking
11. Top Down Design Studies (UML)
12. Using Architecture Explorer
13. Using Layer Diagrams
14. Metrics and ALM assessment
Building (Developer Practices)
15. Version Control
16. Unit Testing
17. Code Quality (Code Analysis, Code Metrics, Code Clones, Code Review)
18. Performance and Profiling (working with IntelliTrace in production, Premptive Analytics)
19. Metrics and ALM assessment
Validating (Software Testing)
20. Overview of software testing
21. Manual testing
22. Automated testing
23. Test lab management
24. Metrics and ALM assessment
25. Continuous delivery
26. Build automation
27. Deployment (implementing a build-deploy-test workflow)
28. Release Management
29. Metrics and ALM assessment
Team Foundation Server
30. Architecture, implementation planning
31. Installation, migration and administration
32. TFS Reporting
33. Working in heterogeneous environments
34. TFS in the Cloud
I hope people will find the book valuable, we have tried to make it as practical as possible by having lots of exampels to illustrate the best practices we have learnt from using the product for many years.
Oh, and did I mention the book can be pre-ordered?
I just found out that my presentations from TechDays 2012 are available online. If you missed the conference but would like to watch what we talked about the sessions can be found here:
The presentations are in Swedish by the way. In case you wonder why the audio sounds strange…
I’ve got a new job! Or should I say new employer? I decided a while back to join Transcendent Group and their ALM team to get even more focus on TFS, Visual Studio and ALM. I’ve been working with the team for several years so this is a great opportunity for me to work closer with some of the brightest people in our field.
So as of June 1 I am the ALM practice lead and head of the ALM team. If you want to get in touch you can find my contact info here.
Update 2012-06-15: Louis Pellerin, one of the developers of Urban Turtle, pointed out that the recommended way to make this kind of customization is to first create a copy of the configuration file. This is important since the default files will be removed when uninstalling Urban Turtle as part of a future upgrade.
I recently downloaded the latest update to the agile board plugin to TFS from Urban Turtle.
The main feature this time is the possibility to have custom columns on the team board. Say for instance that I’ve added a “Ready for Test” state in my work item model:
To add a custom column we need to edit the configuration file for our process. The configuration files are stored on the TFS server at:
C:\Program Files\Microsoft Team Foundation Server 2010\Application Tier\Web Access\Web\UrbanTurtle\configuration\project
In my project I’m using the Microsoft Visual Studio Scrum 1.0 process template. The first thing to do when customizing Urban Turtle is to copy the template you want to change and work in the copy (Microsoft Visual Studio Scrum 1.0.xml in this case). Since the name of the configuration is stored in the configuration file we also need to change the name inside the file.
Next I edit the Tast Board, Columns section and add a new state, “Ready For Test”:
Then save the xml file and refresh the web page and watch the board show the new “Ready For Test” state.
This is a much wanted feature, thanks to the team to getting it out!
Here’s a list of other things added and improved in this release:
= Urban Turtle 3.15 Release Notes =
Release date : 15 May 2012
* Dynamic number of columns on the task board
* Copy/duplicate work item
* Story Point/Effort Burndown Chart
* New design: iteration/area side panel, column headers, card stacks, warning area as well as other work items and footer sections
* Spanish and German versions of the MSF Agile 5.0 process template mapping file
* Fixed card wrapping issue for screen resolutions lower than 1280 pixels
Today is the start of Microsoft TechDays 2012 in Sweden. TechDays is probably the largest IT conference in Sweden this year, three days filled with great content covering everything from IT operation to cloud-based development.
I’m proud to get a chance to talk at the conference again and this time on the following topics (yes, Visual Studio 11 ALM as expected):
- Build Lab in the Sky
- Continuous Feedback
And as if this is not enough, Brian Keller from Microsoft DPE will give the big picture presentation on ALM:
- What’s new in Visual Studio 11 for Application Lifecycle Management
- Software Testing with Microsoft Test Manager 11 and Lab Management 11
Another great thing about TechDays is that you get a chance to connect to the smart people in MEET (Microsoft Extended Experts Team), a group of technology experts, MVPs and MCTs I happen to be a part of. Here are some of the MEET members blogs if you want to learn more about the MEET members: Andreas Stenhall Alan Smith (Azure) Björn Axell (System Center) Cecilia Wiren (.NET) Chris Klug (.NET) Daniel Bugday (Sharepoint) Hasain Alshakarti (Security) Henrik Nilsson (FIM, ADFS, Security) Johan Arwidmark (System Center) Johan Åhlén (SQL Server) Magnus Björk (Exchange) Magnus Mårtensson (Azure) Patrik Löwendahl (.NET) Mathias Olausson (ALM) Jörgen Nilsson (System Center) Ola Skoog (IT Pro Evanglist) Anders Olsson (Security) Joakim Nässlander (Windows Server, Cluster) Martin Lidholm (Unified Communication, Lync)
See you at TechDays 2012 I hope!
If you want to know more about what’s coming in the next version of Visual Studio then here’s an event for you. I’m giving a presentation next week on what’s new in Visual Studio 11 with focus on the ALM tools and there are lots of interesting new capabilities coming, from storyboarding and feedback tools to improved version control and simplifications in lab management.
Register to the event here: http://www.informator.se/utbildningar/seminarier/seminarier/nyheter-i-visual-studio-alm-11.aspx
If you want to have a sneak-peek go to http://www.microsoft.com/visualstudio/11/en-us/downloads and download the beta!
More Posts Next page »