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.

Thursday, 12 February 2015

PowerShell DSC in legacy pipelines, or with no pipeline at all

It is true that PowerShell DSC is the newest kid on the block, but it is also true that we can integrate it in legacy pipelines, or where we have no clear pipeline whatsoever.

How? Pretty easy – even if there is DSC in the name, we are still talking about PowerShell, hence who can stop us from invoking a legacy script or even a command?

For example, think about where you have a script which stops IIS, copies the new content and then the scripts restarts IIS, using iisreset and xcopy. Not best practice at all, but it is broadly used. You can replace it with this:


The Invoke-Command cmdlet is a standard PowerShell one, it has nothing to do with DSC. But embedded into a DSC script it can make a functional step into the DSC script itself.

Even better, do you have a preparation script which prepares the environment? You can use Invoke-Command with the –FilePath switch, pointing at your script, as part of the DSC script.

Wednesday, 11 February 2015

What are .tfignore files?

I was talking with Gian Maria this morning about the need of excluding some files from the Version Control, with both TFVC and Git. With Git (and the .gitignore file) you can specify rules for it, but what about the TFVC?

Typically you have two options, a check-in policy or a .tfignore file. What is the latter?

It is a file which specifies some rules about the allowed and disallowed files in the Team Foundation Version Control. You need to create it in your Workspace folder, and you can specify rules like these. Yep, pretty much like the Git counterpart.

Of course it isn’t like a check-in policy, but it provides a good way of enabling basic rules on the allowed files in your TFVC. It is very helpful anyway when you have large teams, it enables a quick distribution of a standard set of policies without too much mess around the startup.