[#KINECTSDK] Kinect for Windows SDK V2 Final Release, adapter for Kinect of XBoxOne and a couple of very cool apps


great day for Kinect Developers. First the SDK to version 2.0 has been released in mode “release”. So no more excuses to not create¬†apps for Windows 8.1 (and 10), now they are fully supported, the SDK is stable and there is no excuse ūüėČ

Another interesting topic, now we have a special adapter (US$ S49.99) which allows us to use in Windows apps the Kinect sensor included with the XBoxOne. This way if you have, (like myself) the Kinect sensor boring with your XBoxOne you can leverage it to create apps.

Finally there are a couple of apps available in the Store of Windows that already using the SDK and are an excellent example of what we can do with Kinect V2

  • Kinect Evolution: An app that helps developers understand the core capabilities of the Kinect for Windows v2 technology.
  • YAKiT: An entertaining app from the developers at Freak n’ Genius that allows people without design expertise to animate 2D or 3D characters in real time.
  • 3D Builder: An app that enables anyone to scan on person or object, turn it into a 3D model, and create a 3D print of that model. You no longer have to be a technologist or have access to a 3D printer to create amazing 3D prints!

Download the SDK from here (link)

Buy the adapter for Kinect from here (link)

Best regards

/El Bruno


[#TFS] Microsoft Leader in Gartner magic Quadrant for Integrated Software Quality Suites

Ms love linux


Every year the suite of Visual Studio ALM improves in every aspect, today recognition is dedicated to the testing stuff. The current version included in Visual Studio 2013 and 2013 Team Foundation Server is a big improvement over the 1st versions and also has improved in key areas such as reporting, adaptation to changes and customization.

This has been demonstrated within the report made by Gartner Analysts focused in quality tools. In this report Microsoft is within the top range of testing tools in the classic Magic Quadrant (which you can see here)

It is also interesting to see as within the weaknesses of Microsoft tools, they stressed that they are very oriented towards Microsoft development environments. Although that becomes the main virtue in the strengths, since if your working tool is Visual Studio, or you work with Azure, here the Visual Studio ALM tools become a #MustHave.

And when we started talking about the cloud world it is when testing tools (performance, scalability, etc) are starting to be in a gray area. Especially if we talk about the Microsoft cloud world. Since Microsoft’s CEO commented 2 days ago something like “Microsoft loves Linux“, that means that the testing tools that work so well integrated in Visual Studio now are transparent to any backend, maybe in Linux.

And here boundaries are not so clear, it is true that the testing tools are very complete for developments on Microsoft technologies. However, if Microsoft continues to open fronts such as Linux on Azure, as the support to Open Source projects, etc.; sometime testing tools will start to have to deploy hybrid environments or even delegate functionality to other suites.

Personally, I think that the big picture here is to understand how it is possible to integrate all of these options depending on the context you are working, and obviously, start playing the Magic Quadrant also as a guide to the evolution of tools, where we can see how MS has been gaining ground every year.

Best regards

/El Bruno

Source: http://www.gartner.com/technology/reprints.do?id=1-20TBOUS & ct = 140903 & st = sb

[#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