[#TFS2013] TFS 2013 Update 4 Release Candidate, #Bugs in the #Kanban board and suggestions for Visual Studio ALM for free



more than one year ago, I wrote a post where I mentioned how to modify the default configuration in TFS2012 to use the WI type Bug on a Kanban board. Eventually TFS 2013 was available and I’ve to update the story with a little tweak, when you upgrade a TP deom 2012 the changes were lost on the upgrade process, so it was time to write another post.

And now with the arrival of the update Team Foundation Server 2013 4 (by now in Release Candidate) I think I can close these posts since the functionality of working with BUGs on the boards comes out of the box 😉

A couple of days ago Brian Harry explained this in his blog, along with other updates for Visual Studio and Team Foundation Server included the Update 4 (in Release Candidate). The interesting thing about this feature is that he had more than 100 votes in the section of User Voice where everyone can suggest improvements and help with Microsoft ALM tools.

So now there are no excuses:

Do you know that you go in this link and propose changes and enhancements to Visual Studio and Team Foundation?

User Voice Visual Studio: http://visualstudio.uservoice.com/forums/121579-visual-studio

Best regards

/El Bruno

Source: http://blogs.msdn.com/b/bharry/archive/2014/10/16/visual-studio-and-tfs-2013-4-update-4-release-candidate.aspx

[#ALM] Microsoft Virtual Academy + Visual Studio ALM Training = true!


Once in a while I get some mail, DM or similar where ask me some training materials for Visual Studio Alm MSDN is the primary resource, although clear, somewhat more guided always is appreciated. Here comes into play Microsoft Virtual Academy, an excellent site of virtual training. There are several courses that may be of interest inside MVA

  1. Applying ALM with Visual Studio 2012 Jumpstart
    1. This course focuses on the application of ALM (Application Lifecycle Management) or life cycle of applications delve into the processes that should be taken into account when developing with Visual Studio 2012. Iteracciones of software, its final value and the integration of operations and application development will be identified.
  2. Administering Visual Studio and TFS 2012 Exam Jumpstart
    1. In this course you will learn how to implement Team Foundation Server (TFS) within a work team and obtain their full potential in communication and tracking of tasks. Each module focuses on personnel responsible for performing the customization of the TFS infrastructure, also how to define the types of work items as well as their attributes to cover everything related to ALM within a project.
  3. Software Testing with Visual Studio 2012 Exam Jumpstart


An interesting detail is that the last 2 may serve as a good my basis for official certification exams Microsoft Alm.Then if you are still looking for also there is other related courses covering topics such as GIT, Testing, Kanban, Lean, etc.

Best regards

/El Bruno

[#WINDOWS10] New options for Docking Windows


Those of us who use the keyboard a lot, for sure we appreciate the options that we have with the Windows key combination + Cursor (up, down, right, or left) since Windows 7. When you perform one of these combinations, the window with focus is docked to a specific section in your desktop.

I personally use it a lot and now using Windows 10, I realized that something had changed. Now in addition to docking to left and right options, we have additionals options, ie: once accommodated a window to the left, pressing Windows + Up and it conforms to a 4th part of our desktop. With 2 or 3 row combinations, we have interesting layouts.

In the video below, you can see how windows are accommodated and the combination that I use in each case in a label above leftW10 Docking Windows

Best regards


[#WINDOWS10] The new Command Prompt… awesome! ^_^


Windows 10 days it has been my main OS. I.e., I use it on my work laptop and the truth is that it will very well (unless the sombritas end do not convince me). Having said that, like all evolution has things enough good, one of them are new options at the Command Prompt.

To enable them, we must Access the settings from the Command Prompt. Then we can already do something that was impossible until now > > paste from the trash in the COMMAND PROMPT!

As always a small video that is worth more than thousand images 😉

W10 Command Prompt

Very simple

-Firstly a CTRL-V that does not work

-We enable the new features

-Restart the command promt


By the way, if in the video not were good, these are new options from the Command Prompt


Best regards

/El Bruno

#KINECTSDK – Speech recogntition now available in SDK V2 !!!

Hola !!!

Después de tanto pedirlo, por fin tenemos weekly builds del nuevo SDK de Kinect V2. Ahora lo interesante es que tenemos una pila de trabajo interesante en cada release para ver lo que tenemos dentro. Asi que hoy,un pequeño review de algo que ya existe en Kinect SDK V1.8 y que necesitábamos en V2: Speech Recognition.

La base es simple y seguro que lo conoces, crear un diccionario con palabras dentro del mismo. Lo interesante es que en la l’inea 18 hacemos la asociación del audio feed de Kinect con el speech grammar que se define en la línea 5

Otro punto importante es la sección para obtener el KinectRecognizer al final. A ver si cuando llego a Madrid puedo hacer una dem and video cool sobre esto 😀

And as always, the disclaimer

“This is preliminary software and/or hardware and APIs are preliminary and subject to change“

Saludos @AVE

El Bruno

[#PEBBLE] Working with buttons (II) and a bit of #debug mode using #CloudPebble


After the yesterday’s post, I have been able today to update the Pebble smartwatch and the SDK to the version 2.1. That means that I have everything ready for a demo. So, I’ll start with a video of a very simple app. For every button pressed, it sends a debug message to the cloud development environment.

We can see in the video is how an app to the Pebble is displayed using CloudPebble. And then as it is connected and can capture debug events. In the video you can see

00: 00 the development environment CloudPebble with the source code of an app and the feed from a camera with the Pebble

00: 46 Build option, in this case, compiles and deploys the app to the Pebble (through an iPod)

00: 22 now it is possible to see the app deployed and running on the Pebble

00: 25 selection from the view of debug output in the development environment

00: 34 Click on the Button Up and debug message!

Those who are not developers won’t know to enjoy of the divine moment of emotion that can be reached when a smartwatch sends a message by TCP to a browse that is where is the development environment .

That said, just sharing the code and tomorrow an example of a more interesting app with buttons

Saludos @ Home

El Bruno

image image image Google

[#VS2013] HowTo: Debug an external EXE file and some bonus track


Today I have to use some part of my memory skills to remember how to debug an external exe file in Visual Studio. For this task I usually use WinDbg, however this scenario must be easier than that.

So a couple of steps for thos:

1. Open Visual Studio

2. Menu “File // Open // Project or Solution”

3. In the File System select the EXE file to debug

4. Done! press F5 or Run, and Visual Studio will run the app and it will attach to this process.

Very easy? If you take a look at the project properties, you’ll see the EXE path, working directory, etc.


Now bonus track, you can also launch a Profiling session into this external file.


The profiling process is the one you already knows, and is also great.


This option is great if you want to avoid WinDbg, however if you really want more details go to WinDbg world!

Greetings @ Munich

El Bruno

image image image Google

[#LEAPMOTION] HowTo: Show the number of fingers ever the Leap


Today is going to be a quick post, I’ll change the console app for a WPF app to work with the Leap Motion. In this app, I’ll show how a gesture is detected by the sensor in addition to the amount of active fingers over the sensor. For this example I’ve used some information from in this post of the great Iris Classon to create the following listener

   1: using System;

   2: using System.Threading.Tasks;

   3: using Leap;


   5: namespace LeapWpf01

   6: {

   7:     public class ElBrunoListener : Listener

   8:     {

   9:         public void Sample(){}

  10:         public event Action<FingerList> OnFingersRegistered;

  11:         public event Action<GestureList> OnGestureMade;

  12:         private long _now;

  13:         private long _previous;

  14:         private long _timeDifference;


  16:         public override void OnInit(Controller controller) { }


  18:         public override void OnConnect(Controller controller)

  19:         {

  20:             controller.EnableGesture(Gesture.GestureType.TYPECIRCLE);

  21:             controller.EnableGesture(Gesture.GestureType.TYPEKEYTAP);

  22:             controller.EnableGesture(Gesture.GestureType.TYPESCREENTAP);

  23:             controller.EnableGesture(Gesture.GestureType.TYPESWIPE);

  24:         }


  26:         public override void OnDisconnect(Controller controller) { }


  28:         public override void OnExit(Controller controller) { }


  30:         public override void OnFrame(Controller controller)

  31:         {

  32:             var frame = controller.Frame();

  33:             _now = frame.Timestamp;

  34:             _timeDifference = _now - _previous;


  36:             if (frame.Hands.IsEmpty) return;


  38:             _previous = frame.Timestamp;

  39:             if (_timeDifference < 1000) return;


  41:             // Run async

  42:             if (frame.Gestures().Count > 0)

  43:                 Task.Factory.StartNew(() => OnGestureMade(frame.Gestures()));

  44:             if (frame.Fingers.Count > 0)

  45:                 Task.Factory.StartNew(() => OnFingersRegistered(frame.Fingers));

  46:         }

  47:     }

  48: }

The listener is quite simple, public an event with the information captured by the LEAP every 1 second.

In the MainWindow of my WPF app, I have the following code. The only thing that must be taken into consideration, is that the best sensor initialization in the Loaded() event, and always with care for closing the View close the controller and the listener with the sensor.

   1: using System;

   2: using System.ComponentModel;

   3: using System.Diagnostics;

   4: using System.Runtime.CompilerServices;

   5: using System.Windows;

   6: using Leap;

   7: using LeapWpf01.Annotations;


   9: namespace LeapWpf01

  10: {

  11:     public partial class MainWindow : INotifyPropertyChanged

  12:     {

  13:         private string _gesturesText;

  14:         private Controller _controller;

  15:         private ElBrunoListener _listener;

  16:         private string _fingersText;


  18:         public MainWindow()

  19:         {

  20:             DataContext = this;

  21:             Loaded += MainWindow_Loaded;

  22:             Closing += MainWindow_Closing;

  23:             InitializeComponent();

  24:         }


  26:         void MainWindow_Closing(object sender, CancelEventArgs e)

  27:         {

  28:             _controller.RemoveListener(_listener);

  29:             _controller.Dispose();

  30:         }


  32:         void MainWindow_Loaded(object sender, RoutedEventArgs e)

  33:         {

  34:             _listener = new ElBrunoListener();

  35:             _controller = new Controller();

  36:             _controller.AddListener(_listener);

  37:             _listener.OnFingersRegistered += OnFingersRegistered;

  38:             _listener.OnGestureMade += OnGestureMade;

  39:         }


  41:         void OnGestureMade(GestureList gestures)

  42:         {

  43:             var gesturesData = string.Empty;

  44:             foreach (var gesture in gestures)

  45:             {

  46:                 gesturesData += gesture.Type + Environment.NewLine;

  47:             }

  48:             GesturesText = gesturesData;

  49:         }


  51:         void OnFingersRegistered(FingerList fingers)

  52:         {

  53:             FingersText = "Active Fingers:" + fingers.Count;

  54:         }

  55:     }

  56: }

Then, the functionality of the app is pretty straigh forward,


The sensor is OK, but in order to have something up and running, you have to work a lot. The SDK gives you raw information , so you have to work with this information to get cool results

Saludos @ Home

El Bruno

image image image Google

[# VS2012] There are many rumors about VS2012 and WP but less news than on the location of Atlantis



Disclaimer: When I wrote this post I was not at my 100% mental level. Thanks to @wasat I got more information and I still wait for some cool tools Open-mouthed smile

I do not understand very well that are passed by the head to our friends of MS with regard to development of Windows 8, Windows Phone and Visual Studio 2012 tools. VS11 Developer Preview and VS11 Beta versions, half who understood that the extensions might not exist to develop for WP but with a final version, they are not… scares me a little.

Once more have to be installed Side-By-Side VS2010 and VS2012 RC to be able to pull a few lines on WP… Worst thing is that neither seems to be much official information on dates of release, roadmap, etc. Except this thread of StackOverflow and a couple of articles, there is nothing of nothing…

Anger again… Angry smile

Saludos @ Home

El Bruno

image image image

[RESHARPER] HowTo: Dynamic add references based on the typed code


otro tip de los buenos de ReSharper, en este caso que nos ayuda a ahorrarnos los 5 clicks o 15 segundos necesarios para agregar una referencia en un proyecto. Supongamos el siguiente escenario:

  • Proyecto de biblioteca de clases llamado ClassLibrary1, con una clase llamada Class1.
  • Proyecto de biblioteca de clases llamado ClassLibrary2, con una clase llamada NewClass.

En la clase NewClass escribimos el siguiente código y esperamos la ayuda contextual de ReSharper sobre la línea con la declaración y la referencia a Class1. Como se puede ver en la imagen, además de las típicas propuestas de crear una variable local, un parámetro, etc; ahora también tenemos una opción que agrega una referencia al proyecto ClassLibrary1 y luego nos permite utilizar el tipo Class1.



Esto no solo aplica a las referencias entre los proyectos de una solución. Si por ejemplo, declaramos un tipo del modelo de objetos del cliente de Team Foundation Server 2010 para Visual Studio 2010, también podremos ver como nos propone agregar una referencia dinámicamente al tipo Microsoft.TeamFoundation.Client.



Aunque, cuidado que este segundo ejemplo tiene trampa > ReSharper no es lo suficientemente inteligente para conocer TODOS LOS ENSAMBLADOS, sino que infiere el tipo a referenciar ya que una de las referencias del proyecto actual tiene esa referencia, en el ejemplo anterior, la referencia a ClassLibrary1 desde ClassLibrary2, permite importar las referencias del primero hacia el segundo



Otro +1 para ReSharper Open-mouthed smile


Saludos @ Home

El Bruno (@elbruno en Twitter)