Issue: Failed to push new glyph for <file-excluded-by-gitignore> Return code from SccGlyphChanged was -2147024809


Visual Studio 2013 Ultimate Update 3 RTM with Microsoft git provider returns error "Failed to push new glyph for <file-excluded-by-gitignore> Return code from SccGlyphChanged was -2147024809." in Output window.


Issue occurs every time an a file is modified in an editor. The focus switches to the Output window with label "Source Control  - Git". An error message as above is returned for each file excluded by patterns in .gitignore.


This an issue with the way that Solution Explorer is interacting with the notifications from the git source control provider.

A glyph is a source control UI element, that is all those little symbols on the left side of the file in Solution Explorer, as explained in implementing a source control provider. This post talks at length about what is going on in a general fashion, including explaining what the error message number means.

What is missing is the connection with .gitignore patterns. This might point to some logic error in the code that handles the background processing that updates the Solution Explorer UI every time a file source control status is modified by editing it in place.

User was using Update 3 RC prior to installing Update 3 RTM, therefore this might be a left over from RC.

I looked into another related issue with .gitignore that when you have a specific exclusion rule (say "/TFS"), it does not process the file (with a name that starts with "TFS"), plus the Solution Explorer glyph changes to that of a committed file. The workaround for this was to take out the .gitignore rules. Another would be to through suppressing the Output window activation and filtering out messages related to this error by using its automation interface.

All points to an issue with the way that the git provider interacts with the Visual Studio UI.


I have confirmed with Microsoft that this is a bug and that it has been fixed in an upcoming version.

Dynamically creating or modifying controls in a TFS form

TFS forms can only be modified at design time.

The TFS forms engine is capable of specifying different layouts for different targets, which already tells us that it is a subset of the rendering engines for those targets, and as far as I know, with less capabilities. One of the restrictions is exactly that forms can only be modified at design time.

As a workaround, at the bottom of the page on how to specify work item form controls, there is a link to an article on how to implement a custom control using Winforms. It might be possible to create a custom control with multiple drop down boxes which are dynamically displayed; I have not yet tried that.

You can get better samples on how to implement a custom control in the Custom Controls for TFS Work Item Tracking project at CodePlex. The challenge though will be to also generate a web implementation for the same control, otherwise your work items will be visible only from Team Explorer.

Issue Workaround: When launching a test from MTM, Test Runner does not launch


When launching a test from MTM, either manual or automated, it would get the message, MTM does not launch Test Runner and fails to do anything. The following error message was added to the Event Log after failure:

    <Provider Name="VSTTExecution" />

    <Data>(mtm.exe, PID 16168, Thread 1) Exception: System.IO.FileNotFoundException

                Message: Could not load file or assembly 'Microsoft.VisualStudio.TestTools.UITest.WindowsStoreUtility, Version=, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies. The system cannot find the file specified.


We tried running it from another computer to isolate the Visual Studio Ultimate as the issue. It worked on another computer with Visual Studio Ultimate 2013 Update 3. The failing computer had Visual Studio Ultimate Update 2.


Root cause was not determined. Installing Update 3 fixed it.

SAFe: one option to scale Agile

The last year has been marked by the steady adoption of SAFe (Scaled Agile Framework) in companies that, although already development powerhouses, still had been struggling to transform themselves into Agile development shops. So SAFe has played an increasingly important role in those companies transitioning from more traditional SDLCs to Agile based ones.

So what is SAFe? It is the evolution of Dean Leffingwell's long time work in methodologies in general, starting with RUP, tempered with his practical experience in bringing Agile and Lean to many companies over the last ten years. According to its website, "The Scaled Agile Framework is an interactive knowledge base for implementing Agile practices at enterprise scale." As such is has a nicely crafted big picture with hundreds of icons you can drill down to and learn more about a specific topic, sometime going even deeper. It reminded me of the richness you get from the RUP documentation, albeit all of it related to current and relevant Agile topics.


The navigation is a bit bumpy because in order to protect their IP, the authors made it difficult to see more than one topic at a time (no “open link in new tab option”), and you can’t select text either, so if you are quoting them you will need to type it all. Other than that it can be seen as a rich “map” to all things Agile in an enterprise. The main references of SAFe are Leffingwell's books (both available at Safari):

How is SAFe different from Scrum? The short answer is that it encompasses Scrum. You could say that Scrum targets the team, and that SAFe targets the enterprise. Though based on Lean and Agile principles at the micro, team level, it also addresses architecture, integration, funding, governance and roles at the macro or enterprise level.

And here is what is relevant to a Business Analyst: it clearly provides a way to structure and manage requirements at the enterprise level. It starts by reasserting what has become pretty much the standard best practice in requirements management hierarchy levels, Portfolio, Program and Team:

· Portfolio: Business and Architecture epics, epics span releases

· Program: Features fit releases

· Team: Stories fit in iterations

The novelty of SAFe stems from providing practical solutions to some of the “elephant-in-the-room” problems that have prevented scaling up requirements management in many companies. Among these, three caught my attention:

· Architecture runways: this is something obvious for the technical team, but SAFe makes it explicit by adding Architecture epics as an item in the Portfolio backlog. An Architectural Runway “is the extant technical infrastructure (instantiated in code) necessary to support the implementation of upcoming features without excessive, delay-inducing, redesign.” By having Architecture topics explicit, businesses now become aware of the hidden part of the iceberg needed to implement business features: a plane can’t safely fly without a runaway.

· Agile Release Train: it is “a long-lived team of agile teams, typically consisting of 50-125 individuals, that serves as the program-level value delivery mechanism in SAFe. “ This is the equivalent of a Scrum team but at the program or release level. By having this concept clearly understood, business becomes aware about the need to support using a common team sprint cadence, and “teams are aligned to a common mission via a single Program Backlog”. You could say that this idea is similar to Scrum-of-Scrums concept, but it goes beyond in unifying the teams around the idea of releasing Potentially Shippable Increments (PSIs) as a unit, and not just synchronizing the efforts of separate Scrum teams at the backlog level but still not coordinating the delivery of working software, which is after all the measure of progress for Agile teams.

· Investment Themes: by adding this to a portfolio backlog, and mapping it directly downstream to its ramifications at program and team level, it ensures that what is being worked on has been budgeted, and that execution is tied to strategy. Business becomes aware of the need to prioritize and the repercussions downstream of short-changing initiatives that might affect its financial future.


SAFe is not without its critics. It has been bashed by both Lean and Agile/Scrum champions such as David Anderson, Ken Schwaber, and Mike Cohn. However it seems that those initial reactions "throw the baby out with the water", to use an old expression. There is definitely value in the framework, but only if considered within an understanding of how ideas are adopted and used within the enterprise.

For the Scrum practitioner, a minor annoyance is its confusing definition of Scrum: Leffingwell invented “SAFe ScrumXP” as a combination of Scrum project management techniques with XP engineering practices. This separation stems from a backwards pseudo-definition of Scrum from 15 years ago, when the perception was of Scrum as being solely a project management framework. At the time Mike Beedle coined the name “Xbreed” (later “Enterprise Agile Process”) to mean exactly Scrum + XP.

“Xbreed” didn’t catch because eventually everyone started to use the word “Scrum” to mean engineering practices as well (notice how Beedle already says that here even for XBreed), and later and ScrumAlliance made it official by adding the “Professional Scrum Developer” and “Certified Scrum Developer” courses focused exactly on teaching engineering practices alongside the Scrum project management framework.

Finally, among the strongest criticisms is that SAFe does not conform to a well-known process adoption best practice popularized by Alistair Cockburn: "stretch to fit". Like RUP, SAFe needs to be tailored in size, and many might be tempted to adopt everything when in doubt about what to do. SAFe can then be used at the Shu and maybe a bit at the Ha levels (as referred by Cockburn), but for experienced Agile practitioners, both in the technical and product management sides of the business, SAFe will appear overwhelming and verbose, and might get in the way as feeling over prescriptive. However, for companies coming out traditional SDLC middle ages, SAFe can feel like the map of a gold mine. It gives to the uninitiated in the Agile wisdom a sense of direction and security to finally start experimenting on how to get out of the Waterfall corner many businesses brought themselves to.

Some references pro and against:

Method Wars: Scrum vs SAFe, by Ian Mitchell

“SAFe has gained traction [with big companies] not in spite of poor agile credentials, but rather because of them.”

Has SAFe Cracked the Large Agile Adoption Nut, by InfoQ

“However, not all in the community think SAFe is a good idea. In fact, many have a strong negative reaction”

Controversy around SAFe, DAD and Enterprise Scrum, by Elizabeth Woodward

“SAFe has been empirically derived from addressing problems as teams scale--lessons learned over time--and it continues to evolve.”

unSAFe at any speed, by Ken Schwaber

“The boys from RUP (Rational Unified Process) are back.”

Kanban – the anti-SAFe for almost a decade, by David Anderson

“SAFe appears to collect together a number of techniques from software development processes from the 1990s and 2000s”

Austin TFS Users Group Leadership meetings

The Austin TFS Users Group leadership team has weekly meetings over the phone to plan, develop and deliver bimonthly presentations based on community activities, and we welcome presenters who have ongoing practical experience with implementing ALM with TFS. Please send us an email if you are interested, or let us know at one of our meetings.

The leadership team had just had our quarterly face-to-face meeting on July 17th at Chez Zee on 5406 Balcones Dr., Austin, TX. In the picture below we have, from left to right:

George Altenbaugh, Amanda McConville, Tim Pacl, Clementino de Mendonça, and Joe Murphy. Missing from the picture is Bob Hardister, who could not attend because of a last minute impediment at work.


or the record: our team did not use user group funds for lunch: each person paid their own meal.


Example on how to handle IT support communications

Microsoft's VSO support blog provides a nice example on how to handle IT support communications:

Notice how redundancy is accounted for: if for any reason the Microsoft web properties are down, the Visual Studio team will continue to update users through Twitter.

Updated information for fixing issue with max number of items in task board



When using a TFS 2013 task backlog with more than 500 items, the following message is displayed:

You have exceeded the number of items allowed on your task board. The number of items to be displayed on the task board is: 578. This exceeds the allowed maximum of: 500. This maximum limit is configurable.

To resolve this issue, you can perform one of the following tasks:

·        Reduce the number of items included in the current sprint.

·        Your project administrator must increase the maximum number of allowed items.

You follow the second link, and you are taken to the following page which has outdated information:




Refer to the updated information  for TFS 2013:

A workaround for issue "TF201072: A user or group could not be found"



Although a user is already part of a TFS group, he can't access TFS work items (source code is fine), and TFS Web client/Visual Studio display the following message:  

TF201072: A user or group could not be found. Verify that the users and groups used in your work item type defiition have been added to Team foundation server.




The cause is related to some snag in the TFS identity synch service, and it is usually related to a specific collection. There are many articles on the web which help determine the root cause, so here we are only focusing on a fast workaround.

Attaching and re-attaching the collection will force a refresh of the identity synch data, and will usually resolve the issue.

Tips on editing process templates

  • Use an XML editor with syntax highlight (such as Notepad++)
  • Process Editor (PE) is behind in editing modern features, so edit raw XML to access all features
    • PE was created by the TFS process team, and it does not leverage the same code as Process Template Manager when exporting XML, therefore the two generate different formats, both in attributes and node order.
    • PE does not handle bool data type, nor the new XML definitions for backlogs.
  • Use an XML diff tool (such as Microsoft's XMLDiff)





Before Agile, there were agile ideas–the Backlog part 1

Backlogs have long been used to organize work. I could go back as early as Benjamin Franklin writings on how he dealt with practicing a list of mental virtues in an iterative, incremental fashion.

However I would like to point out two more recent examples, the first one in this post, followed by another post on the second one.

Not many are aware of how Steven Spielberg operated when developing his first block buster, Duel. It was shot in a relentless pace, just sixteen days, at a total cost of $425,000 – after all it was originally a TV movie. Its quality though attracted enough audience that allowed it to be released in Europe and Latin America as a theatrical release, and two years later it also came to movie theaters in the United States as well. Brode’s description of Spielberg’s approach is fascinating as anyone who practices Agile today would recognize what he was doing (my inline comments between []s):

[Spielberg] became involved during the time period when Matheson [the original story author] was writing the script, though Spielberg did not consult with him during the writing process. Methodically he blocked out the entire film on IBM cards [the backlog], the first time he tried what would become his regular approach. Each card contained the gist of the scene, the angle he would take on it, and how many camera setups he needed. While filming in Lancaster, he assembled those cards on a huge bulletin board in his motel room [the task board]. Rather than opening the script to the day’s page, he would instead take down several cards. They constituted the day’s work [daily iterations – after all it was sixteen day project], and when each scene was finished, he would tear the card up and throw it away, knowing every night, by glancing at the bulletin board, how much was left to complete.

In addition to cards, he had his art director sketch the entire film on one long mural that arced around the motel room, an aerial view portraying every moment in the movie [the user story map], including chases. Never a great reader, Spielberg liked to avoid referring to his script and memorizing blocks of words, preferring to study this visual panorama, locking himself into it before filming any one day.

The films of Steven Spielberg, by Douglas Brode 

I brought this extract to show that using backlogs has always been a way of working in the minds not only of software developers under a delivery pressure, but also of the general public. Well, at least for smaller projects – the DOD distortion field that swept the 70’s leading to Waterfall stems from the need of extra planning big projects under extreme risk pressure.

Hopefully this example shows how people while thinking create new ideas, which are eventually formalized as a best practice (I will bring that up on the next post related to backlogs), and finally automated in a tool such as Team Foundation Server 2013.

Where did Spielberg have the idea of using IBM punch cards? Maybe by interacting with friends at the university Computer Science department? If you happen to have a chance, please ask Spielberg for me. Smile


<<  March 2018  >>

View posts in large calendar

Month List