Best Feature of TFS 2015 Update 1

Shortly before Christmas 2015 was the TFS 2015 Update 1 released, within this release are some new features that bring more productivity to Team Development and DevOps.

Here are some of my favorites :

TFVC and Git in the same Team Project

Lots of my customers have TFVC (centralized version control) in TFS. When Git support came out, the only option they had if they wanted to switch to Git was to create a new “Git-based” Team Project and port source code over. Then they got into a horrible situation where work items were all in the TFVC Team Project, and the source code was in the new Git Team Project.

Now, you can simply add a new Git repo to an existing TFVC Team Project! Navigate to the Code hub in Web Access, click the repository drop-down (in the top left of the Code pane) and select “New Repository”:

image

Enter the name of your repo and click Create. You’ll see the new “Empty Git page” (with a handy “Clone in Visual Studio” button):

imageThe Repository drop-down now shows multiple repos, each with their corresponding TFVC or Git icon:

image

You can also add TFVC to a Git Team Project! This makes sense if you want to source control large assets. That way you can have your code in Git, and then source control your assets in TFVC, all in the same team project.

If you’re looking for alternatives to supporting large files in Git, then you’ll be pleased to note that VSO supports Git-LFS. Unfortunately, it’s not in this CTP – though it is planned for the Update 1 Release. As a matter of interest, the real issue is the NTLM authentication support for Git-LFS – the product team are going to submit a PR to the GitHub Git-LFS repo so that it should be supported by around the time Update 1 releases.

Query and Notifications on Kanban Column

Customizing Kanban columns is great – no messing in the XML WITD files – just open the settings, map the Kanban column to the work item states, and you’re good to go. But what if you want to query on Kanban column – or get a notification if a work item moves to a particular column? Until now, you couldn’t.

If you open a work item query editor, you’ll see three additional fields that you can query on:

  • Board Column – which column the board is in. Bear in mind that the same work item could be in different columns for different teams.
  • Board Column Done – corresponding to the “Doing/Done” split
  • Board Lane – the swimlane that the work item is in

image Not only can you query on these columns, but you can also add alerts using these fields. That way you could, for example, create an alert for “Stories moved to Done in the Testing column in the Expedite Lane”.

Pull Requests in Team Explorer

You’ll need Visual Studio 2015 Update 1 for this to work. Once you have Update 1, you’ll be able to see and create Pull Requests in the Team Explorer Pull Requests tile. You can also filter PRs and select between Active, Completed and Abandoned PRs. There are PRs you’ve created as well as PRs assigned to you or your team. Clicking a PR opens it up in Web Access:

 

  Team Board Enhancements

There’s a lot to discuss under this heading. If you’re using the Kanban boards, you’ll want to upgrade just for these enhancements.

Team Board Settings Dialog

The Board Settings Dialog has been revamped. Now you can customize the cards, columns, CFD and team settings from a single place – not a single “admin” page in sight! Just click the gear icon on the top right of a Backlog board, and the Settings dialog appears:

image

Field Settings

TFS 2015 RTM introduced field customization, so not much has changed here. There’s an additional setting that allows you to show/hide empty fields – if you’ve got a lot of cards, hiding empty fields makes the cards smaller where possible, allowing more cards on the board than before.

Customisable Styles

You can now set conditional styling on the cards. For example, I’ve added some style rules that color my cards red (redder and reddest) depending on the risk:

image You can drag/drop the rules (they fire in order) and of course you can rules for multiple fields and conditions. You can change the card color and/or the title color (and font style) if the condition matches. Here’s my board after setting the styles:

image
Tag Coloring

You can now colorize your tags. You can see the iPhone and WindowsPhone tags colored in the board above because of these settings:

image
Team Board Settings

Under board settings, you’ll be able to customize the Columns (and their state mappings, Doing/Done split, and Definition of Done. Again you’ll see a drag/drop theme allowing you to re-order columns.

image

The same applies to the swimlanes configuration.

As a bonus, you can rename a Kanban column directly on the board by clicking the hearer:

image

Charts and General

Under “Charts” and “General” you’ll be able to configure the CFD chart as well as the Backlogs (opt in/out of backlogs), Working Days and how your bugs appear (Backlogs or Task boards or neither). These settings used to be scattered around the UI, so it’s great to have a single place to set all of these options.

Tasks as Checklists

If you use Tasks as checklists, then this is a great new feature. Each Story (or Requirement or PBI, depending on your template) card now shows how may child Tasks it has. Clicking on the indicator opens up the checklist view:

image

You can drag/drop to reorder, check to mark complete and add new items.

Task Board Enhancements

The Task board also gets some love – conditional styling (just like the Kanban cards) as well as the ability to add a Task to a Story inline.

More Activities Per Team Member

You can now set multiple activities per team member. I’ve always thought that this feature has been pretty limited without this ability:

image

Now you have a real reason to use the Activity field on the Task! The Task burn down now also shows actual capacity in addition to the ideal trend:

image

As a bonus, you can now also add new Team members directly from the Capacity page – without having to open up the Team administration page.

Team Dashboards

The “old” Home page (or Team Landing page) let you have a spot to pin charts or queries or build tiles. However, you couldn’t really customize how widgets were positioned, and if you had a lot of favorites, the page got a little cluttered. Enter Dashboards. You can now create a number of Dashboards and customize exactly which widgets appear (and where). Here I’m creating a new “Bugs” dashboard that will only show Bug data. Once you’ve created the Dashboard, just click the big green “+” icon on the lower right to add widgets:

image

Once you’ve added a couple of widgets, you can drag/drop them around to customize where they appear. Some widgets require configuration – like this “Query Tile” widget, where I am selecting which query to show as well as title and background color:

imageHere I’m customizing the Query widget:

image

You can see how the widgets actually preview the changes as you set them.

To add charts to a Dashboard, you need to go to the Work|Queries pane, then select the chart and add it to the Dashboard from the fly-out menu:

image

Similarly, to add a Build widget to the Dashboard you need to navigate to builds and add it to the Dashboard of your choice from the list of Builds on the left.

Now I have a really cool looking Bugs Dashboard!

image

Test Result Retention Policies

There is a tool for cleaning up test results (the Test Attachment cleaner in the TFS Power Tools) – but most users only use this when space starts running low. Now you can set retention policies that allow TFS to clean up old run, results and attachments automatically. Open up the administration page and navigate to the Test tab:

image

Team Queries: Project-Scoping Work Item Types and States

If you have multiple Team Projects, and at least one of them uses a different template, then you’ll know that it can be a real pain when querying, since you get all the work item types and all the states – even if you don’t need them. For example, I’ve got a Scrum project and an Agile project. In RTM, when I created a query in the Agile project, the Work Item types drop-down lists Product Backlog items too (even though they’ll never be in my Agile Team Project). Now, by default, only Work Item Type (and States) that appear in your Team Project show in the drop-down lists. If you want to see other work item types, then you’re doing a “cross-Project” query and there’s an option to turn that on (“Query across projects”) to the top-right of the query editor:

image

Policies for Work Item Branch

Now, in addition to Build and Code Review policies for Pull Requests in Git branch policies, you can also require that the commits are linked to work items:

imageYou can also just link the PR to a work item to fulfill the policy.

Labeling and Client-site workspace mapping in Builds

The build agent gets an update, and there are some refreshed Tasks (including SonarQube begin and end tasks). More importantly, you can now label your sources on (all or just successful) builds:

image

Also, if you’re building from a TFVC repo, you can now customize the workspace mapping:

image

And Stay tuned, because will come some other features in Update 2 that are in VSO now like :

 

Build widgets in the catalog

As Karen wrote about in the dashboards futures blog, one area we’re focusing on is improving the discoverability and ease in bringing different charts to your dashboard. With this update, you’ll see a new option to add a build history chart from the dashboard catalog, and you’ll be able to configure the build definition displayed directly from the dashboard.

Adding a build history chart from the dashboard catalog

Markdown widget with file from repository

The first version of the markdown widget allowed custom markdown stored inside the widget. You can now choose to display any markdown file in your existing repository.

Selecting a markdown file for display in the widget

Or add the file to any dashboard in your team project directly from the Code Explorer.

Displaying a markdown file in a dashboard

Check out all the January features in detail for Visual Studio Team Services:

https://www.visualstudio.com/news/2016-jan-25-vso

Microsoft Unity DI Container it is Open Source

   After few months , when was announced that  Prism over to new owners. The Pattern And Practices Team spend some of time and effort into identifying  needs and vision around Unity and owners that would invest in the project and support the community.

 

Going Forward

Be sure to read the official announcement from the new team and follow their work on the new GitHub repo. Let them know what you’d like to see in future releases of Unity and help them continue to grow the community

Fork it and lets begin to improve what we need , like I wrote before in another blog about DI   – https://dumians.wordpress.com/2013/10/02/dependency-containers-and-thread-safe-how-to/.

More MS OpenSource and Multi-Platform tools , .Net Core is GoLive

@Connect 2015 for few hours Microsoft has announced a lot of new things , here are

CONNECT 2015 KEYNOTES AND VIDEOS

You can watch everyone’s talks here

Enjoy DEV Smile

TFS free Book – Managing Agile Open-Source Software Projects with Microsoft Visual Studio Online

We’re happy to announce the release of our newest free ebook, Managing Agile Open-Source Software Projects with Microsoft Visual Studio Online (ISBN 9781509300648), by Brian Blackman, Gordon Beeming, Michael Fourie, and Willy-Peter Schaub.

With this ebook, the ALM Rangers share their best practices in managing solution requirements and shipping solutions in an agile environment, an environment where transparency, simplicity, and trust prevail. The ebook is for Agile development teams and their Scrum Masters who want to explore and learn from the authors’ “dogfooding” experiences and their continuous adaptation of software requirements management. Product Owners and other stakeholders will also find value in this ebook by learning how they can support their Agile development teams and by gaining an understanding of the constraints of open-source community projects.

Download all formats (PDF, Mobi and ePub) at the Microsoft Virtual Academy.

Below you’ll find the ebook’s Foreword and a few helpful sections from its Introduction:

Foreword

The ALM Rangers are a special group for several reasons. Not only are they innovative and focused on the real world, providing value-added solutions for the Visual Studio developer community, but they live and work in all four corners of the globe. The ALM Rangers are a volunteer organization. Talk about dedication! When we were offered the opportunity to write a foreword for this book, we knew we’d be part of something special.

The ALM Rangers don’t pontificate that they’ve found the one true way. This is practical advice and examples for producing great software by those who’ve done it and–most importantly–are still innovating and coding. Readers will find that they have virtual coworkers who share their experiences with honesty and humor, revealing learnings and what has worked for them. This doesn’t mean that this book lacks prescriptive guidance. The Rangers have embraced Visual Studio Online as their one and only home. They are evolving with the product, embracing open source software in GitHub to learn how successful OSS projects are run there and what the community values most. They’ve created an ecosystem that identifies the “low hanging fruit” and tracks it from idea to solution, and they never fail to recognize the Rangers and the ALM VPs who dedicate their personal time and passion to their OSS projects.

The extensive guidance shared here is not an end-to-end plan for everyone, although it could be used as a definitive guide for some teams. One of the many assets of this book is its organization into practical walkthroughs of typical ALM Ranger projects from idea to solution, presented as an easy to consume reference. Other bonuses are an appendix to quick-start your own project and reference checklists to keep you on track.

Among the authors, this book was called the “v1 dawn edition.” True to their core value of “learn from and share all experiences,” the ALM Rangers are always mindful that producing great software means continuous refinements from new learnings and feedback and that there will be more versions of this book. But first we invite you to immerse yourself in Managing Agile Open-Source Software Projects with Microsoft Visual Studio Online.

In the true spirit of Agile, ongoing innovation,

Sam Guckenheimer
Clemri Steyn

Introduction
This book assumes that you have at least a minimal understanding of Agile, Lean, and Scrum development concepts and are familiar with Team Foundation Server (TFS) and Visual Studio Online (VSO). To go beyond this book and expand your knowledge of Agile practices or Visual Studio technologies, MSDN and other Microsoft Press books offer both complete introductions and comprehensive information.

This book might not be for you if …
This book might not be for you if you are looking for an in-depth discussion focused on the process, development, or architecture of software requirements, tooling, or practices.

Similarly, if you are looking for source code or guidance on ALM, DevOps, or proven and official frameworks such as Agile, Scrum and Kanban, this book will not be fully relevant, and we recommend that you consider these publications instead:

TFS 2012 for FREE

 

Brian Harry, Technical Fellow TFS, recently announced that with TFS “11” we’ll be introducing a new version of TFS, called Team Foundation Server Express, that includes the 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. Read more about Team Foundation Server “11” Express in Brian Harry’s blog post entitled Coming Soon: TFS Express

Download the Visual Studio “11” Beta and Team Foundation Server “11” Beta here

Troubleshooting TFS 2010 reports & Warehouse

 

Background: Physical Architecture of TFS Reporting

Each TFS component maintains its own set of transaction databases. This includes work items, source control, tests, bugs, and Team Build. This data is aggregated into a relational database. The data is then placed in an Online Analytical Processing (OLAP) cube to support trend-based reporting and more advanced data analysis.

The TfsWarehouse relational database is a data warehouse designed to be used for data querying rather than transactions. Data is transferred from the various TFS databases, which are optimized for transaction processing, into this warehouse for reporting purposes. The warehouse is not the primary reporting store, but you can use it to build reports. The TfsReportDS data source points to the relational database. The Team System Data Warehouse OLAP Cube is an OLAP database that is accessed through SQL Server Analysis Services. The cube is useful for reports that provide data analysis of trends such as ‘how many bugs closed this month versus last month?’ The TfsOlapReportDS data source points to the Team System Data Warehouse OLAP cube in the analysis services database.

10 Steps to trouble shoot TFS Reporting

1. On the TFS Application tier server, open an Administrative Command Prompt

2. Run the following command: Net Stop TFSJobAgent

3. Once this completes, run the following command to restart the TFSJobAgent: Net Start TFSJobAgent

4. Open the TFS Administration console, and select the Reporting Node

5. Click the Start Rebuild link to rebuild the warehouse. Refresh this page until it displays “Configured and Jobs Enabled”

6. Open a web browser and navigate to the warehousecontrolservice.asmx page at:

http://<server>:8080/tfs/teamfoundation/administration/v3.0/warehousecontrolservice.asmx

7. Click ProcessWarehouse, then click Invoke on the subsequent page. This should return True.

8. Return to the WarehouseControlService.asmx page, then click ProcessAnalysisDatabase.

9. Enter Full for the processingType, then click Invoke, this should also return True.

10. Return to the WarehouseControlService.asmx page and click GetProcessingStatus, this should return the processing status page

with the current processing results. It should indicate Full Analysis processing is occurring. Refresh this page until the status

(ResultMessage) of the “Full Analysis Database Sync” indicates “Succeeded”

 

Refresh TFS Warehouse, Cube and Reports on demand

By default, TFS will process it’s Data Warehouse and Analysis Services Cube (and thus update the data for the reports) every 2 hours. Be careful with changing it to lower values than every hour:

Important

If you reduce the interval to less than the default of two hours (7200 seconds), processing of the data warehouse will consume server resources more frequently. Depending on the volume of data that your deployment has to process, you may want to reduce the interval to one hour (3600 seconds) or increase it to more than two hours. [Source: MSDN]

Alternatively you can use this small command line utility from Neno Loje:

Syntax/Usage:

tfsrefreshwarehouse.exe /server:http://servername:8080/tfs [/full] [/status]

Manually process the TFS Warehouse and Cube

Using just the /status paramter returns useful information about cube processing:

Using /status shows the last and next scheduled sync times

(Note: The user needs to have the ‘Administer Warehouse‘ permission in TFS)

Download the tool from here: TfsRefreshWarehouse.exe (.ZIP, 12,8 KB)

What’s New for Visual C++ in Visual Studio 11 Developer Preview

 

 

Standard Template Library

As part of the added support in Visual Studio 11 Developer Preview for the C++11 specification, the Standard Template Library (STL) support in Visual Studio is extended to provide the additional programming constructs that specification requires. Highlights include the following:

  • Support for new headers <atomic>, <chrono>, <condition_variable>, <filesystem>, <future>, <mutex>, <ratio>, and <thread>.

  • To optimize memory resource usage, all containers are now smaller given their current representations. For example, in x86 release mode with default settings, std::vector has shrunk from 16 bytes in Visual C++ 2010 to 12 bytes in Visual C++ in Visual Studio 11 Developer Preview, and std::map has shrunk from 16 bytes in Visual C++ 2010 to 8 bytes in Visual C++ in Visual Studio 11 Developer Preview.

Other C++11 Enhancements
  • SCARY iterators: As permitted but not required by the C++11 Standard, SCARY iterators have been implemented. For more information, see the PDF document SCARY Iterator Assignment and Initialization.

  • Stateless lambdas, which is code beginning with an empty lambda-introducer [] and capturing no local variables, are now implicitly convertible to function pointers as required by the C++11 Standard.

  • Scoped enumerations support. The C++ enum class enum-key is now supported.

Visual C++ Compiler and Linker


  • Auto-vectorizer. One of the biggest potential performance gains is doing things in parallel instead of sequentially. Visual Studio 11 Developer Preview provides not only parallelism on the task level, but also at the loop level, automatically. The C++ compiler will automatically vectorize loops if it is possible. Vectorization reorganizes a loop, for example, a summation loop, so that the CPU can execute multiple iterations at the same time. By using auto-vectorization, loops can be up to 8 times faster when executed on CPUs that support SIMD instructions. For example, most modern processors support SSE2 instructions, which allow the compiler to instruct the processor to do math operations on 4 numbers at a time.

    Because the compiler recognizes loops that can be vectorized when you compile your code, this occurs automatically. Note that this differs from parallelization, which is described in the next list item.

  • Auto-parallelizer. Visual Studio 11 Developer Preview is improving the way you can take advantage of multiprocessor and multi-core hardware. With the the auto-parallelizer, a loop is reorganized so that it can be executed on multiple threads at the same time. This means that your application can take advantage of multi-core CPUs and multiprocessors to distribute chunks of the work to all available processors. The parallelizer automatically reorganizes loops and executes multiple tasks, all without the need for you to add any new code to your application. You can tell the compiler which loops to parallelize with the #pragma parallelize directive.

    There are some key differences between auto-vectorization and auto-parallelization. First, auto-vectorization is always on and requires no user interaction, while auto-parallelization requires the programmer to decide which loops will be parallelized. Also, vectorization improves the performance of loops on single-core CPUs that support SIMD instructions, while parallelization improves the performance of the loop on multiple CPUs and multi-core CPUs. The two features can work together so that a vectorized loop is then parallelized across multiple processors.

  • C++ Accelerated Massive Parallelism (AMP) Support. C++ AMP accelerates the execution of your C++ code by taking advantage of the data parallel hardware that is ordinarily present as a GPU on a discrete graphics card. The C++ AMP programming model includes multidimensional arrays, indexing, memory transfer, tiling, and a mathematical function library. C++ AMP language extensions and compiler restrictions enable you to control how data is moved from the CPU to the GPU and back. For more information, see C++ Accelerated Massive Parallelism (C++ AMP).

Visual C++ Libraries


Parallel Programming Improvements

With hardware moving to multi-core and many-core architectures, developers can no longer rely on ever-increasing clock speeds of single cores to enhance application performance. The parallel programming support in the C++ concurrency namespace enables developers to take advantage of these new architectures.

In Visual Studio 2010, we saw the introduction of powerful C++ parallelization libraries such as the Parallel Patterns Library. We also introduced concepts to take advantage of concurrency by expressing sophisticated dataflow pipelines. In Visual Studio 11 Developer Preview, these libraries have been extended to provide better performance, more control, and richer support for the parallel patterns developers need most. The breadth of the offering now includes:

  • Parallel patterns library, which supports fork-join parallelism (parallel_for, parallel_for with affinity, parallel_for_each, parallel_sort, parallel_reduce, parallel_transform).

  • A rich task-based programming model that supports asynchrony and continuations.

  • Agents and Messaging, which lets developers express dataflow pipelines that naturally decompose into concurrent units.

  • Concurrency-safe containers package, which provides thread-safe versions of std:: data structures such as priority_queue, queue, vector and map.

  • Customizable scheduler and resource manager to facilitate the smooth composition of the previously-listed patterns.

IDE


In Visual C++ in Visual Studio 11 Developer Preview, the integrated development environment (IDE) has significant improvements in tools to help you be more productive coding in C++. For more information about other IDE enhancements, see Product Highlights for Visual Studio 11 Developer Preview.

  • Visual Studio Templates support. You can now author C++ project and item templates using the Visual Studio Templates technology. This was previously unsupported for C++.

  • C++/CLI IntelliSense. C++/CLI now has full IntelliSense support. All the IntelliSense features such as Quick Info, Parameter Help, List Members, and Auto Completion now work for C++/CLI. In addition, the new IntelliSense and IDE enhancements listed in this topic also work for C++/CLI.

  • C++ Code Snippets. Skeleton code is available for basic code constructs, such as switch, if-else, and for loop, among others, in the List Members drop-down. Select a code snippet from the list to insert it into your code and then fill in the required logic. You can also create your own custom code snippets for use in the editor. For more information, see Code Snippets.

  • List Members Enhancements. The List Members drop-down appears automatically as you type code into the code editor. Results are filtered, so that only relevant members are displayed as you type. You can control the type of filtering logic used by the Member List in the Options dialog box under Text Editor, C/C++, Advanced. For more information, see Using IntelliSense.

  • Semantic Colorization. Additional C++ tokens, such as types, enumerations, and macros, among others, now have colorization. By default, this colorization is enabled. Parameters appear in italic. You can specify additional token colorizations in the Options dialog box under Environment, Fonts and Colors. For more information, see Code and Text Editor.

  • Reference Highlighting. Placing your pointer on a symbol now highlights all instances of the symbol in the current file. Press CTRL + SHIFT + UP ARROW or CTRL + SHIFT + DOWN ARROW to move among the highlighted references. You can turn this feature off in the Options dialog box under Text Editor, C/C++, Advanced.

Code Quality Tools


Parallel Debugging

In addition to the Parallel Tasks window and Parallel Stacks window available in Visual Studio 2010, Visual Studio 11 Developer Preview offers a new Parallel Watch window that lets you observe the values of an expression across all threads and processes, perform sorting and filtering on the result, and extend the window with your own visualizers. You will also be able to take advantage of the new multi-process support across all tool windows.

C++ Accelerated Massive Parallelism (AMP) Debugging and Profiling

Debugging. For applications that use C++ AMP to target the GPU, the familiar CPU debugging experience of Visual Studio is offered. This includes the new parallel debugging additions previously mentioned. Debugging C++ AMP apps is just like debugging any C++ app.

Profiling. There is now profiling support for GPU activity supporting C++ AMP and other Direct3D-based programming models.

Static Code Analysis

Static analysis for C++ has been updated to provide richer error context information, more analysis rules and better analysis results in the new Code Analysis window. In this window, you can now filter messages by keyword, project, and severity. Selecting a message in the window highlights the line in the source code editor where the message was triggered. For certain C++ warnings, the message will list source lines to show you the execution path that led to the warning.

Other code analysis enhancements include the following:

  • New concurrency warnings to help you make sure that the correct locking disciplines in multithreaded C/C++ programs. The analyzer detects several concurrency bugs. These include potential race conditions, lock order inversions, caller/callee locking contract violations, and mismatched synchronization operations.

  • You can specify the C++ analysis rules that you want to apply to code analysis runs by creating or using rule sets.

  • In the Code Analysis window, you can insert a pragma into the source code that suppresses a selected warning.

For more information, see Analyzing Application Quality by Using Code Analysis Tools.

Updated Unit Test Framework

Use the new C++ unit test framework in Visual Studio to write C++ unit tests. Add a new unit test project to your existing C++ solution by locating the C++ Unit Test Project template under the Visual C++ category in the New Project dialog box. Start writing your unit tests in the generated TEST_METHOD code stub in the Unittest1.cpp file. Once the test code is written, you can discover tests automatically as follows: Build the solution, and then open a Unit Test Explorer Window by clicking View->Other Windows->Unit Test Explorer. Run the tests by right-clicking the test case in Unit Test Explorer, and select Run selected test. You can then view test results and additional stack trace information in the same window after the test run finishes.

Architecture Dependency Graphs

To understand your code better, you can now generate dependency graphs for binary, class, namespace, and include files in your C++ solution or projects. Open menu Architecture->Generate Dependency Graph->Project or Solution to generate a dependency graph for your whole solution or a selected project. Once the graph generation is complete, you can explore the diagram by expanding each node, learn dependency relationships by moving between nodes, and browse source code by right-clicking the node and selecting View Content. To generate a dependency graph for include files, right-click a *.cpp source code file or *.h header file and select Generate Graph of Include Files.

Layer Diagrams

Use layer diagrams to validate architecture design against implementation code written in C++. Create a new layer diagram by selecting menu Architecture->New Diagram->Layer Diagram. Start drawing the architecture by dragging and dropping shapes from the Toolbox window and then link projects, or by dragging and dropping existing projects from Solution Explorer onto the diagram directly. Once the architecture diagram is finished, right-click the diagram and select Validate Architecture to run validation against code. View results in theError List window (open from View menu). You can also generate dependencies with a right-click on the diagram and select Generate Dependencies. You can then visualize the actual code dependency on the layer diagram.

Architecture Explorer

The architecture explorer lets you explore the assets in your C++ solution, projects, or files. Find architecture explorer from the menu Architecture -> Windows -> Architecture Explorer. Click on nodes you are interested in; for example, Class View. Then the tool window will be expanded on the right side with a list of all namespaces. Continue by selecting one namespace and a new column will be created on the right side to show a list of the classes, structs, and enums in this namespace. Continue to explore the assets by selecting nodes, or go back to the column on the far left to restart the query.

Code Coverage

Code coverage has been updated to dynamically instrument binaries at runtime, which gives you lower configuration overhead and provides better performance. You can also collect code coverage data from unit tests for C++ applications within Visual Studio. Please see Unit Test Framework section of this topic to learn more about how to create and run unit tests. Once you have created C++ unit tests, you can use Unit Test Explorer to discover tests in your solution automatically. In Unit Test Explorer, select Analyze Code Coverage, which will run the unit tests and collect code coverage data for these tests. View the code coverage results in the Code Coverage Results window (Test->Windows->Code Coverage Results).

Aug ‘11 TFS Power Tools & Build Tools online

 

After few months of feedback and bug fixing the new TFS tools are online, with key improvements in this release include:

Windows shell extension updates
Work Item Search (part of #14 on the TFS UserVoice list
Rollback in the UI (#8 on the TFS UserVoice list)
Build Automation Utilities
Maven 3 support
Best Practices Analyzer updates
Test Attachments clean-up

more about  on Brian’s blog

http://blogs.msdn.com/b/bharry/archive/2011/08/08/aug-11-tfs-power-tools-coming-soon.aspx

TFS in Cloud

Hosting of ALM in the cloud as software as a service is gradually becoming more and more popular.  The vision, of course, is ALM as a seamless service – making it really easy to get started, easy to scale, easy to operate, easy to access, …  You’ve seen from time to time about TFS team work with 3rd party hosting and consulting companies offering TFS services.  Was a lot of work in TFS 2010 on both the technical and licensing front to enable a new generation of cloud based TFS services.

Several months ago, Brian Harry wrote a post about our initial investigation into porting TFS to the Windows Azure platform.  Since then, MS continued to pursue it and  at this year’s PDC, was a demo of Team Foundation Server running on the Windows Azure platform.  MS announced that will deliver a CTP (basically an early preview) next year, but aren’t, by any means, done with the technical work, but, for now,  it’s a great case study to see what is involved in porting a large scale multi-tier enterprise application to Azure.

The demo represents an important step forward in getting TFS running on the Azure cloud platform.  The demo included not only that but also the remaining components of TFS running in the cloud – the ASP.NET application tier (running as a Web Role), the TFS Job Service (formerly a Windows service for periodic background tasks, now running as a worker role) and the TFS Build controller/agent (running in an Azure VM role).  The demo include also connecting from a web browser, Visual Studio and from Microsoft Test Manager.

One of the cool things is that, for the end user, TFS in the cloud looks pretty much like TFS on-premises.  Other than the fact that you can log in with an internet identity rather than a windows identity, you’ll find that the Visual Studio experience, for example, looks pretty much identical to a local TFS scenario.