Steve Lange @ Work

Steve Lange's thoughts on application lifecycle management, Visual Studio, and Team Foundation Server

  • Steve Lange @ Work

    Team Foundation Service is Live!

    • 0 Comments

    That’s right!  FKA TFS Preview has graduated to a fully-released service!

    For a graduation present, the official URL has been updated to http://tfs.visualstudio.com.

    TFS Preview will continue as a valid URL for a little while longer, but now that “TFS in the Cloud” is officially online and available, you can start using the new URL.  http://[youraccountname].visualstudio.com.

    The first real pricing option was also announced, the FREE one!  TF Service will be available for free for teams of up to 5 users, and includes all the bells and whistles that you know and love from TFS: version control, work item tracking, agile planning, feedback management, and more.  And not to mention there’s no limit on number of projects.

    Additional pricing plans will be announced as they become available, according to Brian Harry on the TFS news page.

    Enjoy!

  • Steve Lange @ Work

    Upcoming Coffee Talks from Northwest Cadence

    • 0 Comments

    Here are some upcoming webcasts from our ALM partner Northwest Cadence!  Simply click on the links in the “Code” column to register!

     

    Coffee Talk: Northwest Cadence – A Lap Around Visual Studio 2012

    Summary: An introduction to the major new features and improvements in Visual Studio 2012. Expect to see the new enhanced User Interface, Agile Planning Tools, Requirements Gathering Tool, Stakeholder Feedback Tool, Updates to the Developer and Tester Experience, Version Control Improvements, and DevOps Integration. The list goes on but the ride starts here, so buckle up and join us for this lap around Visual Studio 2012.

    DATE

    TIME

    CODE

    September 28, 2012

    October 12, 2012

    October 26, 2012

    8:30 AM –9:30 AM PST

    8:30 AM –9:30 AM PST

    8:30 AM –9:30 AM PST

    nwclaparound928

    4171027656

    4171109902

    Visit http://nwcadence.com/events for a full list of upcoming events.

    Coffee Talk: Northwest Cadence – Leveraging your SA Benefits

    Summary: Join Northwest Cadence as we provide you with an overview of the three (3) DTDPS offerings. We will explain how to activate and strategically utilize these benefits to enhance your software deployment planning. In addition, we will review how you can connect DTDPS to other Software Assurance benefits within your agreement to ensure you gain the highest return on your investment.

    DATE

    TIME

    CODE

    October 8, 2012

    November 12, 2012

    9:00 AM –10:00 AM PST

    9:00 AM –10:00 AM PST

    4184219112

    4184237166

    Visit http://nwcadence.com/events for a full list of upcoming events.

    Coffee Talk: Northwest Cadence – Introduction to Kanban

    Summary: Kanban is a Lean-inspired approach to software development. Although the rules of Kanban are simple, they are also remarkably powerful. By simply visualizing work, limiting work in process, and monitoring the flow of work, the team begins a powerful process of discovery and improvement. This has resulted in impressive improvements in nearly all areas of software development time and time again. During this event, we will talk about the five basic principles of Kanban adoption, the benefits of adoption, and the pitfalls along the way.

    DATE

    TIME

    CODE

    October 10, 2012

    October 24, 2012

    8:30 AM –9:30 AM PST

    8:30 AM –9:30 AM PST

    162401

    162402

    Visit http://nwcadence.com/events for a full list of upcoming events.

    Coffee Talk: Northwest Cadence – Migrating Without Fear: Visual Source Safe to the new TFS2012

    Summary: Moving code from one repository to another has never been the hard part of migrating from VSS to TFS. It’s fast, it’s safe, you keep backups, so what’s the holdup? If your developers have been pushing back because they’re afraid TFS will totally disrupt their daily coding practices, you’re not alone! (And they weren’t entirely wrong.) Local Workspaces in TFS 2012 may be just the thing you need to change the conversation. Learn more about these and other first-class code management features and get your team ready to make the leap!

    DATE

    TIME

    CODE

    October 31, 2012

    November 14, 2012

    8:30 AM –9:30 AM PST

    8:30 AM –9:30 AM PST

    162403

    162406

    Visit http://nwcadence.com/events for a full list of upcoming events.

    Coffee Talk: Northwest Cadence – Refactoring Without Fear: Architecture in the new Visual Studio 2012 Ultimate

    Summary: Refactoring a production application feels an awful lot like trying to swap out the hydraulics on a jumbo jet in the air. On the other hand, sub-standard hydraulics don’t sound so great either. That’s what refactoring is about: improving code to provide long-term stability and maintainability. Done right, it can reduce overall costs and dramatically increase user satisfaction, even accelerate new feature development. In this session, learn the basics of refactoring: what and why to refactor, when and how to work it into your team’s overall process, and key technical strategies like unit testing, automated build, and architectural verification that make technology renewal on-the-fly safer and simpler than ever.

    DATE

    TIME

    CODE

    November 7, 2012

    8:30 AM –9:30 AM PST

    162404

    Visit http://nwcadence.com/events for a full list of upcoming events.

    Coffee Talk: Northwest Cadence – Embracing Modern App Development with Visual Studio 2012

    Summary: Whether it’s Test-Driven Development, Test-First Development, or just plain figuring out whether your code does what you want it to do, unit testing is the standard for modern application development and a must-have for agile teams—but getting started can be a real challenge. What should you test? How granular should your tests be? How do you isolate code? How much code coverage is reasonable? If you’ve hit a wall, you’re not alone.

    Get straightforward, practical guidance you can use today to jump-start your team’s unit testing efforts and finally see for yourself what the big deal is.

    DATE

    TIME

    CODE

    November 19, 2012

    9:00 AM –10:00 AM PST

    162405

    Visit http://nwcadence.com/events for a full list of upcoming events.

  • Steve Lange @ Work

    VS/TFS 2012 Tidbits: TFS Feedback Management Behind the Scenes

    • 3 Comments

    In this post, I’m going to take a closer look at how the new Feedback capabilities in TFS 2012 works under the covers.

    In general, TFS users can request “feedback” from stakeholders about particular elements/areas of an application.  This can be either specific or general scenarios.  TFS manages the feedback process using work items and email notifications.  But how does this work, really?  Let’s find out!

    You initiate a feedback request from your project (or team) dashboard by clicking on “Request Feedback”

    image

    In this example, I’m soliciting feedback for Bing searches.  And I’ve asked for two items of feedback (called “feedback items”, see Step 3 in the screenshot).

    So what happens when I actually click send?

    Well, as far as the stakeholder is concerned, they just get an email with some simple instructions to get started:

    image

    But on the TFS side, TFS creates two work items (of type Feedback Request), one for each feedback item specified in the previous request (see #142 and #143):

    image

    Let’s look at #142 (Search for ‘Steve Lange’) and see what’s stored.

    The Title field obviously houses the name of the feedback item.  On the Details tab, the Description field holds the specific instructions that correspond with the feedback item.

    image

     

    On the Application tab you’ll find the details from step 2 on the request form (“Tell the Stakeholders How to Access the Application”).

    image

    And lastly, you’ll notice that the feedback items (Feedback Request work items) are linked together to form the more composite request.

    image

    So how can we see to whom this request was sent?  Look in the comments of the history for the work item (at the bottom of the screenshot):

    image

    The benefit of this approach is that it allows feedback items to be tracked individually.  If you submit a feedback request, but ask stakeholders to check out features that align with different backlog items/requirements/whatever, this method provides more specific tracking.

    Reuse or Making Corrections

    Another less obvious, but equally nice benefit to managing feedback requests this way is that you can make changes to the request without creating an entire new one.  This is possible because the link that’s inserted in the email sent to the stakeholders references the work item ID’s of the feedback request items, rather than embedding all the instructions in the URL (or statically somewhere else).

    So if I make a mistake I don’t have to create a brand new request, but instead the Title, Description, and other applicable fields on the Application tab and have the stakeholder simply reuse the previously-sent link.

    In this example, the URL provided in the email looks like this (see bolded area):

    mfbclients://<my_subdomain>.tfspreview.com/DefaultCollection/p:Sandbox?rid=142%2C143

    By updating either of the work items specified in the URL, the feedback session will subsequently be updated.

    More on the feedback URL

    You can modify the URL and send it directly to someone without filling out the feedback request form.  For instance, if I requested feedback of work items 142 and 143 from certain people but also wanted feedback on work item 143 from an additional person I can augment the URL and send it to that one-off person.  In this example it would look like:

    mfbclients://<my_subdomain>.tfspreview.com/DefaultCollection/p:Sandbox?rid=143

    Here’s the basic breakdown of the URL:

    mfbclients://<TFS_URL>/CollectionName/p<Project_Name>?rid=<work_item_ids>

    <TFS_URL> The URL of your TFS instance
    <Project_Name> The name of your Team Project
    work_item_ids Comma-separated list (or use %2C) of work item ID’s.  These work item ID’s need to correspond to Feedback Request work items or the Feedback Client will throw an error.

    Moving On

    So let’s say I walk through the process of providing feedback using the Microsoft Feedback Client.  For summary, here’s the feedback I provide:

    image

     

    Once I submit my feedback through the Feedback Client, a work item (of type Feedback Response) is created for each individual reply.  (See #144 and #145 below)

    image

    Again, this allows teams to track individual responses to discrete items.  So if a stakeholder skips feedback for a particular item, it doesn’t interfere with feedback on other items.

    Revisiting and Providing More Feedback

    Here’s one last great feature.  As the stakeholder, let’s say I want to either review or amend feedback I’ve already provided, or submit additional feedback.  I’m covered!  If I simply click on the link provided in the original feedback request email, upon entering the “Provide” step of my feedback session TFS is smart enough to see that I’ve already provided feedback.  In doing so, it inserts the feedback details I provided earlier into the Feedback Client.  So now I can make changes to existing feedback, or enter more information. 

    For example, here’s the Feedback Response work item created from my first submitted feedback:

    image

    If I click on the URL in the original email sent to the stakeholder, the Feedback Client runs again, and I can instantly see the feedback I’d previously supplied:

    image

    (Look familiar?)

    Really all it’s doing is looking at the Feedback Request work item, checking to see if there is a Feedback Response item submitted by me already.  If there is, it pulls the content of the Stakeholder Comments field and sends it over to the Feedback Client for the stakeholder to make further edits.  Sweet!

    Basically..

    The basic thing to remember here is that the Feedback Management process in TFS uses TFS work items to manage the storage and workflow of providing feedback.  Think of the Feedback Client as a very lightweight TFS client.  Changes you make in the Feedback Client either create or update Feedback Response work items in TFS.  Direct changes made in TFS to the work items are reflected in the Feedback Client when those work items are accessed.

    I hope this helps better explain how feedback actually works in TFS 2012.  It’s terrific and easy way to engage stakeholders to get feedback at various points in the development lifecycle.  But it’s a flexible implementation as well, providing mechanisms for reuse and more granular tracking.

    Enjoy!

  • Steve Lange @ Work

    Upcoming ALM Webcasts from Neudesic

    • 2 Comments

    The events just keep comin’ from our awesome partners!  See below for the latest schedule of ALM webcasts from Neudesic.

    October 30th Scrum and Agile Management with Visual Studio 2012, Presented by Clementino de Mendonca

    Find out how Visual Studio has become the tool of choice to manage your Scrum projects, and how it stands out of the way allowing you to do Agile in your own terms instead of forcing you to adapt your development process to a tool. We will take a tour on how you can enact Scrum best practices and cycles, allowing the team to always have a clear picture of Done should look like at the end of a sprint through using Team Foundation Server as a team communication hub.

    November 1st Requirements and Stortyboarding in the Visual Studio 2012, Presented by William Salazar

    Many teams use mockups or storyboards to describe general application appearance and flow.  This session will demonstrate new features in Visual Studio 2012 that support creating, presenting and maturing storyboards using tools you already know. And then we’ll show how this process fits into the rest of your application’s lifecycle.

    November 6th – Creating a Branch Strategy, what it is, why you need one, and how you get started, Presented by Clementino de Mendonca

    Do you know for sure which code base snapshot in your source control system matches what is in production? What is the best strategy to manage source code for team members working in parallel in different features? In this talk we will take a look at creating branching strategies that answer these and other questions, and allow you to balance simplicity, isolation, and speed in your software development efforts.

    November 8th – DevOps: Integrating Operations for Continuous Delivery, Presented by William Salazar

    Integrating Development and Operations teams deeply using new practices and tools is critical to delivering on the promise of shorter cycle times, improved mean time to repair, and increased business value that all companies that build software want to fulfill. Organizations that use practices and tools to integrate development and operations can significantly speed up their Application Lifecycle Management (ALM) process and enable continuous delivery of software to their customers, whether internal or external. Developers and Operations engineers are increasingly working closer together to maintain always on services. Visual Studio 2012 with System Center 2012 give developers and operations the tools to work seamlessly together to reduce the mean time to repair for defects in production applications.

    Learn about some of the newest features in Microsoft Visual Studio 2012 and System Center 2012, including:

    • Features to help improve the interactions between development and operations, creating better, integrated workflows
    • New lab management tools that allow teams to quickly spin up an advanced Build-Deploy-Test infrastructure
    • Deployment management features such as support for multiple package types, virtual machine management, automated deployment to private and public clouds
    • Integrated production monitoring and diagnostics tools

    Register:

    November 14th – Collecting Actionable Feedback with Visual Studio, Presented by Clementino de Mendonca

    Most teams collect feedback from customers in one way or another but it fails to trickle down as something that developers can use to improve the product. See how Visual Studio can help you capture, structure and tie feedback into your existing development efforts with Microsoft Feedback Client, allowing you to provide actionable starting points for your development and testing efforts. REGISTER TODAY!

    November 15th – Developer Testing with Visual Studios, Presented by William Salazar

    From the ground up, the developer testing experience in Visual Studio 2012 was designed to allow developers to focus on their code and avoid unnecessary distractions. Test Explorer is now easily extended, allowing you to add third-party testing frameworks in addition to those shipped with Visual Studio. Visual Studio also includes the new Fakes framework to let developers create fast running and isolated unit tests. In this session, we will review the new developer testing experience in the context of a typical day-to-day workflow, showing how these features will help you quickly write better quality code.

    November 27th – Improving Small Team Productivity with Team Foundation Server, Presented by Clementino de Mendonca

    Team members in smaller teams have always had to wear multiple hats: talk to customer, develop, test, talk to customer, fix bugs, retest, talk to customer, deploy… did I forget to mention you also have to plan your releases?  No way you can do this without some automation. Visual Studio 2012 is the suite that will boost your productivity to the max by augmenting your skills with powerful tools that will help you trace your way out of a development cycle labyrinth.

    November 29th – Making Developers More Productive with Visual Studio Team Foundation Server, Presented by William Salazar

    In this session, we will talk about those “fit-and-finish” scenarios in Visual Studio Team Foundation Server 2012 which will make developers more productive as they write code and collaborate with other team members. You’ll find out about the new integrated code reviews; the new “My Work” experience for managing your active tasks; and once you’re “in the zone” Visual Studio will now help you stay focused on the task at hand, no matter how much you’re randomized, with a new suspend/resume experience. You’ll also find out how to work offline seamlessly, how the new merging experience works, and how you can more easily find work items.

  • Steve Lange @ Work

    Windows 8 / Windows Server 2012 Installfest - Denver (October 9, 2012)

    • 0 Comments

    My colleague (and ridiculously knowledgeable) Harold Wong will be hosting a Windows 8 / Windows Server 2012 Installfest in Denver next week.  I highly encourage you to attend if you have an interest in getting a solid start on these platforms.  In his own words:

    “With the recent RTM of Windows 8 and Windows Server 2012, I am hearing a lot of interest from people who really want to start kicking the tires of these two new flagship products from Microsoft. If you are interested in getting an evaluation version of Windows 8 or Windows Server 2012 installed onto you machine to start playing with, I can help you. I will have bootable thumb drives with Windows 8 Enterprise 90-Day Eval (RTM) and Windows Server 2012 Evaluation (RTM). In addition, I will also provide VHD files that have Windows Server 2012 Evaluation and Windows 8 Enterprise RTM 90 Day Evaluation preinstalled so that we can configure your machine with Boot to VHD (no repartitioning required and keeps your existing OS intact). I will show you how to build your own VHDs so you are armed for the future.”

    This is an informal event where you can come and go at any point during the event window.

    To register, sign up here:  http://hwdenverinstallfest2.eventbrite.com/# (The registration page also lists prerequisites for your laptop, as well as some other stuff to have ready/downloaded prior to arrival).

    This event is also listed through the Colorado Microsoft Developers Meetup group here:  http://www.meetup.com/ColoradoMicrosoftDevelopers/events/82056702/

  • Steve Lange @ Work

    Content from Denver VS 2012 Launch Roadshow

    • 0 Comments

    thank you signUPDATE:  I just posted the content for the Denver and Lehi roadshows.  The link can be found on my previous post here. http://aka.ms/VS2012Roadshow

     

    First of all, THANK YOU to everyone who attended the roadshow event yesterday in our office.  We really appreciate your attendance, feedback and interaction!

    As I mentioned yesterday, I’ll be posting all the content from the sessions to this blog…. just not quite yet.  The exact same content is going to be delivered in a few additional cities over the next couple of weeks, so in order to not spoil it for others I’ll post the content publicly after a few more stops on this roadshow are complete.

    That said, if you have a pressing need to get the content earlier, contact me directly (stevenl@microsoft.com) and we can work something out!

    Thanks,

    Steve

  • Steve Lange @ Work

    VS/TFS 2012 Tidbits: Using SkyDrive/OneDrive with Team Foundation Service (or Server)

    • 0 Comments

    April 2014 Updates:

    • SkyDrive is now OneDrive
    • Team Foundation Service is now Visual Studio Online

    Team Foundation Server has always had a great integration with SharePoint by allowing organizations to leverage the goodness of SharePoint’s web parts and document libraries.  TFS can surface reports and other statistics to SharePoint so roles that are on more of the periphery of the lifecycle can still check in and see how the project is progressing.  For teams that use document libraries in SharePoint, these libraries can be accessed directly from Team Explorer, allowing developers to stay in Visual Studio (or whatever development tool they’re using) while still consuming supporting documents such as vision documents, wireframes, and other diagrams.

    And in TFS 2012, this integration continues.  However, if you’re using Team Foundation Service (AKA TFS Preview - think TFS in the cloud), it does not currently support SharePoint integration.  So this shortens the ability for teams to leverage document collaboration. 

    This is very applicable to the new Storyboarding with PowerPoint capability in TFS 2012.  You can associate storyboards with any work item in TFS; but to follow those associations and access the artifact on the other end of a link in TFS, that artifact needs to be accessible to people on your team.  Which means that your docs should be somewhere in the cloud or on a public share somewhere on your network.  If you’re using the TF service in part because your team is distributed, a public share may not be viable.  Which leaves the cloud.

    Enter SkyDrive.  SkyDrive is a great way to easily store, access, and share documents online (I share every customer presentation I deliver on SkyDrive).  And with TF Service, you’re most likely using a Live ID/Microsoft ID for authentication, that account gives you at least 7GB of space to play with for free.

    Now, you can use SkyDrive for all sorts of artifacts; but for this post I’ll be doing storyboards.  So consider my basic product backlog below (again, on my TF Service instance): 

    Sample product backlog

    Let’s say that I want to create a storyboard to support and better define “Sample PBI 4”, the second item on my backlog.  Effectively what I need to do is put my PowerPoint storyboard on SkyDrive and build the link between the PPTX and my PBI work item.

    The first thing you need to do is set up a folder (or folder structure) on SkyDrive to support all the documents you will want to associate with items in TFS.  You can create this structure either via the SkyDrive app or on the SkyDrive website as well.  For this example, I created a “TFS” folder in my “Documents” default folder, then added subfolders to store “Documents” and “Storyboards”.  Here is what it looks like:

    SkyDrive folder structure

    Regardless of how you create your structure, you’ll need to go to SkyDrive via the browser and grant permissions for others on your team to view/edit the root folder (in my case “TFS”) and its contents.  Select the root folder, choose the “Share” action, and either have SkyDrive send an email to your teammates or grab the View & Edit link and send it yourself.  Be sure to send it to your teammates’ Live/Microsoft email addresses that are associated with their TF Service account.

    There are two ways to do this, and the best path for you really just depends on if you use the SkyDrive app/client on your local computer.  I’ll describe both ways to do it below; but the end goal is to get your PowerPoint document open from SkyDrive and not your local computer.  This ensures that when you actually create the link from it to the work item in TFS, that the path that’s inserted in the link is a SkyDrive path and not a local one.

    With No SkyDrive App/Client

    If you don’t have it, or don’t’ want to use the SkyDrive app, that’s fine.  It’ll just take you a couple extra steps.

    • On the SkyDrive website, go to the folder in which you want to store your storyboard(s) (in my example TFS\Storyboards).
    • Select Create, then PowerPoint presentation

    Creating a PowerPoint presentation on SkyDrive

    • Specify a name for your storyboard.

    Naming your storyboard

    • After your PowerPoint document is created, it will be opened (blank) in the Microsoft PowerPoint Web App Preview

    PowerPoint Web App Preview

    • Select “OPEN IN POWERPOINT” at the top right.  Allow/confirm all prompts that come your way.

    image

    image

    • This will launch PowerPoint on your machine and open the storyboard you initialized on SkyDrive.

    Skip down to “Once You Have Your Storyboard Open From SkyDrive..”

    With the SkyDrive App/Client

    If you have the SkyDrive app, it’s even easier

    • Open your SkyDrive folder from your file system.
    • Right-click and select to create a new PowerPoint document.

    Creating a new PPTX from the file system

    • Give it a name.
    • Double click on you new PowerPoint document to open it.

    Alternatively, you can also launch PowerPoint, create a new presentation, and save it to your SkyDrive folder. 

    image

    You’ll just want to be sure to save it to SkyDrive before you create any links back to TFS.

    Once You Have Your Storyboard Open From SkyDrive..

    There’s a very quick and easy way to double-check that PowerPoint has opened your document from SkyDrive. Look at the “Save” button and see if it has a smaller “refresh”-looking overlay on the icon.

    Save button detecting an online document.

    Now move on and build your storyboards.

    • When you’re ready to associate it with a work item in TFS, on the Storyboard tab/ribbon, click “Storyboard Links” in the “Team” group.

     

    Selecting the Storyboard Links button

    • Create your link by connecting to your TF Service instance, finding and selecting your work item.  Again in my example, work item #138, “Sample PBI 4”.

    image

    • Save your document (always a good measure, right?)
    • You should now be able to open the associated work item and see the link to the storyboard (by default, the Product Backlog Item work item type has a tab to just show storyboard links.  If you don’t have such a tab, go to the All Links tab and you should see it there.  You can quickly verify that the link to the storyboard is an online link/URL and not a local path (if you see a local path, you didn’t open the PPTX from SkyDrive).  Notice in my example the long HTTPS link to my storyboard that contains docs.live.net and trails with my SkyDrive path (Documents/TFS/Storyboards..).

     

    image

     

    That’s it!  My instructions are probably more detailed than you need, but you’ll see that it’s remarkably easy to do.  The most important thing about linking work items to documents (storyboards, files, whatever) is to make sure that the location passed to TFS for setting up the link is an accessible one.

    Hope this helps, and enjoy!

  • Steve Lange @ Work

    Visual Studio 2012 Launch Roadshow!

    • 8 Comments

    Visual Studio 2012 Launch Roadshow

    If you’re not heading to Seattle for the Visual Studio 2012 Launch Event on September 12th, don’t worry: We’re coming to you!

    Be our guest and attend in person to experience all of the incredible new capabilities of Visual Studio 2012 first hand.

    UPDATE

    For those of you who have attended the events so far and are looking for the slides/content, look no further! Everything is here:  http://aka.ms/VS2012Roadshow

    I’ll be there, will you?

    Discover how Visual Studio 2012 allows you to collaborate better and be more agile. See how it helps you turn big ideas into more compelling apps. Experience how it integrates best practices that accelerate development and deployment.  You’ll enjoy several sessions which will take Visual Studio, Team Foundation Server, and Test Professional through their paces to show off what’s possible with this incredible release!

    Register today for a city near you (dates and locations listed below), we hope to see you there!

    Cities & Dates

    9/18

    Denver, CO

    9/25

    Lehi, UT

    10/2

    Tempe, AZ

    10/9

    San Diego, CA

    10/10

    Irvine, CA

    10/16

    Mountain View, CA

    10/17

    San Francisco, CA

    10/25

    Portland, OR

    10/30

    Boise, ID

       

    Registration/check-in begins at 8:30.  The event runs from 9:00AM to 4:00PM.

  • Steve Lange @ Work

    VS/TFS 2012 Tidbits: When to Use the Feedback Client

    • 1 Comments

    As the Visual Studio family of products (Visual Studio, TFS, Test Professional) nears its 2012 release, I thought I’d bring some short hits – tidbits, if you will – to my blog. Some of these are pretty obvious (well-documented, or much-discussed), but some may be less obvious than you’d think. Either way, it’s always good to make sure the word is getting out there. Hope you enjoy!

    When to Use the Feedback Client

    FeedbackOne of the “new” new features of TFS 2012 is the addition of the Microsoft Feedback Client for collecting feedback from stakeholders, end users, etc.  This tool integrates with TFS to provide a mechanism to engage those stakeholders and more seamlessly include their insights in the lifecycle.

    Several of my customers however, perhaps with brains overloaded with the possibilities of this capability, have asked me, “So when exactly do I use this? When do I request feedback?”

    Well, the answer, as it often times is, is “it depends.”

    First, if you aren’t aware of the two ways to use the Microsoft Feedback Client, check out (shameless plug) my previous post covering this.

    The more I play around with this tool and talk about it with customers, the more scenarios I find in which this new 2012 capability adds value.

    Now back to that “it depends” answer.. The key thing to remember for using the feedback capability is that there is no hard and fast rule for when you should use it.  But here are three main scenarios:

    • Voluntary, Unsolicited Feedback – When a stakeholder/end user has something to say, let them say it with the Feedback Client.  Instead of an email, entry on a spreadsheet or SharePoint list, using the Feedback Client leverages the goodness of Team Foundation Server (not to mention proximity to the actual development team) to log, manage, relate, and report on the stakeholder’s insights. If a business analyst or project manager likes the feedback provided, it’s just a few clicks to get a backlog item created from the feedback and shoved onto the backlog.  The feedback then becomes a supporting item for the PBI, helping address any questions as to why the PBI was added to the backlog.
    • User Acceptance Testing (UAT) – When a new feature has been developed and made available for UAT, request feedback from one or more knowledgeable stakeholders to get sign-off.  Linking the feedback request to the PBI/task/bug being tested for acceptance not only gives additional traceability in validating sign-off; but it provides the team additional “clout” if a stakeholder later voices a concern about a feature completion (“You said you liked it, see?”).
    • Checkpoints/Continuous Feedback – Feedback doesn’t have to be just at the beginning and end of a sprint. Any time there’s something new that QA’s already had a run at, why not involve a stakeholder? While you can, you don’t have to wait until a sprint’s over to get feedback.

     From MSDN, “Planning and Tracking Projects”:Planning and Tracking Projects

    What other scenarios can you think of where you could leverage the new feedback capabilities in VS 2012?

  • Steve Lange @ Work

    VS 2012 ALM Tidbits: The Feedback Client’s Two Modes

    • 4 Comments

    As the Visual Studio family of products (Visual Studio, TFS, Test Professional) nears its 2012 release, I thought I’d bring some short hits – tidbits, if you will – to my blog. Some of these are pretty obvious (well-documented, or much-discussed), but some may be less obvious than you’d think. Either way, it’s always good to make sure the word is getting out there. Hope you enjoy!

    The Feedback Client’s Two Modes

    One of the “new” new features of TFS 2012 is the addition of the Microsoft Feedback Client (download) for collecting feedback from stakeholders, end users, etc. This tool integrates with TFS to provide a mechanism to engage those stakeholders and more seamlessly include their insights in the lifecycle.

    It’s important to know that this new tool provides a mechanism for collecting feedback in two distinct manners, voluntary and requested. The rest of this post will walk through each of these “modes”.

    Regardless of the mode used to provide feedback, this feedback gets stored in TFS as a work item (of type Feedback Response) which then gets all the benefits of being a work item (auditing, assignment, linking, reporting, etc.). As you can imagine, this is a much more effective way of tracking feedback than email, lists, and forms. We’ll talk about that (plus licensing) toward the end of this post.

    Voluntary Feedback Mode

    This mode is used naturally by a stakeholder (I’m using the term “stakeholder” to mean anyone that may want to have a say in how a product evolves) to provide unsolicited feedback about a product or application. This means that if a stakeholder is using an application and thinks of an idea to improve it (or maybe even to report a problem), they can fire up the Feedback Client and include annotated screenshots, record video or audio, and notes.  

    Voluntary feedback

    In this screenshot, I provide “voluntary” feedback that I should be more prominently featured on Bing. Yes, I’m that way.. ;)

    This is an incredible light and easy way for a stakeholder to feel like they have a say/vote in the direction of an application.

    Requested Feedback Mode

    As the name implies, this kind of feedback is given in response to a request for feedback from another user. Requesting feedback begins in Team Web Access on a project’s home page, by clicking on the “Request feedback” link under Activities. 

    Request feedback

    The requestor fills out the Request Feedback form:

    Request feedback form

    Which sends the following email to all included stakeholders (yes, you can send a single request to multiple recipients, as well as request multiple items of feedback in a single request):

    Feedback request email

    When the stakeholder clicks the link in the email, the Feedback Client will launch and walk the stakeholder through the process.Requested feedback in Feedback Client

    Once the feedback is submitted, everything shoots back into TFS and is automatically linked to the Feedback Request work item.

    Response linked to Request

    Looking at the feedback response in my example:

    Feedback Response work item

    Okay, Now What?

    Now that you have feedback in TFS, what do you do with it?

    Several things, actually.  First, leverage the linking capabilities of work items to associate feedback with the appropriate task, backlog item, bug, or whatever. In my example, I linked my feedback request to a PBI:

    image

    This provides an even more cohesive story for “covering” the PBI.  Now not only can you see from a PBI all the tasks, storyboards, bugs, etc. related it to it, but you have a way to track “sign-off”, or at least unofficial support from stakeholders about the “doneness” of the backlog item.

    Also, you may want to is create a few shared queries to better help you view and track feedback.

    Feedback queries

    In this example, I created 4 queries to help me manage feedback (again, just an example):

    • All Feedback – Flat list showing all feedback responses (voluntary or requested).
    • Feedback Requests & Responses – Direct links query showing all feedback request and any associated responses.
    • Feedback without PBI – Flat list showing all feedback requests and responses that are not associated with a Product Backlog Item.
    • Unsolicited Feedback – Flat list showing all voluntary feedback.

    Lastly, if stakeholder feedback is important to you, add one of your feedback queries as a Team Favorite, which will make it show up on your team’s home page.

    Team Favorites

    Licensing

    • To provide feedback (i.e. use the Microsoft Feedback Client), there is no licensing requirement at all. The Feedback Client tool is free to download, and there is no TFS CAL requirement to use it.
    • To request feedback (i.e. solicit feedback from others), you need to be part of one of the following licensing groups: Visual Studio Premium, Visual Studio Ultimate, or Visual Studio Test Professional.

     

    There’s plenty of documentation on stakeholder feedback, but something that can fall through the cracks is the fact that there are indeed two modes of using this capability.

    Hope this helps!

  • Steve Lange @ Work

    Want More VS 2012 ALM Training? You Got It!

    • 1 Comments

    VS_Purp526_rgbOur friends at Northwest Cadence are offering a FREE two-event series in August.  These online events cover four individual sessions:

    • Session 1: A Lap Around Visual Studio 2012
      An introduction to the major new features and improvements in Visual Studio 2012. Expect to see the new enhanced User Interface, Agile Planning Tools, Requirements Gathering Tool, Stakeholder Feedback Tool, Updates to the Developer and Tester Experience, Version Control Improvements, and DevOps Integration. The list goes on but the ride starts here, so buckle up and join us for this lap around Visual Studio 2012.
    • Session 2: Visual Studio 2012 for Agile Teams
      Getting the tool out of the way and letting you stay in the zone is a big part of Visual Studio 2012. Come experience the new developer experience and workflows for work items, version control, unit testing, and code reviews. Visualizing your current work and updating status is almost effortless, version control is much more flexible, continuous testing made possible by a new unit testing interface, and a true code review workflow is available for collaboration and feedback.
    • Session 3: Storyboarding and Feedback Manager
      Bringing people with the good ideas into the software development process! Storyboarding and Feedback Manager can dramatically improve the quality of your requirements, and provide the voice of the customer to your development team. Storyboarding allows you to leverage the familiar features of PowerPoint to drive a completely new requirements-gathering experience. Feedback Manager provides a clean, intuitive interface to provide video, voice and image feedback. Both allow for powerful interaction between stakeholders, business analysts, developers, and testers, smoothing out the handoffs to ensure continuous delivery of customer value.
    • Session 4: Leveraging your Microsoft and Northwest Cadence Benefits for Visual Studio 2012
      Join Northwest Cadence as we provide you with an overview of the three (3) DTDPS offerings. We will explain how to activate  and strategically utilize these benefits to enhance your software deployment planning. In addition, we will review how you can connect DTDPS to other Software Assurance benefits within your agreement to ensure you gain the highest return on your investment.

    To reserve your space in an upcoming series, please choose a date:

    For more information, please email Rick.Flath@nwcadence.com

  • Steve Lange @ Work

    Additional VS 2012 ALM Webcasts by Imaginet

    • 1 Comments

    Take a look at the below webcast series from Imaginet focusing on Visual Studio 2012 ALM.  If something looks good, don’t forget to sign up!

    “Imaginet is thrilled to provide you with exclusive invitations to our Summer Webcast Series. Over the last year, Microsoft has made some significant announcements that affect software developers, architects, information technology professionals, and businesses profoundly. This is your exclusive opportunity to gain incredible insights, learn new skills, and understand how to best leverage some incredible new technologies from Microsoft.
    Space is limited to 500 participants per webcast!”

    Requirements and Storyboarding with Visual Studio 2012

    The saying "a picture is worth a thousand words" is true for requirements. Many teams use mockups or storyboards to describe general application appearance and flow. This session will demonstrate new features in Visual Studio 2012 that support creating, presenting and maturing storyboards using tools you already know. And then we'll show how this process fits into the rest of your application's lifecycle. Come join us for this free Web Workshop!

    • July 31, 2012 - 1:00-2:30pm CT   Register (free)

    Scrum and Agile Management Using Visual Studio 2012

    Scrum and agile management methodologies focus on iterative planning, development and release. This session will demonstrate how agile planning, management and tracking are streamlined with Visual Studio 2012. Come join us for this free Web Workshop!

    • August 7, 2012 - 1:00-2:30pm CT   Register (free)
    • August 21, 2012 - 1:00-2:30pm CT Register (free)

    A Day in the Life: Developer Enhancements with Visual Studio 2012

    The next version of Visual Studio is rich with new tools that enhance standard developer activities. In this session we'll review and demonstrate some of these new features, such as Unit Testing, Code Reviews, Code Clones and other developer tools. Come join us for this free Web Workshop!

    • August 14, 2012 - 1:00-2:30pm CT   Register (free)
    • August 28, 2012 - 1:00-2:30pm CT   Register (free)

    For questions or more information on Imaginet's webcasts, please feel free to contact us at info@imaginet.com or by calling 1-800-989-6022.

  • Steve Lange @ Work

    VS/TFS 2012 Tidbits: Requesting a Code Review on Code Already Checked in

    • 18 Comments

    As the Visual Studio family of products (Visual Studio, TFS, Test Professional) nears its 2012 release, I thought I’d bring some short hits – tidbits, if you will – to my blog. Some of these are pretty obvious (well-documented, or much-discussed), but some may be less obvious than you’d think. Either way, it’s always good to make sure the word is getting out there. Hope you enjoy!

    Requesting a Code Review on Code Already Checked in

    There’s been great hype about the new built-in code review capabilities in TFS 2012, and for good reason. The process is easy, effective, and most of all, audited.

    image

    But did you know that “My Work” is not the only place from where you can kick of a code review?  You can also do a review on code that’s already been checked in. Go to the file in Source Control Explorer, then view its history. In the History window, right-click on the changeset/revision and select “Request Review”.

    image

    This will load up the New Code Review form in Team Explorer:

    image

    Notice that it not only brings in the files from the changeset (5 of them, in this example), but also any work items that were related to this changeset as well.  The check-in comments are used to populate the title of the code review, as well as the optional description.

    Off ya go!

  • Steve Lange @ Work

    VS/TFS 2012 Tidbits: Merging Changes by Work Item

    • 4 Comments

    As the Visual Studio family of products (Visual Studio, TFS, Test Professional) nears its 2012 release, I thought I’d bring some short hits – tidbits, if you will – to my blog. Some of these are pretty obvious (well-documented, or much-discussed), but some may be less obvious than you’d think. Either way, it’s always good to make sure the word is getting out there. Hope you enjoy!

    Merging Changes by Work Item

    This is something that existed in VS 2010, but it wasn’t talked about as much.  While it’s pretty straightforward to track changes merged across branches by changeset, sometimes it’s even more effective to track merges by work item (i.e. show me where changes associated with a work item have been merged/pushed to other branches).

    Let’s catch up. Consider the relatively simple branch hierarchy below:

    image

    A work item has been assigned to Julia, Task #80.

    image

    Julia makes some code changes, and checks in against (linking to) the work item (Task #80).

    She checks in 2 individual changes to create links to 2 discrete changesets from the task.

    Now, it’s easy to go ahead and track an individual changeset by selecting the option from the History window.

    image

    That’s all well and good, but if I didn’t know the exact changeset ID (#17), or if there was more than one changeset in associated with the task, this tracking process becomes less effective.

    What Julia can do is right-click on the work item and select “Track Work Item”.    (Note that this option will be disabled if there are no changesets linked to the work item.)

    image

    She can also click the “Track Work Item” button at the top of the work item form:

    image

    I get a much clearer picture now of all the work and where it’s been applied, and the “Tracking” visualization will now include all changesets (in my case, 2 changesets) in the window.

    Now I know exactly what changes to merge.  I merge them, and now I can see that the entire work item has been merged to Main from Dev (i.e. both changesets were merged).

    image

    And just as effectively, I can see these changes in the Timeline Tracking view:

    image

    So that’s it! Tracking by work items are pretty easy to do, and paint a much clearer picture of how a change from a work item perspective can, or has been, applied across branches.

    Again, I know this isn’t exactly a new feature, but there are a lot of people out there who are looking for ways to “merge by work item” and aren’t aware of this feature.

  • Steve Lange @ Work

    VS/TFS 2012 Tidbits: Agile Planning - Drag & Drop to Assign Sprints

    • 0 Comments

    As the Visual Studio family of products (Visual Studio, TFS, Test Professional) nears its 2012 release, I thought I’d bring some short hits – tidbits, if you will – to my blog.  Some of these are pretty obvious (well-documented, or much-discussed), but some may be less obvious than you’d think.  Either way, it’s always good to make sure the word is getting out there.  Hope you enjoy!

    Agile Planning: Drag & Drop to Assign Sprints

    TFS 2012 places a greater emphasis on “agile” planning, enabling teams to more readily plan, monitor and augment their iteration assignments.  Regardless of the methodology used (Scrum, Agile, CMMI, or your own), this tool “just works” to help you in the planning process.

    One new, and welcome, addition to TFS 2012 is the added support of start and end dates on iterations.  This allows you to simplify the process of building iteration-specific queries, and provides better insight as to what sprint a team is currently working on.

    To assign a work item (PBI, task, bug, whatever) to an iteration in the past, you had to open its dialog, set the correct iteration path value, and save it. Not a big deal, but excessive if you need to assign several work items in a single planning session.

    Fast-forward to TFS 2012.  When viewing your product backlog (however you have defined a “product backlog”) in the new TFS Web Access (which looks WAY cooler than the WA of old, right?) interface, you’ll see all your sprints/iterations listed on the left.  To assign a backlog item (in this case) to a sprint, you can instead drag the work item from the backlog to the sprint you want to put it in.  In the below screenshot, I’m dragging the second backlog item (“The calculator should perform division”) to Sprint 4.  The new web access client automatically updates the work item accordingly.  Done!

    Assigning a PBI to a sprint via drag and drop

    Assigning work items to iterations can be done pretty easily when looking at a work item query result as well.  If you’re in a view which doesn’t show the iterations to the left, for example, looking at “Assigned to me”, you can simply right-click on a work item and choose “Move to iteration –> <your iteration>”.  See the below screenshot of my doing exactly that.

    Moving a work item to a specific iteration

    Simple, yet effective!

  • Steve Lange @ Work

    Denver Event: SQL Server 2012 Breakthrough Insights

    • 0 Comments

    Looking to go deep into SQL Server 2012’s BI capabilities? Then this event may be what you’re looking for!

    Date/Time: Friday, July 20, 2012, 09:30-2:00 PM Mountain

    SQL Server 2012 "Breakthrough Insights." This will be a "deep dive" into the SQL Server Business Intelligence model including PowerPivot, Power View and SharePoint integration. This will be taught by Microsoft's Ted Malone. Ted works with large Microsoft customers to help them engage with emerging technology to solve complex business problems. Ted also has extensive experience as a software architect designing and developing enterprise storage solutions for EMC. Don't miss this opportunity to learn from one of Microsoft's best.

    To register, go here: https://clicktoattend.microsoft.com/en-us/Pages/EventDetails.aspx?EventID=161121

  • Steve Lange @ Work

    Pluralsight + MSDN = Loads of free training!

    • 1 Comments

    Pluralsight - Hardcore Developer TrainingIn case you missed the reminder in the latest MSDN Flash, here’s another gentle nudge:

    MSDNFor a limited time, all MSDN subscribers in the US can get a FREE 1 year “starter” subscription to the list of 20 Pluralsight courses listed here on their website.

    This is a great opportunity to leverage even more of your MSDN subscription. Get over to Pluralsight’s page and sign up sooner than later! (Yes, this offer will expire!)

     

    .

  • Steve Lange @ Work

    Hey Denver, there’s a new Meetup in town!

    • 1 Comments

    If you haven’t already joined, head over and check out the Colorado Microsoft Developers Meetup.  My pal Jerry Nixon started it about a month ago to create a central place for our development community find out about events (MSDN, MS-sponsored, others) happening in the area.  He’s also graciously added me as an organizer so we’ll be able to include development tools-specific events (ALM, TFS, Visual Studio, testing, etc.) to the calendar as well!

    image 

  • Steve Lange @ Work

    Catching up..

    • 1 Comments

    Summer is here, and to help say goodbye to Spring, I thought I’d list a few tidbits that you may or may not have heard about in the news recently:

    There are two great books out now that cover Visual Studio ALM 2012.  These are among the first and most comprehensive books to dive into Application Lifecycle Management and Team Foundation Server, and are well worth the read!

    Team Foundation Service Preview goes public!  What? Yep, no more waiting for invite codes.  Go at it! You can just go to the home page (http://tfspreview.com) and sign up for your account.  As of right now, everything is still free. Check Brian Harry’s blog for more details.

    Virtual Machines & Hands on Labs have been updated to 2012 RC.  For details and download (it’ll take a while, so get comfortable), see Brian Keller’s post.

    There’s a lot more, but these are the highlights from the ALM side of things. 

  • Steve Lange @ Work

    Microsoft’s Visual Studio ALM is a leader in the the Gartner Magic Quadrant

    • 3 Comments

    The brilliant minds at Gartner have positioned Microsoft in the “leader” quadrant for Application Lifecycle Management, in their June 5th, 2012 publication, “Magic Quadrant for Application Life Cycle Management” (available for 12 months following publication).

    Their evaluation was based on Visual Studio 2010 and Team Foundation Server 2010. I can’t wait to see what they think of the 2012 version once it releases!

    Magic Quadrant for Application Life Cycle Management (Gartner June 2012) 

    I’ll let you read the report (Microsoft section) for full details, but notable quotes include:

    “By virtue of its position in the market as a provider of key platforms and development tools, Microsoft acts as an overall thought leader in the ALM market”

    “Unlike all of the other tools in this Magic Quadrant, Microsoft's is the only one that tightly binds its versioning system to the rest of the ALM planning tool.”

    “..the company has made good strides with support for Eclipse and the ability to extend TFS with Java code.”

    This is truly a great accomplishment for our teams at Microsoft.  Congratulations to all!

  • Steve Lange @ Work

    Come to the SURF Incubator! Build Win8 Apps!

    • 0 Comments

    Come join us at SURF Incubator in Seattle over the course of 4 different Wednesday nights to build great Windows 8 apps. Throughout the course of this four-part series, guests will have a chance to learn from Microsoft experts about the world’s largest opportunity for app developers.

    We’ll also have great food and drink each night, and you’ll also have the opportunity to win great prizes! (See Official Rules here)

    Register now! https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032514870&Culture=en-US

    SURF Incubator

    Exchange Building

    821 2nd Ave., 8th Floor

    Seattle, WA 98104

    Wednesdays, June 20, 27, July 11, 18 from 6pm-9pm

    Series Schedule

    June 20 - Week 1:
    · Business Opportunity for Windows 8
    · Designing Apps with Metro Principles and the Windows Personality


    June 27 - Week 2:
    · How Metro style apps drive end user impact
    · Building Metro style apps with HTML and JavaScript
    · Creating Windows 8 Metro Style User Interface (UI)

    JULY 4 – SKIP – HOLIDAY WEEKEND


    July 11 - Week 3:
    · Bring Your App to Life with Live Tiles and Push Notifications
    · Integrating with key Windows 8 features

    June 18 - Week 4:
    · Applying the finishing touches
    · The Business Opportunity Continued: Monetizing your app
    · The Windows Store

  • Steve Lange @ Work

    Hey! We’re looking for great Windows 8 Apps!

    • 0 Comments

    As you likely know Windows 8 is coming in the near future. You can download, use it, and even develop apps for it today. At this point in time the Windows Store is not open for everyone to deploy, but we are looking for the first wave of great applications which highlight the power of Metro and Windows 8, especially those developers that want to get to market first and build the awareness and brand for their applications.

    In order to submit your application today you need a token which is something I can help you get.

    What do you need to do to get a token? Well I’ll tell ya.

    1. Create a great application or game and get it ready.
    2. Let me know about it by contacting me: stevenl@microsoft.com
    3. I’ll help you register so you can get your application through our Application Accelerator Labs where the app will get reviewed to confirm it is done and conforms to the Metro guidelines and certification requirements.

    This is a great opportunity to not only be first to market with your app, but also to get feedback from a Microsoft Services Engineer to make your app great. If you are serious about creating an application this is a chance that you probably don’t want to pass up.

    In addition, my extended team is holding a series of events and office hours to help you – they want to make sure you have what you need to be successful. You can come learn more about how to build apps for Windows 8 or show up and build your app with one of our evangelists or others in your community available to help you if you need it. You can find more information here:

    image

    See below for upcoming developer camps and accelerator labs (click on the link on the city to register!):

    Windows Developer Camps

    Windows Application Accelerator Labs

    So, do you want to build the next great Windows 8 app, first?

  • Steve Lange @ Work

    Slide content from Denver ALM Roundtable

    • 1 Comments

    This is a slightly tardy post, but here is a link to the presentation slide deck used by Peter and Matt during the ALM Roundtable in Denver.  You’ll see that it’s rather light; but keep in mind the slides were merely for talking points leading to more demo (remember, this was a demo-heavy event!).

    If you have any questions, please let me know!

  • Steve Lange @ Work

    Thoughts on Managing Documentation Efforts in Team Foundation Server

    • 1 Comments

    I’ve met with several customers over the last few months who either are, or are looking to, manage their documentation efforts in Team Foundation Server.  There’s not much guidance or documentation about the best way to do that.  Now my blog is hardly a repository of impactful information; but I hope this post helps to shed some light on practices that can be used to manage documentation in TFS.

    In thinking about this, the concept of documentation management is somewhat similar to requirements management:  A document format is the ultimate output, consistent capture and management is ideal, and a development workflow is needed.  Several years ago (when TFS 2005 was the current release), I blogged a four-part series on requirements management in TFS, a series which many seemed to appreciate.  (Since then, a much more robust, prescriptive guidance has been published on CodePlex around TFS 2010 called the “Visual Studio Team Foundation Server Requirements Engineering Guidance” ). 

    There are two main schools of thought around using TFS to manage documentation efforts:

    • Document-centric
    • Item-centric

    Document-Centric

    In the document-centric approach, the document itself is the “version of the truth”. Updates are made to the document directly, and either TFS or the associated SharePoint site manages versioning.  Any approval workflows are handled by SharePoint.

    The benefit of this approach is that people already know how to edit a document (Word is the most popular requirements management tool, as well!).  It’s natural and seemingly convenient to just pop open a document, make some updates, hit “Save”, and close.  When the documentation process is finished, you already have your “output” – the document itself.  Just convert it to the format that you want (PDF, XPS, whatever), and you’re done.

    The drawback however, is in its simplicity.  You lose formatting consistency of individual sections of the document, as well lower-level management of those sections.  This results in extra scrutiny over a document to check for those inevitable inconsistencies. If you have traceability requirements in your process guidelines, it’s going go be very difficult to accurately relate a specific section within a document to another artifact in TFS.  It’s quite near impossible to report on the status of a documentation effort, other than “the document is or isn’t done yet.”  There are no metrics around how much effort has been applied to the documentation, how many people have collaborated on it, etc.

    Item-Centric

    The item-centric approach uses the work item tracking system in TFS to manage components/pieces of documentation individually.  This is accomplished by creating a work item type designed to support individual pieces of documentation.  In this scenario, TFS becomes the “version of truth”, and the actual document is really just an output of that truth. (Think of this as similar to version control, which houses the truth of your code, and the build is the output of that.)

    Several of these RM-centric approaches can be applied toward documentation efforts:

    • Custom work item types
    • Consistent UI for consistent data capture
    • Querying and reporting
    • Categorization or classification

    Below is just one example how a “Documentation”-like work item type might look in TFS:

    Sample documentation work item type

    You’ll notice there are standard fields such as title, assigned to, state, area, and iteration.  In this example, there are a few custom fields added as well:

    • Document Structure (group)
      • Target Document
      • Document Order
    • Documentation

    Target Document allows you to target a specific document that this documentation piece belongs to.  In my example, I use a global list for this field, allowing choices of End User Manual, Administrator’s Guide, and Installation Guide.

    Document Order is a field I created to help with the ordering of the documentation piece (for sibling work items) when it is finally output into a document.

    In TFS 2010, you also have the added advantage of work item hierarchy to better help organize the structure of your documentation. You can use hierarchy to break down sections or areas of the document.  Viewing the “structure” of a document (like a document outline in Word) is a matter of constructing a query.

    For example, below is a query result that shows a document hierarchy for my “End User Manual”:

    image

    There are a few very tangible advantages of using this approach:

    • Each section of documentation is individually manageable.  They can be assigned to different people, follow individual workflows, and be reported on and queried against.  Documentation can much more explicitly be planned as documentation work items can be put into sprints, iterations,etc.
    • Sections can be modified using a number of tools (Team Explorer, Excel, Web Access, or several 3rd party integrations).
    • Documentation work items, as they are work items, can be related/linked to other artifacts they support.  For instance, you can tangibly relate a build, task, requirement, or even code to a piece of documentation.
    • You can use work item queries to help identify and track the progress of your documentation efforts.  For example, while the previous screenshot shows the entire tree of documentation items, you could have another query to display the items that haven’t yet been completed:

    image

    Creating your Document

    Sounds great, right?  Oh yeah, but what about actually creating the document itself? (What, you don’t just want to dump the query results to Excel and format from there?)

    Well, the first main step is to get your work items exported to a Word document (for any fine tuning) and ultimately converted to your final output format (probably PDF).

    If your list of documentation work items is flat (i.e. no hierarchy, parent/child relationships), that simplifies things because you can dump your work items to a file format that can be used as a merge source for Word (like a TSV or Excel file).  Then you really just have to worry about formatting your document appropriately.

    And there are a couple of 3rd party tools that you may (again, based on your specific needs) be able to leverage.  These tools work to integrate Word with TFS, and each carries their own pros and cons:

    It gets more complicated as you work with a hierarchy.  In my above example, I want my work item hierarchy to reflect  a document hierarchy in the output document (i.e. first level gets Heading 1, second level gets Heading 2, etc.).  That puts a small wrinkle in things.

    So when in doubt, roll your own.  I have several customers who have implemented custom utilities to export their documentation work items to a Word document.  Given my amateur status as a programmer, I thought I’d give it a shot myself.  More on that in a future post, but the basic idea of such a utility is something like this:

    1. Select the WI query that gives you the work items you want, in the right order, etc.
    2. Select a document template to use, or at least a document style.
    3. Click “go”, and watch the utility run through each work item in the query results, inserting field values in the appropriate placeholder (named area, bookmark, whatever) in the document.

    Again, more on that later.

    Summary

    So keep in mind that while your mileage may vary in terms of approach and need, it is definitely possible to leverage TFS WIT as repository for your document development needs.  My examples above are by no means the only way to attack this topic – I’ve just seen them work with other customers of mine.

    Enjoy!

  • Steve Lange @ Work

    Content from the VS11 ALM Roadshows (Denver/Phoenix/Lehi)

    • 0 Comments

    Happy Monday!

    First, thanks to all of you who have attended the ALM Roadshows so far, and I hope to see many more of you attend the upcoming stops.

    VS 11

    Many folks from the Denver and Tempe events asked if the content would be made publicly available (to help minimize the amount of note-taking required).  So as promised, this morning I posted the slide decks from the three sessions on SkyDrive here:

    Here are direct links to the individual sessions:

    1. Continuous Delivery
    2. Beyond Software Testing with Agile Team Support in Visual Studio 11
    3. Beyond Code - Increasing Developer Productivity

    And again, if you want to more easily download all the session content, you can view the entire folder here.

    The demos performed during the sessions are very similar to the labs which are included in a publicly-available VM by Brian Keller.  Download the VM + labs from here and enjoy a pre-configured environment will all the VS11/TFS11 Beta goodness ready to roll.

    For those of you that will be attending a roadshow event in the near future, take note: Exact content varies between venue, so the content I posted is really most applicable to Denver, Tempe (Phoenix), and Lehi (Salt Lake City).

    And as a reminder, if you can’t make it to an in-person event, definitely check out some of the many webcasts being delivered as well.

Page 3 of 14 (347 items) 12345»