Monday, 20 April 2015

Remember, remember, remember…to close the TFS Administration Console!

That was fun :) While working with TFSConfig I hit this error on a TFS Farm’s Application Tier…


Oh, right, I have it open. I run the command again after closing the console and I get the same error.

The lesson? Close the TFS Admin Console on all the Application Tiers of your TFS Farm, otherwise TFSConfig will detect it as open and return an error.

Wednesday, 8 April 2015

How to schedule a TFS Integration Platform session

You might need to schedule your TFS Integration Platform session at a certain time, and the TFS Integration UI doesn’t expose such an information.

Not all is lost though, the UI relies on a Console Application:


As you can see, you can feed it with a Configuration File. It would be a breeze then scheduling a task with the Windows Task Scheduler, to run whenever it is convenient for you.

Friday, 27 March 2015

Why ‘Doing’ and ‘Done’ in the Kanban board?

Visual Studio Online introduced this feature a few weeks ago, and then I’ve been asked…

Why is the split column inside another column?

That is absolutely a fair question.


Kanban rotates around the concept of Capacity Flow, minimizing turnover and cycle time.

The so called ‘Kanban Boards’ – the Backlog Boards in reality - in Visual Studio Online take this principles as foundational when it is time to present an aggregated view of the development situation. Capacity is immutable by definition, unless there is an external intervention.

Also note that the we are not looking at the same stuff. The Sprint Backlog Board will boast the true States of my involved Work Items, which are then mapped to the Kanban Boards’ Metastates. Here is an example:


This is my Process Template. But my board looks like this:


What happens is that regardless of the Metastate (between New and Approved) the actual Work Item State is still Proposed. A Metastate is basically a way of determining how it is visualised, given that all the constraints are valid of course.

But back to the original question – does it make sense?
It does, indeed. These feature might seem just cosmetic stuff, but they actually contribute a lot in keeping the teams’ meeting lean and the procedures simple and effective.

Even if a PBI is Approved, it still might have work on it. Hence separating the Doing/Done phases makes it way easier for the Product Owner to understand the actual pace of the team. This works very well with the Definition of Done on the board, which I covered on this post.

Tuesday, 17 March 2015

Definition of Done on the Boards – how, and my thoughts on why

Last week Microsoft rolled on the latest Visual Studio Online sprint deployment, and among all the new features there is the possibility of adding a visualisation of the Definition of Done in the Kanban Board.

How? It’s very easy, you click on Customize columns in the board, and you add the DoD for each column you want to add it to:

image image image


Easy as chips. But where is the real value of this (very welcomed) feature? Why is it that good for me?

Step back from your role a minute, and think. What is the Definition of Done?

The DoD is usually a clear and concise list of requirements that a software Increment must adhere to for the team to call it complete.

That said, the Boards are meant for team’s consumption, hence reporting the DoD in a shared, neutral tool is an amazing way of pushing the concept of the Definition of Done itself. It is under everybody’s eyes and it doesn’t leave space for interpretation, so it enforces how to properly relate to it.

Monday, 9 March 2015

A lap around the new Application Insights

I really like Application Insights – it is no mystery, just look at how many posts I wrote on it – and the last time I purposely played with it was around 2013.3 last September, with the 2.0 version approaching the release and a complete under the hood rewrite to fit into Microsoft Azure.

Well, a lot changed in the last six months…let’s start from scratch: we have a Web Site running, we want to add Application Insights as the production monitoring solution.


You are running on Azure, so the request monitoring is implemented out-of-the-box. No configuration, no code changes – it is offered as part of the Azure infrastructure. If we want to monitor the actual end-user usage, we need to add a bit of JavaScript to your pages:


Doing this will enable the usage monitoring. You are going to notice how fast and sleek Application Insights is now compared to the old Visual Studio Online implementation, it is a matter of a couple of minutes at worst and you are going to look at your freshly fetched data:


Obviously you can dig into this data – it is a monitoring platform after all!

 3 4

The Diagnostic search is very cool because it is a pre-filtered, context-based series of charting which enables troubleshooting and diagnostic scenarios with a couple of clicks. For instance here I can access the details of a page’s status in a certain session:

5 6

subsequently, I might want to see the telemetry for the whole session:


so looking at what this user did, in case I am inspecting a suspect behaviour on a bug report:


The other option is on a timeframe, so looking at the ten minutes interval around the event I scoped my search on:


Moving on to the health and performance monitoring, you need the Application Insights Telemetry, a two-click operation in Visual Studio which is going to lead to a new NuGet package installed in my solution:



So I can enabled scenarios like this - I have a troublesome page here:


I can dig into the Metrics Explorer, and look at the stats – each event is reportable and will boast a number of properties you can use to investigate.



If you want to log custom events, it is a matter of using the same appInsights object created by the existing snippet and model what you need to log. For example, I might want to log an event with two properties, a string and an integer:


and out-of-the-box I would get support for sorting and aggregating my custom properties in the charts:

18 2019 

To be fair, I really like the workflow provided by the Azure Portal’s blades. Let’s say I have an exception:



For each level I dig into, a blade opens, so I can easily keep track of the workflow I am following. Very good use for all these 16:9 screens around :) 22


The Properties blade is the same for each event, so I can retrieve the relevant telemetry in any case. My users for example behaved like this:


It’s a matter of seconds understanding where this issue is.

But what if you want more logs? Mostly important, more logs at lower levels? Here they are:


Eventually, you get live streaming of the Application and Web Server Logs:




This is actually quite verbose because I set it so, but you have four options to choose from…

The new Application Insights is more promising than ever – I am seriously impressed by the effort the team spent on it, Application Insights now feels very solid and it sports even more data than before, without mentioning how integrated it is with Azure.

Thursday, 5 March 2015

Why can’t I output the result of git log from a PowerShell script?

Git log is a special command, it uses a pager and it seems the PowerShell ISE hangs when you run into that kind of commands. If you try creating a script relying on running git log in whatever form, you won’t get anything.

The workaround is not the very best, but it does the trick:

$logcommand = "git --no-pager log ... [> file.ext if needed]"
Invoke-Expression $log

Other commands like git diff are not affected by this. This made me lose quite a bit of time this morning…but I am happy to be unblocked now.

Wednesday, 25 February 2015

A first look at Team Foundation Server 2015

A few days ago Microsoft released a first CTP of Team Foundation Server 2015, together with another one for Visual Studio 2015. Whoo!
I was particularly curious about Team Foundation Server, as the preferred way of evaluating new features is Visual Studio Online. Keep in mind what Brian said: “More than anything it was a forcing function for us to practice getting ready to ship TFS 2015”, meaning I’d expect other TFS 2015 CTPs soon. Moreover, don’t forget many of the Visual Studio Online features had been brought into TFS 2013 Updates, so it isn’t like 2008 any longer.
It is the beginning of a new wave. The TFS 2015 wave! It is quite of a change, I reckon, but based on my experience it works pretty well. I manage a gigantic TFS deployment with all the trimmings, and being on the Update Train is perceived as extremely valuable by both my colleagues in Operations and my users. So expect sizeable features to show up after RTM.
Before looking at the actual features, a word on the installation process itself. It didn’t change a lot, but there are a couple of tidbits worth mentioning.
You can now configure a Basic Server (TFS Basic as we knew it) or a Full Server. The Full Server makes it clear that the new Build is a new core service:AT8
SharePoint Foundation doesn’t ship in the box anymore, hence the 370MB ISO size. You can still integrate with an existing SharePoint deployment of course:AT9
So let’s start with what’s in the CTP1:
  • Extensibility and integration
  • Agile tooling improvements
  • Licensing changes
  • Build.vNext
Extensibility means you now have the whole set of REST APIs which were available in Visual Studio Online only, together with the Service Hooks. This is very interesting for the whole lot of in-house applications you might have, plus a out-of-the-box integration facility with the supported 3rd party services.
Oh, integration…I think this screenshot says it all:
Do you want to integrate with a Jenkins build server? A couple of clicks, and you are in!
On the Agile tooling improvements it is basically lots of what we already saw on Visual Studio Online with all the reliability improvements we cannot see because they are behind the scenes.
To be honest, I read quite a few comments busting the Product Team’s work because there aren’t hundreds of new eye-popping features in this CTP, and I cannot agree with them. It is a CTP1, to be used as a shipping test for the team, it isn’t feature-complete or go-live supported. Why all this mess? They used to be called alphas, and I still remember the excitement when the first virtual machine containing an alpha of Visual Studio 2010 (codename Rosario at the time) came out, with really few features inside a Visual Studio Team System 2008 IDE, and everybody was excited about it. On my side, I’d rather appreciate what we can have to learn and share feedback, instead of complaining…
Anyway – back to the features :)
The licensing changes are all about the Stakeholder Access Level, extending lots of the Standard features to the basic, CAL-less tier. It is amazing because it enables a true involvement by the stakeholders themselves, without being too limited by the lack of a CAL.
Eventually, Build.vNext – it is a new Team Build concept, based on scalable agents instead of rigid matching between controllers and agents. But what matters most is that the workflow is now easier, clearer, and cross-platform.
Does this mean the old XAML-based build is going away? Absolutely not, everything works as it does today, but this is now the way forward for the future. With Build.vNext, you won’t have a dedicated Build Controller setup any longer. You can have it, but it would be the Legacy Build Service we saw in the installation as a separated, optional step to do – aka XAML-based Team Build.