The opinions expressed in these materials are my own and are not necessarily those of Microsoft.
Copyright © Microsoft Corporation. All rights reserved. Unless otherwise indicated, all source code provided is licensed under the Microsoft Public License (Ms-PL).
Myfriends at Caravan Studios <www.caravanstudios.org>,the newest division of TechSoup <www.techsoup.org>You can go here for more information:
Once you've registered with SafeNight, you become a member of the community. A community who believes that people want to help. That we can use the resources at our disposal to make change. A community that believes everyone deserves a violence free life.
Once you've registered, you can connect to a verified domestic violence service organization. These organizations provide shelter and other services to individuals in need. Once you connect, you will receive requests to sponsor a hotel room when there is an urgent need and no availabe space at a shelter.
When the organization you are supporting needs help, you will see a notification on your phone. That lets you know that there is an individual who needs a safe night. By agreeing to sponsor a hotel stay, you give that person a chance to receive additional support in a time of need.
I recently had a discussion with a customer about our GIT support. I thought I would share this great documentation for folks who are wondering what our current level of support is and a to compare GIT to the Team Foundation Version Control (TFVC). We want to provide folks the ability to choose the version control systems that suits them best so we offer both centralized (TFVC) and decentralized (GIT) version control alternatives natively in TFS. You can find the documentation below here:
When you create a new team project you choose the version control system your team will use in that project: Team Foundation Version Control (TFVC) or Git. This is a permanent choice for each team project you create, but you can use both TFVC and Git team projects in the same team project collection.
Team Foundation Version Control (TFVC) is a centralized version control system. Typically, Team members have only one version of each file on their dev machines. Historical data is maintained only on the server. Branches are path-based and created on the server.
TFVC enables two models for your team to make changes:
Check out/check in in server workspaces: Before making changes, team members publicly check out a files. Most operations require developers to be connected to the server. (In the past teams blocked more than one person from checking out, but this is now less common.) This system facilitates locking work flows. Other systems that work this way include Visual Source Safe, Perforce, and CVS.
Edit and commit from local workspaces: Each team member takes a copy of the latest version of the codebase with them and works offline as needed. Developers check in their changes and resolve conflicts as necessary. Another system that works this way is Subversion.
Learn more about Team Foundation Version Control (TFVC).
Git is a decentralized version control system. Each developer has a copy of the entire source repository on their dev machine. Developers can commit each set of changes on their dv machine and perform version control operations such as history and compare without a network connection. Branches are lightweight. When you need to switch contexts, you can quickly create a private local branch. You can quickly switch from one branch to another to pivot among different variations of your codebase. Later, you can merge, publish, or dispose of the branch. Another system that works this way is Mercurial.
Git in Visual Studio and TFS is standard Git. You can use Visual Studio with third-party Git services, and you can also use third-party Git clients with TFS.
Learn more about Git
Here’s a comparison chart to help you make a choice between TFVC and Git.
Team members can receive email alerts when check-ins occur.
Team members can receive email alerts when commits are pushed to the server.
Because your team checks in all their work into a centralized system, you can identify which user checked in a changeset and use compare to see what they changed. Looking at a file, you can annotate it to identify who changed a block of code, and when they did it.
You can identify which user pushed a commit to TFS. (Anyone can claim any identity as the author or committer.) You can identify when changes were made what was changed using history, compare, and annotate.
Path-based branches are used mostly as long-standing constructs to isolate risk of change among feature teams and releases. Team members typically set up an additional workspace for each branch they work on.
Changes in each branch are independent from each other, so you don’t have to check them in before switching from one branch to another. Merging between sibling branches requires a baseless merging.
You can get visualizations of your branch structures and where your changesets have been merged.
See Use branches to isolate risk in Team Foundation Version Control.
Branching is lightweight and path independent. Many developers create a branch for each new feature they are coding, sometimes on a daily basis. You can quickly switch from one branch to another to pivot among different variations of your codebase. You can create branches that exist only on your dev machine and share them if and when you’re ready.
You must commit, branch, stash, or undo changes before switching branches. Merging is simple and independent of the commit that the branch is based on.
You can compare branches to see which commits exist on which branches.
See Use Git branches to switch contexts, suspend work, and isolate risk.
Builds (automated by TFBuild)
You can use all TFBuild capabilities to build any combination of content you want within the team project collection.
You can use most TFBuild capabilities to build one team project at a time, and one or more repositories at a time. Gated check-in builds aren’t available yet. Symbols can be published, but they are not indexed yet.
Team members can concurrently change files on their dev machines. You upload (check-in) changesets to the server when you create them. You can upload your changes at any time. However, you might be interrupted by conflicts.
You can change the comment of a changeset after you check it in. You can link changesets to work items and associate them with completed builds.
Team members can concurrently change files on their dev machines. You create commits on your dev machine independently of contributing them to the team. When you’re ready you must pull the latest commits before you upload (push) yours to the server. When you pull, you might be interrupted by conflicts.
You cannot change the comment of a commit. You can link commits to work items and associate them with completed builds.
You can modify and combine commits from the command prompt.
Code reviews in TFS
Not available yet, but you can comment on and send email about a commit from the web portal.
You might have to resolve conflicts when you get, check in, merge, or unshelve. You can resolve all types of conflicts in Visual Studio.
You might have to resolve conflicts when you pull or merge. You can resolve content conflicts in Visual Studio. Other types of conflicts can be resolved from the command prompt.
You can check in large binary files. You might also want to use NuGet in combination or as an alternative.
You can check in small binary files. You might want to use NuGet as an alternative.
Files on the client dev machine
You can browse your files using Source Control Explorer in Visual Studio, or using Windows File Explorer or the command prompt.
You can browse your files using Windows File Explorer or the command prompt. You cannot yet browse files in Visual Studio.
Files on the server
Each team project contains all files under a single root path (for example: $/FabrikamTFVC). You can apply permissions at the file level. You can lock files.
You can browse your files on the web portal and using Source Control Explorer in Visual Studio.
Each team project can contain one or more Git repositories and each Git repository can contain one or more branches. The most granular permissions you can apply are to a repository or a branch. Files cannot be locked.
You can browse your files on the web portal.
File history is not replicated on the client dev machine and so can be viewed only when you’re connected to the server.
You can view history in Visual Studio and on the web portal. You can annotate files to see who changed a line, and when they changed it.
File history is replicated on the client dev machine and can be viewed even when not connected to the server.
You can view history in Visual Studio and on the web portal. On the web portal you can annotate files to see who changed a line, and when they changed it.
Manage work on your dev machine
Pending changes and my work pages
Changes, commits, and branches pages.
You can use CI builds, gated check-in builds and check-in policies.
You can use CI builds. Gated check-in builds aren’t available yet.
You can work on small or very large scale projects using local workspaces. Supports massive scale (millions of files per branch and large binary files) projects using server workspaces.
You can quickly begin small projects. You can scale up to very large projects, but you have to plan ahead to modularize your codebase. You can create multiple repositories in a team project.
Suspend your work
You can suspend from my work page or shelve your changes.
You can create a branch from (from Visual Studio or the command prompt) from or stash (from the command prompt)
Tag your files
You can apply labels to a version of one or more files from either Visual Studio or the command prompt. Each file can have label applied to a different version.
You can apply tags from the command prompt to individual commits. View tags in the Visual Studio history window.
Client tools: Visual Studio, Eclipse (with Team Explorer Everywhere)
Server tool: TFS
Client tools: Visual Studio, Eclipse, and other third-party tools
Server tools: TFS and third-party services
Visual Studio: Offers all commonly used features and many advanced features.
TFS web portal: Can browse, comment, annotate, and see history of the codebase.
TF Command prompt: Installed with Visual Studio. Used for advanced, administrative, and other less common tasks.
Visual Studio: Offers many commonly used features. Features for some common tasks are not yet available.
Third-party command prompt: You can install it from Visual Studio. Used for some common and many less common tasks.
Visual Studio compatibility
You can use all supported previous versions of Visual Studio.
You can use Visual Studio 2013 (Git is included) or Visual Studio 2012 Update 3 (you must also install Visual Studio Tools for Git).
You can browse your codebase (including branches), view history, annotate and comment on changesets and shelvesets, and perform other tasks such as ad hoc downloading of selected parts of your codebase as a .zip file.
You can browse your codebase, view history, compare branches, annotate and comment on commits, and perform other tasks such as ad hoc downloading of selected parts of your codebase as a .zip file.
This next feature only applies to C++ and C# just so you know. There are four things I want to talk about: highlighting, moving, selecting, and defining matching braces.
If you have any code with matching braces:
You can put your cursor to the left of any brace and it will highlight the matching one:
If you want to move the cursor from one brace to another simply press CTRL+] (close bracket) to jump, forward or backward, between them:
If you press CTRL+SHIFT+] (close bracket) then it will not only jump to the matching brace but will highlight everything between the braces as well:
Lastly, the definition of “brace” is very loose and applies to square brackets, curly braces, and parentheses:
So feel free to use this feature set with just about any type of brace.
Just came across these the other day and wanted to share below is the information verbatim from http://msdn.microsoft.com/en-us/library/vstudio/ee889983(v=vs.120).aspx
Welcome to the technical articles for Application Lifecycle Management! These technical articles provide additional resources for you to use when supporting your development efforts with Team Foundation Server. Some provide in-depth technical information about unique scenarios that involve Visual Studio Application Lifecycle Management. Others provide insights into development processes and philosophies from industry experts that you might want to consider when developing your software or working as a team on a software project. These articles represent the viewpoints, opinions, and experience of their individual authors.
Agile Principles and Values, by Jeff Sutherland. Jeff Sutherland provides an overview of the Agile principles as defined in the Manifesto for Agile Software Development.
Ten Year Agile Retrospective: How We Can Improve in the Next Ten Years by Jeff Sutherland. Ten years after the publication of the Agile Manifesto, Jeff Sutherland describes the successes of Agile and pinpoints four key success factors for the next ten years.
Done and Undone by Ken Schwaber and David Starr. Delivering a done increment is critical to being successful with agile software development. Using both real-world and theoretical examples, the authors demonstrate the difference between perception of "done" and the reality of "done," and how that affects the success of a project. Using these examples, the authors go on to demonstrate tools and strategies that can help teams start with a definition of done that makes sense for them, and methods to help teams communicate dependencies, status, and the meaning of "done."
Building and Managing the Product Backlog by Mitch Lacey. A good product backlog is at the heart of any well-functioning agile team. In this article, Mitch Lacey explains the importance of a product backlog, describes what makes a good backlog, and provides some best practices for creating and maintaining your backlog.
Prioritization by Mitch Lacey. In this article, Mitch Lacey discusses three methods that have proven very beneficial for many Agile teams: the Kano Model of Customer Satisfaction, a series of Innovation Games by Luke Hohmann, and Karl Weigers’ Relative Weighting model. He describes how any of these methods can help you move from rough prioritization of your backlog to a precise ordering that satisfactorily weighs risk, importance, and customer satisfaction.
Estimating by Mitch Lacey. Mitch Lacey discusses the difficulty surrounding software project estimation, and provides tips and tricks for using two agile software estimation techniques when teams are estimating projects.
Sprint Planning by Mitch Lacey. Sprint planning does not need to be challenging. In this article, the author provides examples and strategies for keeping sprint planning focused and effective, and detail potential solutions to common problems teams encounter when planning a sprint.
Effective Sprint Retrospectives by David Starr. Going beyond techniques, this article offers ways to maintain and improve the practice and results of Retrospectives.
Distributed Scrum by David Starr. Distributed teams often struggle with consistent, timely, and effective communication. In this article, David Starr explains how Scrum offers a container in which different types of distributed teams can improve and succeed.
Enterprise Agile: Using TFS to support portfolio backlogs across multiple teams by Gregg Boer. Learn how TFS can be configured to support a portfolio of backlogs which provides automatic roll-up and management insight into work across multiple teams.
Lean Software Development by David J. Anderson. David J. Anderson describes Lean Software Development, its history, and how it can be used by software development project teams.
CMMI Principles and Values by David J. Anderson. The concept that an organization can be appraised at a particular maturity level and that this is an indicator of capability to deliver reliable work to the government is a matter of ongoing debate. In this article, David J. Anderson makes a case for Capability Maturity Model Integration (CMMI) and describes how it provides valuable insights for managers, process engineers and all external stakeholders including customers, investors, governance bodies and auditors.
The Lean of Scrum by David Starr. In this article, learn about the inherent Lean qualities of the Scrum framework along with various ways to help Scrum Teams improve using Lean Thinking.
Microsoft Solutions Framework (MSF) Overview . In this article, learn about the Microsoft Solutions Framework (MSF), an adaptable approach for successfully delivering technology solutions faster, with fewer people and less risk, while enabling higher quality results.
Application Analytics: What Every Developer Should Know by Sebastian Holst. In this article, Sebastian Holst discusses the objectives and advantages of application analytics.
Exploratory Software Testing by James Whittaker. In this article, an excerpt from his book Exploratory Software Testing: Tips, tricks, tours and techniques to guide test design, James Whittaker discusses goals, advantages, and approaches to exploratory software testing.
I’m back! Vacation was great but now I’m ready to get back into the swing of things. I thought we would get things going again with a look at two features of IntelliSense: Pascal Case and keywords.
This is one of my favorite features! Have you ever been in a situation where you wanted to use IntelliSense to get a method but there are a TON of methods that start with same word and you have to type almost the entire method name:
Let's say you want the SetWindowSize Method but really, really don't want to type it out or even scroll down to get the method. IntelliSense supports Pascal Case. All you have to do is type "SWS":
This is true in a number of areas within Visual Studio now so feel free to try this in other areas (i.e. the search dialog in Solution Explorer).
To show you the new feature, let’s take a look, way back, at VS2008 IntelliSense. Notice when I type Console.Key what happens:
IntelliSense used to be this huge alphabetical list and would just show you whatever begins with the keyword you were typing at the time. In this example, it takes me to the “key” area in the list. Notice that it then continues into the “L” and “M” and so forth. That’s great but what if I don’t know what I am looking for but I know that it has the word “key” somewhere in it? Well, I can go search in the Object Browser, of course or I can use keyword feature that was introduced with IntelliSense for VS2010. Watch what happens when I do the same thing in the VS2013 editor:
It now shows only those items that have the word “key” in them AND doesn’t care where the word is in the name of the member! So not only do it get items that begin with “Key” but I get ANYTHING that has the word “key” in it.
There are some great hidden gems in the editor and these are just a couple of them. Stay tuned for many more goodies to come.
Folks I will be on vacation until 8/5. See you all in a couple of weeks :)
p.s. Unfortunately I’m not going to the great place shown in the picture…
You can use Navigate To to search for objects, definitions, or references (symbols) in a solution. If you happen to remember the old Navigate To dialog box then you know it was useful but blocked your view of the code:
The new Navigate To dialog is much less intrusive. Just press CTRL+,[comma] to see the new dialog:
The Navigate To experience will look one of two ways while you are using it. If the symbol is in any open document the relevant line will be highlighted within it:
If the symbol is not in an open document then it will show up in the Preview Tab:
There is only one search option when using Navigate To that will include (or exclude) external items:
At any time you can press ESC to close Navigate To and go back to your original code.
In case you haven’t heard we acquired InCycle’s InRelease Business Unit. Here is information on InRelease from the website (http://www.incyclesoftware.com/inrelease/):
More interesting is the information from Brian Harry (http://blogs.msdn.com/b/bharry/archive/2013/07/10/inrelease-acquisition-is-complete.aspx):
[NOTE: Extra space added by me]
At TechEd, in early June, I announced our agreement to acquire InRelease – a release management product built specifically for Team Foundation Server by InCycle Software. Since then, we’ve received tons of requests for more information, demos, etc. Unfortunately, we’ve only been able to point people at InCycle because the acquisition was not final. I’m happy to say that about a week ago we closed the acquisition and InRelease is now a part of Microsoft.
That doesn’t mean we can start selling it right away. There are a number of things that have to happen in order to enable that – getting it on our price lists, shipping a version that is properly branded, serviceable, etc. All of that will take a few months but there are some good options for you in the interim. Let me share some of them.
Hopefully these two paths will solve everyone’s needs while finish up the changes we need to make.
I also want to say a few words about licensing so you, at least, have a little context on what to expect. We are not ready to announce pricing but I can share a bit about the structure of the licensing.
For now, we are focused on getting InRelease integrated into our on premises product. We will also support our cloud service but that will come a bit later.
Please give it a try and give us any feedback you have. As you might imagine, we are currently working on developing and prioritizing our backlog.
For those that are installing TFS 2013, here is a FAQ from the team to help answer some common questions. The most notable is the Go Live license for this build.
[Note: I added some extra spacing but the emphasis is from the original post]
Now that the Preview has been out for a couple of weeks, we've started to get lots of questions about acquisition and upgrade. This page provides useful information about the upgrade process for the Visual Studio Team Foundation Server 2013 Preview. If you're unfamiliar with the new features available in Visual Studio 2013, see this post for an overview.
This release is a preview, so we do expect there to be some bugs in the product. However, we have been using the Preview in our production environment for months and have had a handful of customers install it prior to release to provide feedback, so it has already been through some vetting. If you feel comfortable upgrading your production server, we will support you. The 2013 Preview is "Go-Live," which means you'll be able to upgrade your data to the next 2013 release when it comes out.
The upgrade process has not changed significantly since TFS 2012. One improvement to be aware of is that just like in the later updates for TFS 2012, the 2013 configuration wizards will persist your Application Tier and Build settings during in-place upgrades. As of 2012.2, we also support upgrading databases involved in SQL AlwaysOn or SQL Mirroring.
Please see our Preview docs on MSDN for instructions on how to perform in-place and migration upgrades. If you need to clone your environment to walk through a practice upgrade, you may reference the TFS 2012 Rangers Upgrade Guide, as the process is still the same. Remember to always take a current, full backup of your TFS data prior to attempting an upgrade!
You may upgrade TFS 2010 (with or without SP1) and any Go-Live version of TFS 2012 to the TFS 2013 Preview. We no longer support upgrades from TFS 2008. If you would like to move from TFS 2008 to TFS 2013, you will need to perform a two-step upgrade by first moving your server to TFS 2010 or 2012 (2012.3 is recommended), and then to TFS 2013.
Yes. The TFS hardware requirements have remained the same, but there are new software requirements. The most notable ones are that TFS 2013 now requires Windows Server 2008 R2 and higher as well as SQL 2012 SP1 (CU2 recommended) and higher. We no longer support Windows Server 2008, SQL Server 2008 R2, or SQL Server 2012 RTM. If you use SharePoint, we now require SharePoint 2010 and higher. For more details on the Preview's system requirements, see our guidance on MSDN.
No, you don't. You can continue to use Visual Studio 2012 clients with the TFS 2013 Preview. The Visual Studio 2010 SP1 client is also compatible with the Preview if you install the 2012 compatibility GDR. We no longer support integration with VS 2008 clients, except for very limited functionality through the MSSCCI provider.
The short answer is no. Every release of TFS fully replaces the previous installation of TFS on your server, so they cannot be removed like patches. There is also no "downgrade" path from a later version of TFS to an earlier one. You can roll back to your previous version of TFS using the backup you took of your data prior to upgrading, which is useful if you experience any issues configuring the TFS 2013 Preview. However, it is not possible to revert any upgraded databases back to their original servicing level, so any work you do after upgrading your server will be lost if you roll back. For more information on how to roll back your server, see the TFS 2012 Rangers Upgrade Guide.
It depends. If you are currently on TFS 2010, you will need to uninstall manually, but if you are on one of the TFS 2012 releases (2012, 2012.1, 2012.2, 2012.3), the TFS 2013 installation process will uninstall your existing instance automatically. This is consistent with the auto-uninstall behavior we had in the TFS 2012 cumulative updates.
No, you cannot. The installation process for the Preview will automatically uninstall TFS 2012 from your box. Note that this behavior is different from the Visual Studio client, where the 2013 Preview CAN be installed side-by-side with the 2012 one. If you want to try out the TFS 2013 Preview without getting rid of your TFS 2012 instance, you need to install it on a different server.
As always, we are interested to hear about any issues you encounter. If you think you've identified a setup-related bug, please email tfcare a*t Microsoft d*ot com. You can use our forums, Connect, UserVoice, or the "Send a Smile/Frown" feature in VS to give any other feedback. Happy dogfooding!
ASP.NET and Web Tools 2012.2 is a tooling refresh of Visual Studio 2012 that extends the existing ASP.NET runtime with new features without breaking existing applications. ASP.NET and Web Tools 2012.2 installs in minutes without altering the current ASP.NET run time components. Click the green button to download and install right now. For a complete description see the Release Notes or watch the video. This .2 update adds a number of new templates and features including:
Download ASP.NET and Web Tools 2012.2 Today!
From the Release Notes at http://www.asp.net/vnext/overview/fall-2012-update/aspnet-and-web-tools-20122-release-notes-rtw
This section describes features that have been introduced in the ASP.NET and Web Tools 2012.2 release.
ASP.NET Web API has been enhanced with several new features:
ASP.NET Web API OData
ASP.NET Web API OData gives you the flexibility you need to build OData endpoints with rich business logic over any data source. With ASP.NET Web API OData you control the amount of OData semantics that you want to expose. ASP.NET Web API OData is included with the ASP.NET MVC 4 project templates and is also available from NuGet (http://www.nuget.org/packages/microsoft.aspnet.webapi.odata).
ASP.NET Web API OData currently supports the following features:
For more information on ASP.NET Web API OData see http://go.microsoft.com/fwlink/?LinkId=271141.
ASP.NET Web API Tracing
ASP.NET Web API Tracing integrates tracing data from your web APIs with .NET Tracing. It is now enabled by default in the Web API project template. Tracing data for your web APIs is sent to the Output window and is made available through IntelliTrace. ASP.NET Web API Tracing enables you to trace information about your Web API when hosted on Windows Azure through integration with Windows Azure Diagnostics. You can also install and enable ASP.NET Web API Tracing in any application using the ASP.NET Web API Tracing NuGet package (http://www.nuget.org/packages/microsoft.aspnet.webapi.tracing).
For more information on configuring and using ASP.NET Web API Tracing see http://go.microsoft.com/fwlink/?LinkID=269874.
ASP.NET Web API Help Page
The ASP.NET Web API Help Page is now included by default in the Web API project template. The ASP.NET Web API Help Page automatically generates documentation for web APIs including the HTTP endpoints, the supported HTTP methods, parameters and example request and response message payloads. Documentation is automatically pulled from comments in your code. You can also add the ASP.NET Web API Help Page to any application using the ASP.NET Web API Help Page NuGet package (http://www.nuget.org/packages/microsoft.aspnet.webapi.helppage).
For more information on setting up and customizing the ASP.NET Web API Help Page see http://go.microsoft.com/fwlink/?LinkId=271140.
ASP.NET SignalR makes it simple to add real-time web capabilities to your ASP.NET application, using WebSockets if available and automatically falling back to other techniques when it isn’t.
For more information on using ASP.NET SignalR see http://go.microsoft.com/fwlink/?LinkId=271271.
ASP.NET FriendlyURLs makes it very easy for web forms developers to generate cleaner looking URLs(without the .aspx extension). It requires little to no configuration and can be used with existing ASP.NET v4.0 applications. The FriendlyURLs feature also makes it easier for developers to add mobile support to their applications, by supporting switching between desktop and mobile views.
For more information on installing and using ASP.NET Friendly URLs see http://www.hanselman.com/blog/IntroducingASPNETFriendlyUrlsCleanerURLsEasierRoutingAndMobileViewsForASPNETWebForms