Have app ideas?  Have software development skills?  If so, that’s all you need to learn, compete and win! 6 Cities, 100’s of developers and 1000’s of great ideas.

THE MAIN EVENT

WINDOWS 8 APP FACTOR LEARN | Fun day of “training and auditions” where you will learn what you need to know to take your skills and ideas into a new economy.

• Form a team where you can use your skills and compete to win.
• Learn how to build an app from idea to store submission. 
• Start from scratch or use a beautiful sample to get started.
• Free consulting from the local evangelist team (in person or online). 

MEET YOUR COMPETITION

WINDOWS 8 APP FACTOR COMPETE | Windows 8 App Factor Compete will provide you with an opportunity to show off your app and hard work to the world and potentially win.

If you don’t have time to attend in person, no big deal, just submit your work of art online to be eligible to win fabulous prizes. Find out what amazing apps are coming out of your community. Watch and see which developers truly have the App Factor, register today!

Special Note: To participate in these sessions, you will need to bring your own computer (laptop preferred). Prep info available at: www.windows8appfactor.com.

We look forward to seeing you there!

REGISTER NOW

(Click on the city for which you’d like to register)

For more information or to register, visit: www.windows8appfactor.com or call 1-877-MSEVENT

HOPE TO SEE YOU THERE!

Consider this scenario:

1. User A opens a work item (and keeps it open)
2. User B opens the same work item, makes a change, and saves it.
3. User A (with work item still open), decides to make a change.

In Team Foundation Server 2010 (and previous releases for that matter), support for multiple users editing the same work item at the same time was simple and blunt.

When User A makes a change (based on a now out-of-date version of the work item), he’s presented with the TF237079 error (again, I’m looking at TFS 2010 currently):

This occurs regardless of the field you modify (i.e. if User B changed “Description” and User A changed “Title”, this condition still rears its head).

Dang!  Now what?  You need to refresh the work item (to suck in the updated version), and lose your proposed changes (well, you have to input them again).  The work around for this is simple: If you like to keep work items open (for reference, or whatever) and don’t want to get “blocked” should you decide to make a later change, click the refresh button prior to making your changes.  This will reduce the chance that someone else slides in an update before you do.

Team Foundation Server 2012 handles this scenario more smoothly.

Let’s revisit the scenario I listed above.  When user A makes his change and clicks “Save”, TFS will check to see if the work item has already changed.  If it has, but User B’s change (say to “Description”) doesn’t conflict with User A’s proposed change (say to “Title), it just works (this condition is equivalent to merging in version control when there are differences but no conflicts).  TFS will save the User A’s change and refresh the work item for him (so now User A can see his save, as well as the updated field values from User B).  Basically, TFS will auto-merge work item updates when different fields are updated (i.e. no stepping on toes).

If the same field is has been updated by User B and User A, now you effectively have a true merge condition.  In this case, TFS will give you this message, TF248023:

Look at what the message is saying.  It’s not blocking you – it’s warning you that you may step on someone’s toes (i.e. there’s a direct conflict with a field you’re trying to update).  If you close this dialog and try to save the work item again, it will allow you to save!  Now ideally, you’d take a look at the work item history (per the dialog message) to see check on what changes you’re potentially overwriting before saving; so consider this message as a warning from TFS 2012 saying “I’ll let you save this if you really want to, but don’t say I didn’t tell you so if someone gets mad!”

So again, in previous versions of TFS, the above scenario doesn’t really work.  You’re forced to refresh the work item and re-enter your changes.  In TFS 2012, if there are no direct field-level conflicts, it works just fine.  If there is a direct conflict, you’ll get warned first.

Hope this makes sense!

Northwest Cadence has some webcasts in the hopper – check them out!

Check out the latest round of webinars from Imaginet! Click on the date/time to register..

Top Business Benefits of Application Lifecycle Management (ALM)

Why should your business focus on Application Lifecycle Management? What benefits will you see to your overall business? How does ALM impact your bottom line? Come attend this free webinar to discover all the answers!

April 1, 2013
1:00 - 2:00 pm CT

June 3, 2013
1:00 - 2:00 pm CT

Quality Coding: What’s New in Visual Studio 2012

The newest release of Visual Studio 2012 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 Webinar!

April 4, 2013
1:00 - 2:30 pm CT
April 18, 2013
1:00 - 2:30 pm CT

May 9, 2013
1:00 - 2:30 pm CT
May 23, 2013
1:00 - 2:30 pm CT

Getting Started with Coded UI Testing: Building Your First Automated Test

This training seminar will demonstrate how to record tests run against various types of application user interfaces using Microsoft Visual Studio's Coded UI Tests and how to replay them at any time.  Additionally, we will explore how to embed validations, either simple or elaborate, to ensure your application is producing the correct results.  Learn how to improve the quality of your applications by having a repeatable set of Microsoft Coded UI Tests available to ensure defects don’t go unnoticed!

April 11, 2013
1:00 - 2:30 pm CT
April 25, 2013
1:00 - 2:30 pm CT

June 13, 2013
1:00 - 2:30 pm CT
June 27, 2013
1:00 - 2:30 pm CT

The How, What, and Why of Performance Testing Your Applications

Verifying that a system works with a single user does not mean it will work in real-life scenarios.  Performance testing allow you to simulate real-world scenarios to verify your system will function and perform after real users start using it.  This session will demonstrate how Microsoft's Visual Studio 2012 can be used to perform both stress and load tests against a variety of technologies.  Come join us for this free Webinar!

May 2, 2013
1:00 - 2:30 pm CT

Managing Test Labs Without Headaches

In 2010, Microsoft released a bold new features to support management of virtual test environments.  "Lab Management" provided the ability to easily spin up test environments, perform automated build and deployments, run automated tests, and collect diagnostic data. Unfortunately, many teams were discouraged by the infrastructure requirements.

Now, with Visual Studio 2012 and standard environments, even small teams or groups that can't use Microsoft's Hyper-V can still benefit from lab management.  This session will demonstrate how to configure your existing environments for many of the same compelling features formally available only with Hyper-V. Come join us for this free Live Web Workshop!

June 6, 2013
1:00 - 2:30 pm CT
June 20, 2013
1:00 - 2:30 pm CT

Microsoft’s Build conference is on its way to San Francisco June 26th-28th!  Come see all the goodness around developing great experiences around Windows, Windows Phone, Windows Azure, IE, Office 365, and Xbox!

Registration opens at 09:00am PDT, April 2, 2013
Early bird (first 500): $1,595 | Full: $2,095

So don’t forget to register!  Oh, and you can follow Build on Twitter as well: Follow @bldwin

In the world of Scrum or Agile, do requirements really still matter that much? Well, if you want to compete in the world of the modern application, absolutely!

In fact, they matter more than ever. Shorter release cycles mean that typical impediments to value delivery impact the application lifecycle more than ever. The challenge of “getting requirements right” is crucial to getting the right thing out the door before your competitors do.

Come join us for this half-day event where we’ll:

• Examine the impact that these compacted release cycles have on the application lifecycle and how they apply to the world of requirements.
• Explore how Microsoft Team Foundation Server can serve as the mechanism to manage your requirements as well as how they integrate with the rest of the lifecycle.
• Showcase InteGREAT by eDev Technologies, a robust requirements lifecycle management platform that can help teams meet the ever evolving needs of the modern application world.

We’re bringing this unique event to four (4) cities throughout the Western US.  Click on the city closest to you to register! (Oh, and this event is FREE!)

• April 23rd – Irvine, CA
• April 24th – Sunnyvale, CA
• April 25th – Bellevue, WA
• April 26th – Salt Lake City, UT

I hope you can make it!

A couple of customers have asked me about this in the past couple of weeks:  “How can I tell in my workspace, how far out of date are my files?”

TFS knows if your file is out-of-date and will tell you simply by showing you a “No” in the Latest column in Source Control Explorer:

But what if you want to know how far out of date your file is?  You can see this by accessing the properties of the file (right-click, select Advanced->Properties):

As you can see in the above screenshot, I’m one version behind.

Easy, right?

But what if I want to know this for all the files in my workspace?  Using the built-in mechanisms, I’d have to look at the properties of each file that shows “No” in the Latest column.  That could take a while!

As a side note, if I don’t care how far out of date I am, but I at least want to know all the files that are out-of-date, I could use the /preview switch on the command line tf get:

Notice that a.txt and d.txt in the command line correspond with what’s shown as out-of-date in the first screenshot. (BTW, nothing actually happened because I specified /preview.  And the “Replacing” tells me that these files need to be replaced, or “caught up”.

However, let’s assume I want to know the workspace and server versions for all my files that are outdated in my workspace.  There’s not a very convenient manner to do this without several clicks, but it’s surprisingly easy through the TFS API.

Here’s a quick, full sample console application that:

1. Connects to my TFS server (only works for “on prem” TFS, not TF Service (it will work, but not by using WindowsIdentity))
2. Grabs your workspace
3. For each file in your workspace, checks to see if the workspace version is different than the server version.
4. Spits everything out to the console.

The code isn’t anything special (I’m not a developer by trade), but it works.

using Microsoft.TeamFoundation.Client;
using Microsoft.TeamFoundation.VersionControl.Client;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Principal;
using System.Text;
using System.Threading.Tasks;

namespace WorkspaceVersions
{
    class Program
    {
        private const string _TfsUrl = "http://<myTFS>/defaultcollection";
        private const string _TfsProject = "$/<myproject>";
        private const bool _OnlyListOutOfDate = true;

        static void Main(string[] args)
        {
            Print("Connecting to TFS..");
            // Connect to the team project collection and the server that hosts the 
            // version-control repository. 
            TfsTeamProjectCollection tpc = new TfsTeamProjectCollection(
               new Uri(_TfsUrl));
            VersionControlServer vcServer = tpc.GetService<VersionControlServer>();
            
            // Get workspace versions
            ListWorkspaceVersions(vcServer, _TfsProject);

            Print("");
            Print("Finished.");

            Console.ReadLine();
        }

        /// <summary>
        /// Silly convenience method for printing a line of text to the console.
        /// </summary>
        /// <param name="text"></param>
        private static void Print(string text)
        {
            Console.WriteLine(text);
        }
        private static void ListWorkspaceVersions(VersionControlServer vcs, string project)
        {
            Print("Getting workspace..");
            var workspace = vcs.QueryWorkspaces(null, WindowsIdentity.GetCurrent().Name, 
                System.Environment.MachineName).First();

            Print("Getting working folder for the project..");
            var folder = workspace.Folders.First(f => f.ServerItem == project);

            Print("Getting local versions..");
            List<LocalVersion[]> items = workspace.GetLocalVersions(new[] { 
                new ItemSpec(folder.LocalItem, RecursionType.Full) }, 
                false).ToList<LocalVersion[]>();

            if (_OnlyListOutOfDate)
                Print("NOTE: Only listing items which are out-of-date");

            foreach (LocalVersion[] locals in items)
            {
                foreach (LocalVersion item in locals)
                {
                    int serverversion = vcs.QueryHistory(
                        new ItemSpec(workspace.GetServerItemForLocalItem(item.Item),RecursionType.Full),
                        1).First<Changeset>().ChangesetId;
                    if ((_OnlyListOutOfDate && (serverversion != item.Version)) || _OnlyListOutOfDate == false)
                    {
                        Print(item.Item);
                        Print(String.Format("   Server: {0}, Local: {1}", serverversion, item.Version));
                    }
                }
            }
        }
    }
}

If you are comfortable in the command line, this may work out well for you.

2/13: Update – New meeting location!

The local user group here in town has set up a new study group, kicking off tomorrow (Feb 7th).  For full details, go here, but below are the core details.

The Denver Study Group is a sub group of Denver Visual Studio User Group.

When

Thursdays, beginning February 7, 2013 (first course for 6 weeks, then repeat for next course)
5:30 p.m. - 7:30 p.m. Limited to First 20 Attendees!  

Where

Microsoft Store, 303-824-6772
Park Meadows Mall, 8505 Park Meadows Center Dr., Lone Tree, CO 80124,
Store is near the center of the mall, Zone B, Upper Level, between Macy's and Forever 21
Meeting space is near the middle back portion inside the Microsoft store

UPDATED LOCATION (see below)   

Innovation Pavilion, 9200 East Mineral Ave., Centennial, CO 80112

North of Park Meadows Mall, between E. Dry Creek Rd. & E. County Line Rd., W of I-25)
- Plenty of free parking, Enter the front lobby (doors locked after 7:00 p.m.)
- Check the white board for room number (probably, 3rd floor, Suite 310 or 385)

Using Pluralsight videos: one month free pass for first time attendees
First Course: Building Applications with ASP.NET MVC 4 by Scott Allen
Watch Videos, Code, Discuss (no purchase necessary)
Optional: bring your own pc (free Wi-Fi available)
Join us for our first Denver Study Group --
FMI: read the details below

What

The Study Group meets for the express purpose of gathering developers together on a series basis to watch, code, discuss, and learn from high quality video training along with others of a like mind.
During the Study Group meetings, the training videos are shown in a web browser via a streaming service and displayed on a large screen audio/visual presentation system for all participants to watch and hear together.

Why

Video training helps us in our group bring experienced and highly rated training professionals directly into our group at a time and place of our choice -- and for free! More than that, it provides us with opportunities to select the specific training we need to be delivered via video and supplement it with coding in a group setting and interactive discussions learning together with our own peers locally. This gives us the best of both worlds - expert training and group interaction - delivered to fit our needs.
Video training provides an excellent, cost-efficient alternative to live training programs by using a vast training library which has helped thousands of developers worldwide. When we add our group members to code and discuss together, you get even more than you could by watching the videos solo.

When

Thursdays, 5:30 pm – 7:30 pm MST, approximately 2 hour meetings once each week
Watch 45-60 minutes of course video at each meeting
Work 20-30 minutes on ad-hoc exercises and code together as a group related to the video just watched
Discuss 20-30 minutes in a round table format related to the video just watched
Approximately 5-6 consecutive weekly meetings will be completed to go through a course
Break between courses 1-4 weeks and then repeat for next course
Depending on the course and the needs of the participants, the watching/coding/discussion times  will vary, sometimes considerably
Depending on each course, length of each weekly meeting and consecutive meetings for a course may vary
Holidays, other special days, weather, and venue use, may cause changes to the planned schedule
We will plan for each course from one to six months ahead of scheduled venue space needs and  communicate those dates and times to ensure our space reservations and placement on the venue  events calendar

If you’re one of the lucky ones to be attending the ALM Summit this week (I’m not), you’ve been able to experience first-hand the bevy of announcements made concerning Visual Studio Update 2.  An evaluation CTP (read: Not supported, not “go live”) has been dropped and is ready for feedback.

Brian Harry explains it best in his blog post (as always), but here’s a quick list of my highlights:

• You can tag work items: Similar to tags on blog posts, you can place various tags on work items to help with categorization and organization.
• Web-based test case management:  Think Test Manager (MTM) in the browser.  You can do basic management and execution of test cases via the web.  This will make it much easier to perform manual tests on non-Windows platforms.
• Unit testing
• Playlists: Create arbitrary test lists/groups.
• Windows Phone app support
• Fakes & Stubs has been moved down to VS Premium (still in Ultimate)
• Office 2013 support
• Blue Theme – if you still can’t get past the reduction of color in VS 2012.

But nevermind all that – did you hear that Team Foundation Service (compare) now supports Git repositories?  More on Brian’s blog.

As you may or may not know, my primary geography of responsibility is basically the entire western United States.  Scaling to support thousands of customers involves a lot of prioritization, packed travel schedules, and “breadth”-type activities.

While I think I’m pretty good about replying to email and phone calls (let me know here), I’m always looking for other manners to be more accessible to customers.  To this end, I’ve set up virtual office hours for this spring (running through June 2013).  I’ll be holding office hours every Friday (well, most Fridays ;)) for 1 hour (and will add more time if this becomes at all popular) in the mornings (9AM Pacific, 10AM Mountain).

To do this, I’m following the lead of some of my peers and using OHours.org to manage online office hours.  Per that site, here’s how it works:

• Each office hours session is broken into 4 15-minute segments
• Anyone can RSVP for a 15-minute session
• Upon RSVP, I’ll send Lync and phone info to you

I think the advantage to using this process is that I’ll know if anyone plans to show up.  There’s no point in sitting on a Lync call if no one plans to join!

Here’s the link to view and sign up for my office hours:  http://aka.ms/SteveLangeOfficeHours

Please feel free to sign up and join me for a chat one of these Friday mornings!