March 2012 - Artículos

image

Buenas,

hace unos días Brian Harry hizo pública la noticia donde comentaba que ya podemos contar con un servidor Team Build en nuestro servicio de Team Foundation Service. Dicho de otro modo, esto significa que tenemos a nuestra disposición un servidor Team Build en TFS en la nube. Just great !!! (El amigo Vincenc también ha escrito un post al respecto)

Esto tiene muchas grandes ventajas, pero también tenemos que tener en cuenta varias cosas para trabajar con este modelo.

image

Importante: No tenemos acceso a la máquina física de Team Build

Esto significa que no podemos modificar nada en la misma para que nuestros proyectos compilen, ejecuten pruebas unitarias, etc. en este servidor. Personalmente pienso que esto es genial, un proyecto de software debe poder ser compilado y empaquetado solo a partir de los contenidos que se encuentren en el repositorio de Source Control.

Si utilizas componentes COM, o trabajas con un entorno de compilación que te requiera instalar algo en el mismo para poder compilar, pues tendrás que revisar tu modelo de desarrollo para poder utilizar Team Build en Team Foundation Service.

Inicialmente la VM de Team Build solo tendrá instalado

- Visual Studio 2010 SP1

- Visual Studio 11 Beta

Java por ahora nada de nada … aunque claro, estará en el paquete final, ya que los clientes de ECLIPSE con Maven 2 y Maven 3 lo necesitan.

Yo he hecho la prueba del “Hola Mundo” para Team Build en 10 minutos y funciona genial, aunque si en lugar de MSTests utilizas XUnit o NUnit, pues tienes que dedicarles unos minutos a la configuración.

Finalmente, un detalle interesante. Cuando definimos el directorio de salida de nuestra Build, usualmente lo solemos hacer en un share con formato \\SERVER\SHARE\BUILD.

En este caso, también tenemos esa opción, aunque no creo que nadie abra esta puerta al mundo. Lo mejor parece ser que si configuramos el output de la Build directamente en el Source Control, consumiremos espacio a cholón en el SC, pero bueno … para eso está.

image

¿Qué pasa con mis plantillas de build personalizadas?

Como el concepto de Build Controller y Build Agent sigue siendo igual, pues tampoco es que nos cambie mucho la forma en la que trabajamos si hemos personalizado nuestras plantillas de Build. Simplemente accedemos a la configuración de los Build Controllers y ya podremos seguir trabajando como antes.

image

¿Hay trampa?

Pues sí, aunque en realidad no es trampa. Por ejemplo, te puedes hacer una plantilla de Build que se encargue de montar un entorno específico para poder compilar una solución (por ejemplo registrando componentes COM, previos a la compilación). Pero claro, como las VMs de AZURE “no tienen estado”, pues perderás estos cambios cuando se refresquen las mismas.

Aunque como la build se ejecuta siempre que lo necesitemos, pues podremos volver a tener este estado en cuando lo necesitemos … Risa

Este punto está por verse porque entiendo que será un entorno mucho más parecido a un Sandbox al que podremos tener acceso desde la versión final.

 

Ahora a migrar un par de plantillas personalizadas de Avanade Spain a TFS AZURE, perdón a Team Foundation Service y a preparar el próximo post.

 

Saludos @ Home

El Bruno

image image image

Fuentes:

http://blogs.msdn.com/b/bharry/archive/2012/03/27/announcing-a-build-service-for-team-foundation-service.aspx

http://geeks.ms/blogs/devnettips/archive/2012/03/29/creaci-243-n-de-una-build-con-el-nuevo-servicio-de-builds-para-tfs-service.aspx

http://blogs.msdn.com/b/visualstudioalm/archive/2012/03/27/build-on-the-team-foundation-service.aspx

image

Buenas,

desde el blog oficial de Kinect for Windows, comentan un par de detalles interesantes sobre la nueva versión del SDK de Kinect.

Vamos con los puntos más interesantes

  • La próxima versión será 1.5, con lo que no es un Major Release sino una evolución desde la versión 1.0.
  • La fecha de salida será a final de mayo.
  • Se incorporan nuevos lenguajes para el reconocimiento de voz, French, Spanish, etc. …
  • Lo más interesante es que se detectarán skeleton parciales con 10 puntos o más, que nos permitirán detectar la parte superior de un cuerpo.

Supongo que será parte de algo más grande, pero tiene buena pinta.

 

Saludos @ Home

El Bruno

image image image

Fuente: http://blogs.msdn.com/b/kinectforwindows/archive/2012/03/26/what-s-ahead-a-sneak-peek.aspx

Publicado 29/3/2012 10:38 por El Bruno | con no comments
Archivado en:

image

Buenas,

los que seguimos utilizando la máquina virtual de Visual Studio 2010 ALM para demos y pruebas, sabemos que dentro de unos días se nos acaba el período de prueba.

Por suerte el gran Brian Keller, nos confirma en un post que que la fecha de expiración de la misma se ha extendido desde el 9 de Abril del 2012 al 10 de Septiembre de 2012. Risa

Los datos de descarga se pueden ver desde http://elbruno.com/2012/03/02/vs1-maquinas-virtuales-para-probar-visual-studio-11-alm-y-visual-studio-2010-alm/

 

Saludos @ Home

El Bruno

image image image
Fuente: http://blogs.msdn.com/b/briankel/archive/2012/03/27/updated-visual-studio-2010-alm-virtual-machine.aspx

ALM 03

Buenas,

hoy toca post de autoayuda. Siempre he pensado que los libros de autoayuda están creados para personas que no encajan o que no están muy felices con lo que tienen. Luego estos libros describen una serie de problemas que es muy probable que nadie tenga, pero claro la gente los hace suyos y … pum! bombazo editorial, tienes a millones de personas comprando un libro que básicamente te repite las lecciones que te dieron tus padres cuando eras un adolescente.

Aunque claro, es mejor parar €10 por un libro que te ayude, que aprovechar la sabiduría que te brindan gratis por allí.

En mi caso, lo de los 30 minutos es algo que me ha costado 35 años en aprender. Hace un tiempo, comenté como había personalizado mi propia versión de GTD, trabajando con pomodoros de 25 minutos y gestionando mis ToDos con OneNote (link). Con el tiempo, el hecho de dedicar períodos de 25 o 30 minutos con un foco exclusivo hacia un solo tema, me ha ayudado a sacar adelante cosas que antes no podía.

Pero lo más importante que he aprendido, es que en estos pequeños bloques de tiempo, puedo lograr mucho, si aprendo a separar en bloques pequeños las tareas que me voy agregando. Esto que se escribe tan fácilmente en 3 líneas, luego es bastante más complicado de implementar cuando lo llevas a la realidad. Pero con el tiempo, aprendes a distinguir las piedras grandes de las piedras pequeñas; y finalmente consigues que sean todas piedras pequeñas.

Nota: ¿no conoces la historia de las piedras y el lago de Toyota? pues deberías (link)

Esto viene a cuento de que mi padre de chico, siempre me decía que la mejor forma de emprender un viaje es dando un primer paso. O que si tengo delante mío un problema muy grande, pues lo mejor es separarlo en problemas pequeños. Y luego ir solucionando uno a uno. Vamos que era información gratuita que podía tener gratis y después de estudiar sobre ALM durante más de 10 años, le voy captando la idea.

Nota 2: Mi padre es ingeniero y es un crack por si no lo sabías (link). En la siguiente foto ves como la siguiente generación de Capuanos ha entendido que las cosas mejor entran a martillazos en la cabeza Risa

image

Entonces, ¿qué hago con esto para mejorar el ciclo de vida de mis desarrollos?. Pues aplicar el sentido común y dedicar 30 minutos diarios a encontrar respuestas a las siguientes preguntas:

  • ¿Estoy desarrollando software de calidad?
  • ¿Qué puedo hacer para mejorar la calidad de mi proceso de desarrollo?
  • ¿Estoy trabajando con las mejores herramientas?
  • ¿Conozco cómo trabajar con estas herramientas para ser lo más productivo posible?
  • ¿Estoy aportando valor a mi negocio?
  • etc.

Estas preguntan parecen triviales, pero por ejemplo la última es uno de los puntos que más abandonamos los informáticos. Muchas veces pensamos que la solución tecnológica de la muerte es lo mejor que podemos hacer, cuando en realidad con algo simple y concreto estamos aportando más valor del que necesitamos. Eso sí, sin dejar de olvidar que "la deuda técnica” (link) puede destruir un proyecto poco a poco.

Para resumir:

Dedica 30 minutos un día a pensar cómo mejorar tu forma de trabajo.

Luego aplica otros 30 minutos en aplicar estas mejoras.

Finalmente tienes una sesión de 30 minutos para evaluar si estas mejoras realmente se reflejan en tu día a día.

Cuidado, esto no es una tarea de 90 minutos en un día, es repartir y pensar en como mejorar con el tiempo ... pero PENSANDO !!!

Yo lo hago, y también dedico un pomodoro diario a

  • Hacer un CodeKata, para no olvidarme de las bases de la programación
  • Leer un poco sobre tecnología, tendencias, etc., para no perder el tren

 

 

Saludos @ La Finca

El Bruno

image image image
Publicado 28/3/2012 17:22 por El Bruno | con no comments
Archivado en:

image

Buenas,

los que usualmente hacemos presentaciones de ALM con herramientas de Microsoft conocemos la potencia de DemoMate. Demomate es un cliente en Silverlight que nos permite reproducir paso a paso, un escenario concreto grabado a partir de la interacción con un ordenador.

Es decir, es como un video pero mucho más interactivo y donde sabes que las demos no fallarán. Lo único que hay que tener en cuenta es que DemoMate es de pago, con lo que si queremos grabar demos por nuestra cuenta deberemos comprar primero la licencia.

Pues bien, el gran Brian Keller, sale al paso con una solución ya que nos deja pregrabadas varias demos de Visual Studio 11 y Team Foundation 11 para mostrar las principales capacidades de ambos productos.

Puedes descargar las demos desde aquí, y obviamente para las demostraciones en vivo, la máquina virtual desde aquí.

Si las quieres ver online

 

Saludos @ Home

El Bruno

image image image

Referencias: http://blogs.msdn.com/b/briankel/archive/2012/03/15/visual-studio-11-beta-alm-demomates-now-available.aspx

http://blogs.msdn.com/b/briankel/archive/2011/10/16/demomates-for-visual-studio-11-alm-demos.aspx

image

Buenas,

ayer tuve la suerte de participar en el primer CodeMotion de España en una ponencia junto con @vgaltes. El evento en general fue genial, se juntó mucha gente, hubo mucho networking, muchas caras conocidas y obviamente con la suerte de poder desvirtualizar a más de uno.

Además fue la excusa ideal para conocer un poco herramientas y tecnologías fuera de mi scope, donde tengo que admitir que Groovy y Grails, han sido una gran sorpresa para mis.

Finalmente en la última sesión tenía la opción de ir a ver a Luis Fraile o a David Bonilla. Como a Luis lo tengo conocido a @David_Bonilla no lo había visto en vivo pero sí conocía su fama, me metí en su sesión. La verdad es que fue un crack, por un lado un despliegue de recursos como hacía mucho que no lo veía y por otro, una persona cercana pero con las ideas bien puestas en la cabeza.

Volviendo a la sesión de Kinect que hicimos con Vincenc, pues nos lo pasamos bien. Tiramos un par de líneas de código y nos pusimos a mostrar ejemplos de aplicaciones Kinect donde lo que mejor se nos dio fue sacar un par de sonrisas. El pobre Vicenc tuvo que sufrir la labia de un argentino y además un portátil al que no no estaba acostumbrado pero salió al paso como un crack!

Me quedo con la anécdota de que la sala de nuestro evento estaba tan llena que al momento de forcejear para entrar a la misma tuve la siguiente conversación con un flaco que estaba delante mío:

Bruno – me dejas pasar?

Flaco – no hay más sitio

Bruno – pero es que con @vgaltes somos los ponentes

Flaco – ahh entonces SI pueden pasar Risa

casi no entramos !!!

image

image

Y el código fuente con los ejemplos se puede descargar desde https://skydrive.live.com/redir.aspx?cid=bef06dffdb192125&resid=BEF06DFFDB192125!3904&parid=BEF06DFFDB192125!3842&authkey=!AHlC-AoSBzrGWnA

Saludos @ Home

El Bruno

image image image
Publicado 25/3/2012 17:54 por El Bruno | 3 comment(s)
Archivado en: ,

image

Buenas,

si bien ya lo han comentado en varios sitios, es importante destacar la noticia.

Ahora Codeplex soporta la creación de proyectos basados en GIT. 

image

Visto desde afuera no parece algo tan importante, pero si leemos entre líneas hay 2 cosas interesantes a destacar.

En primer lugar que este cambio no esté basado en una decisión estratégica de MS sino que viene impulsado por la gran cantidad de peticiones que realiza la comunicada. Cuidado, no seamos ingenuos; esto no significa que ahora MS comience a hacer todo lo que diga la comunidad, ni tampoco que no piensen ganar nada con este cambio. Pero si es importante tener en cuenta que incluir un software de este tipo, dentro de la plataforma de gestión de código para las comunidades de Microsoft es un punto que abre muchas posibilidades.

Por una parte, ayudar a mejorar los productos de la familia de Visual Studio. VS11 y TFS11 están muy bien, pero si comparamos la fluidez de trabajo que da un DCVS como GIT, pues no hay color. Es por esto, que detrás de esta decisión hay un deseo de formar a los developers orientándolos a nueva forma de trabajo (que ya se incluirá en VS).

Además con este cambio, se pretende incluir en Codeplex a un gran conjunto de developers que actualmente utilizan GIT para sus desarrollos.

En segundo lugar, no perdamos de vista que MS está incorporando un software OpenSource dentro de su plataforma. Esto no es la primera vez, ni tampoco será la última, pero sirve de referencia para dar una idea de lo poderosa que es la idea de OpenSource para los equipos de MS. Algo que desde afuera no se ve mucho, ya sólo se tiene en cuenta la faceta de vender software enlatado que posee Microsoft.

A la larga veremos si termina siendo una copia de GitHub o de otros sitios más avanzados basados en GIT. Lo que es importante no perder de vista, es que CodePlex no solo ofrece soporte para un repositorio de Source Control, sino que agrega varias posibilidades más … ahí lo dejo.

 

Saludos @ Home

El Bruno

image image image

Fuentes:

http://blogs.msdn.com/b/bharry/archive/2012/03/22/the-future-of-codeplex-is-bright.aspx

http://blogs.msdn.com/b/codeplex/archive/2012/03/21/git-commit-m-codeplex-now-supports-git.aspx?wa=wsignin1.0

Publicado 23/3/2012 14:55 por El Bruno | con no comments
Archivado en: ,
image

Buenas,

lo digo y lo repito:

no puedes trabajar con Visual Studio sino tienes ReSharper

Para el caso de Team Foundation la frase es similar

no puedes trabajar con Team Foundation Server sin las TFS Power Tools

Visual Studio 11 y Team Foundation 11 están en modo Beta, pero eso no quita que los chicos de Redmond se pongan las pilas y nos envíen una versión de las PowerTools específica para TFS11.

Las Power Tools no tienen ninguna novedad o herramienta nueva (eso por ahora Guiño). En las misma encontrarás los clásicos Team Process Editor, Best Practices Analyzer, etc.

Vamos que un recomendado de los buenos.

 

Saludos @ Home

El Bruno

image image image

Descarga: http://visualstudiogallery.msdn.microsoft.com/27832337-62ae-4b54-9b00-98bb4fb7041a

image

Buenas,

hace un par de días me preguntaban como hacer para pintar un skeleton con el nuevo KinectSDK, en este post. El post de hoy explica en pocos pasos los conceptos básicos para pintar el skeleton.

Para este ejemplo utilizaremos un formulario WPF, en el que agregaremos un Canvas donde pintaremos el skeleton.

   1: <Window x:Class="KinectSkeleton01.MainWindow"
   2:         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   3:         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   4:         Title="MainWindow" Height="480" Width="640">
   5:     <Grid>
   6:         <Canvas Name="skeletonCanvas" 
   7:                 Height="480" Width="640" 
   8:                 HorizontalAlignment="Center"/>
   9:     </Grid>
  10: </Window>

Lo siguiente a tener en cuenta es trabajar con el sensor Kinect como una variable local del form. En este post (link) hable un poco al respecto.

Una vez controlado el estado del Kinect, lo siguiente es inicializar la captura de skeleton (línea 6 y 7) y suscribirse al evento de cambio de frame para el skeleton (línea 8).

En la implementación de este evento, en primer lugar limpiaremos el canvas (línea 14) y una vez validado el frame recibido (línea 19) copiaremos el array de skeletons a una variable local (línea 21 y 22).

Las líneas finales verifican el estado del Joint de la cabeza para ver si el seguimiento es correcto y luego utilizan un helper de ElBruno.Kinect para pintar el skeleton.

   1: void MainWindowLoaded(object sender, RoutedEventArgs e)
   2: {
   3:     if(KinectSensor.KinectSensors.Count == 0)
   4:         return;
   5:     _kinect = KinectSensor.KinectSensors[0];
   6:     _kinect.SkeletonStream.Enable();
   7:     _kinect.Start();
   8:     _kinect.SkeletonFrameReady += KinectSkeletonFrameReady;
   9: }
  10:  
  11: void KinectSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e)
  12: {
  13:     // Remove the old skeleton
  14:     skeletonCanvas.Children.Clear();
  15:     Skeleton[] skeletons = null;
  16:  
  17:     using (var frame = e.OpenSkeletonFrame())
  18:     {
  19:         if (frame != null)
  20:         {
  21:             skeletons = new Skeleton[frame.SkeletonArrayLength];
  22:             frame.CopySkeletonDataTo(skeletons);
  23:         }
  24:     }
  25:  
  26:     if (skeletons == null) return;
  27:  
  28:     foreach (var skeleton in skeletons)
  29:     {
  30:         if (skeleton.TrackingState != SkeletonTrackingState.Tracked) continue;
  31:         var headJoint = skeleton.Joints[JointType.Head];
  32:         if (headJoint.TrackingState != JointTrackingState.NotTracked)
  33:         {
  34:             var skeletonDraw = new SkeletonDraw();
  35:             skeletonDraw.DrawSkeleton(_kinect, skeletonCanvas, skeleton);
  36:         }
  37:     }
  38: }

La clase encargada de pintar el skeleton básicamente pinta líneas entre cada uno de los joints del mismo. Como podemos ver en el siguiente código las líneas se pintan entre 2 puntos con el canvas y el sensor como elementos de referencia.

   1: void AddLine(KinectSensor kinectSensor, Canvas drawCanvas, Joint j1, Joint j2)
   2:  
   3:    var boneLine = new Line {Stroke = SkeletonBrush, StrokeThickness = 5};
   4:  
   5:    var j1P = kinectSensor.MapSkeletonPointToDepth(j1.Position, DepthImageFormat.Resolution640x480Fps30);
   6:    boneLine.X1 = j1P.X;
   7:    boneLine.Y1 = j1P.Y;
   8:  
   9:    DepthImagePoint j2P = kinectSensor.MapSkeletonPointToDepth(j2.Position, DepthImageFormat.Resolution640x480Fps30);
  10:    boneLine.X2 = j2P.X;
  11:    boneLine.Y2 = j2P.Y;
  12:  
  13:    drawCanvas.Children.Add(boneLine);
  14:  
  15:  
  16: ublic  float JointDistance(Joint first, Joint second)
  17:  
  18:    float dx = first.Position.X - second.Position.X;
  19:    float dy = first.Position.Y - second.Position.Y;
  20:    float dz = first.Position.Z - second.Position.Z;
  21:  
  22:    return (float)Math.Sqrt((dx * dx) + (dy * dy) + (dz * dz));

El código de ejemplo se puede descargar desde

https://skydrive.live.com/redir.aspx?cid=bef06dffdb192125&resid=BEF06DFFDB192125!3903&parid=BEF06DFFDB192125!1932&authkey=!AKQC01rb-avYBVg

 

Saludos @ Home

El Bruno

image image image

Recursos

http://elbruno.com/2012/03/06/kinectsdk-howto-detectar-el-cambio-de-estado-o-desconexion-del-sensor/

ALM 03

Buenas,

repito el título del post que más que un título es una afirmación

AUTOMATIZAR PROCESOS ES AHORRAR A LARGO TIEMPO

Esto no es una tarea fácil, pero una de las formas de encarar la misma es la siguiente

1. Identificar las tareas repetitivas que realizamos manualmente durante el desarrollo de una aplicación

2. Evaluar la posibilidad de crear un proceso automático que se encargue de realizar esas tareas

3. Definir un período de prueba para la implantación de este proceso

4. Verificar el tiempo ganado utilizando este proceso

Si seguimos esos pasos durante la implantación de un proceso de automatización, seguramente veremos una de estas dos opciones

- lo que inicialmente parecía una tarea que podía ser sustituida rápidamente por un script luego se complica bastante y no tiene sentido abandonar el proceso manual

- el proceso automatizado comienza a ser parte de un proceso de automatización cada vez mayor que nos ayuda a ganar calidad en nuestros desarrollos

Esto que parece un poco de teoría de cerveza de viernes por la noche en realidad es bastante cercano a nuestro día a día. He aquí un ejemplo con uno de los grandes “el Javi Gallardo” (a ver cuando te creas un blog che!)

Resulta que para compartir el output de una aplicación era necesario comprimir la misma en un formato especial, separar el archivo comprimido en varios chunks, firmarlos, y par de pasos más.

Cuando realizábamos este proceso a mano, el mismo nos tomaba menos de un minuto. Pero siempre existía la posibilidad de poner mal la clave del ZIP, de separar mal los chunks, etc. Javi se tomó 30 minutos y se creó un script que se encargaba de realizar este proceso.

De esta forma, logramos tener siempre el mismo OUTPUT a partir de un proceso repetitivo y predecible (que es una de las bases sobre las que debemos trabajar).

A nivel métricas, simplemente evitando que Javi se equivocase en la generación de un paquete ya habíamos ganado el tiempo de generación del script. Javi es un crack, pero si asumimos que se podía equivocar 2 veces al día.

Todas las ejecuciones posteriores nos dieron una ganancia de +300 segundos. Finalmente, después de un par de meses habíamos ganado 2 días/hombre. (Esto traducido a €uros siempre nos da una alegría)

Con Javi no fuimos más allá, ya que con el script nos bastaba, pero siempre existe la posibilidad de pensar un poco out-of-the-box

  • delegar en una build de Team Foundation la responsabilidad de realizar este proceso.
  • procesar el resultado de este proceso solo en ocasiones de compilación exitosa y si los tests se ejecutan correctamente
  • automatizar el empaquetado y distribución a partir de este proceso
  • etc.

Cuando llegamos a estos escenarios estamos más cerca de tener escenarios de Continuous Delivery (sobre lo que hablé en este link), simplemente automatizando tareas.

Existen muchos escenarios donde podemos automatizar, la mayoría se traducen en despliegues, pero rápidamente se me ocurren los siguientes

  • Despliegues, por ejemplo cuando desplegamos a AZURE, ¿porqué lo hacemos SIEMPRE manualmente?
  • Pruebas, el principal punto donde automatizar nos garantiza calidad
  • Generación de código, no es uno de los más recomendados, pero trabajar con plantillas por ejemplo es una forma de garantizar siempre el mismo OUTPUT a partir de un INPUT determinado
  • Muchos más …

Finalmente, comentar que tal vez el mejor momento donde podemos aplicar estos procesos es en el momento de integrar nuestro código. En el caso de trabajar con Team Foundation, la definición de una build es increíblemente potente como para implementar estos procesos.

En AVANADE Spain tenemos una serie de definiciones de Build que nos permiten realizar diferentes tareas de automatización. Desde procesos para garantizar la calidad, como la ejecución de análisis de estilo de código (StyleCop), generación de informes personalizados a partir de pruebas unitarias y de pruebas de MTM, hasta despliegues automatizados a AZURE, ClickOnce, WebDeploy, etc.

 

Saludos @ Home

El Bruno

image image image
Publicado 17/3/2012 20:05 por El Bruno | con no comments
Archivado en: ,

image

Buenas,

otra vez ReSharper llega a mi y me evita horas y horas de trabajo innecesario, esta vez aprovechándome de la capacidad extendida que tiene para generar plantillas.

Si utilizas mucho Visual Studio, supongo que sabrás que si escribes “prop” y presionas 2 veces la tecla TAB, pues el code snippet que viene por defecto con el IDE te crea una plantilla de una propiedad auto implementada.

image

Con esto es suficiente en la mayoría de los casos, pero cuando llegan los amigos del pinta y colorea, pues tienes que comenzar a trabajar con Dinamyc Properties (creo que se llaman así) donde tu clase debe implementar la interfaz INotifyPropertyChanged y luego disparar la notificación en el set de la propiedad.

Vamos que una forma de implementar una propiedad Name de este tipo sería algo así.

   1: #region Name
   2: [XmlIgnore] public const string NamePropertyName = "Name";
   3: [XmlIgnore] private string _name;
   4: public string Name
   5: {
   6:     get { return _name; }
   7:     set
   8:     {
   9:         _name = value;
  10:         RaisePropertyChanged(NamePropertyName);
  11:     }
  12: }
  13: #endregion

El problema viene dado cuando tienes que ir creando propiedades de este tipo de una forma rápida y te pasa lo que me pasa a mi un viernes: estás cansado (esto sirve como excusa para no pensar un poco más).

Pero por suerte, llega ReSharper con su edición de plantillas extendidas y te permite sacarte de arriba el problema como si nada.

Lo primero es acceder al panel “Templates Explorer” de ReSharper, utilizando el menu “ReSharper // Templates Explorer”. En el mismo veremos el listado de plantillas con las que podemos trabajar.

image

Para el caso que comentaba antes, he creado un nuevo template, llamado PropNot con el siguiente texto dentro del mismo

   1: #region $Name$
   2: [XmlIgnore]
   3: public const string $Name$PropertyName = "$Name$";
   4: [XmlIgnore]
   5: private $type$ _$NameLower$;
   6: public $type$ $Name$
   7: {
   8:     get { return _$NameLower$; }
   9:     set
  10:     {
  11:         _$NameLower$ = value;
  12:         RaisePropertyChanged($Name$PropertyName);
  13:     }
  14: }
  15: #endregion

Como se puede ver, dentro del mismo se implementan variables identificadas con el signo $$ y luego cada una de estas variables tiene un comportamiento especial.

- La variable $Name$ es de tipo input para definir el nombre de la propiedad

- la variable $type$ define el tipo de la propiedad y presenta la lista de tipos en el intellisense

- la variable $NameLower$ obtiene el valor de la variable $Name$ y cambia el primer carácter por lowerCase()

image

Pues listo, ahora con dos clics ya puedo seguir con las propiedades raras estas de un tirón Risa

image

 

Saludos @ La Finca

El Bruno

image image image
p>image

Buenas,

después de un buen tiempo trabajando con Visual Studio 11 y ReSharper 7, pues ya le voy agarrando la mano. Los que se quejan de los íconos y el Look & Feel pues se quejan gratis porque en realidad, una vez que te acostumbras ni te das cuenta de que ha cambiado el IDE.

Aclaración: personalmente pienso que si los colores del IDE de VS11 te molestan, es que estas más preocupado por el IDE que por el código … no debería ser así.

Pero bueno, como han cambiado bastantes cosas, si es importante conocer y aprender sobre las mismas. Una de ellas es que ahora con Visual Studio 11 podemos integrar la ejecución de pruebas unitarias con diferentes set de unit tests, nUnit, MSTest, etc. Pero claro para dar soporte a este escenario, han tenido que modificar la forma en la que Visual Studio 2010 trabajaba atado a MSTests.

Veamos un ejemplo. Yo tengo una solución en Visual Studio con una ClassLibrary con las funciones Foo() y Bar(), y luego 2 unit tests con el siguiente código.

   1: [TestMethod()]
   2: public void AskForFooAndGetFoo()
   3: {
   4:     var target = new Class1();
   5:     var actual = target.Foo();
   6:     Assert.AreEqual("Foo", actual);
   7: }
   8:  
   9: [TestMethod()]
  10: public void AskForBarAndGetBar()
  11: {
  12:     var target = new Class1();
  13:     var actual = target.Bar();
  14:     Assert.AreEqual("Bar", actual);
  15: }

Como soy una persona organizada, pues tenía creada mi lista de tests

image

y claro, los unit tests pasaban OK y la cobertura de código era muy buena.

image

Hasta aquí todo genial. Y yo tan feliz trabajando con Visual Studio 2010.

Sin embargo, la cosa cambia un poco cuando abrimos la misma solución con Visual Studio 11 vemos que las listas de tests no están más soportadas. Podemos ver los tests y las categorías que hemos creado pero no podemos ejecutar los tests.

image

El artículo de referencia al que nos redirigen, está muy bien aunque estoy seguro que lo cambiarán en un futuro próximo.

Para la ejecución de las pruebas unitarias, tenemos ahora un nuevo panel en Visual Studio 11 llamado “Unit Test Explorer”. Y he aquí un detalle interesante sobre el funcionamiento del mismo.

El panel “Unit Test Explorer”, se encarga de inspeccionar automáticamente el código de nuestra solución y detecta las pruebas unitarias que hay en la misma.

image

Luego podemos ejecutar las pruebas unitarias, lanzar las pruebas fallidas, las que han pasado correctamente, etc.

image

También tenemos la capacidad de filtrar por estas vistas y de seleccionar el TestSettings con el que queremos ejecutar las pruebas.

Pero lo mejor (o una de las mejores cosas) está un poco escondida. Ahora el IDE nos permite configurar Visual Studio 11 para que las pruebas unitarias se ejecuten automáticamente después de cada compilación (algo que antes hacía con una MACRO).

image

Así que … nuestras pruebas no se han perdido, solo tenemos que organizarlas nuevamente. Y además es un excelente momento para revisar nuestras pruebas, empezando por el nombre de las mismas.

Lo dijo esta mañana a través de Twitter el equipo de ReSharper. @ReSharper

Documenting a method name with a comment? Try giving it a better name. Better name doesn't fit in one line? Now you have a serious issue!

 

 

Saludos @ Home

El Bruno

image image image

Referencias: http://msdn.microsoft.com/library/dd286595(VS.110).aspx

Publicado 15/3/2012 15:15 por El Bruno | con no comments

image

Buenas,

pues eso que el próximo 24 de marzo en la UPM de Madrid voy a participar con el gran Vicenç García (@vgaltes) en una sesión de introducción a KinectSDK.

Veremos el combo 1 de Kinect, detección de movimientos, gestión de la cámara, del sensor de profundidad, etc. Vamos que en 45 minutos daremos un repaso rápido por todo lo que tiene el KinectSDK y si nos queda tiempo pasaremos a las sorpresas.

Obviamente que queremos agradecer a toda la organización de CodeMotion.es que se lo están pasando en grande con toda la gestión del evento y lo increíble es que dentro de la cantidad de sesiones que hay (http://codemotion.es/talks) podamos tener tiempo para mostrar un poco de Kinect Risa

Saludos @ Home

El Bruno

image image image
Publicado 14/3/2012 21:15 por El Bruno | con no comments
Archivado en: ,,

image

Buenas,

los archivos DGML, de los que hablado bastante en posts previos han incorporado un par de novedades interesantes en Visual Studio 11.

Una de las que más me ha llamado la atención es que ahora podemos editar la posición de los nodos del gráfico y esa información se almacena dentro del mismo.

Si por ejemplo, creamos un archivo DGML con la siguiente información:

   1: <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
   2:   <Links>
   3:     <Link Source="Bruno" Target="Valentino" />
   4:     <Link Source="Bruno" Target="Martina" />
   5:     <Link Source="Pao" Target="Valentino" />
   6:     <Link Source="Pao" Target="Martina" />
   7:   </Links>
   8: </DirectedGraph>

 

Podremos ver lo siguiente en el visor gráfico

image

Ahora podemos mover los contenidos del gráfico a nuestro criterio. Por ejemplo en este caso veo que además han incorporado los “conectores inteligentes” para el automatic chart.

image

Si vemos la información que se ha generado en el contenido del DGML veremos que ahora tenemos mucho más para trabajar.

   1: <?xml version='1.0' encoding='utf-8'?>
   2: <DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
   3:   <Nodes>
   4:     <Node Id="Bruno" Bounds="99.7241031138102,-9.33186195373535,51.6633333333333,25.96" Label="Bruno" UseManualLocation="True" />
   5:     <Node Id="Martina" Bounds="11.4679100863139,103.543610028076,60.9266666666667,25.96" Label="Martina" UseManualLocation="True" />
   6:     <Node Id="Pao" Bounds="3.25611114501953,-8.40670049756368,50,25.96" Label="Pao" UseManualLocation="True" />
   7:     <Node Id="Valentino" Bounds="8.41111859003703,47.5835100280762,70.3266666666667,25.96" Label="Valentino" UseManualLocation="True" />
   8:   </Nodes>
   9:   <Links>
  10:     <Link Source="Bruno" Target="Martina" Bounds="68.7575836181641,16.628137588501,48.8051223754883,79.2549724578857" />
  11:     <Link Source="Bruno" Target="Valentino" Bounds="69.6639488796923,16.6281380462646,37.1953348604241,25.8227892240103" />
  12:     <Link Source="Pao" Target="Martina" Bounds="-3.06789708137512,17.5532989501953,23.9082214832306,79.9630508422852" />
  13:     <Link Source="Pao" Target="Valentino" Bounds="31.8073044893709,17.553299407959,5.84093040266691,21.3492393330849" />
  14:   </Links>
  15:   <Properties>
  16:     <Property Id="Bounds" DataType="System.Windows.Rect" />
  17:     <Property Id="Label" Label="Label" Description="Displayable label of an Annotatable object" DataType="System.String" />
  18:     <Property Id="UseManualLocation" DataType="System.Boolean" />
  19:   </Properties>
  20: </DirectedGraph>

Lo dicho, nice feature para VS11.

 

Saludos @ Home

El Bruno

image image image
Publicado 12/3/2012 20:58 por El Bruno | con no comments
Archivado en: ,

ALM 03

Buenas,

tenía pensado escribir sobre algunas de las novedades de Static Code Analysis en Visual Studio 11, pero mejor saco este post del draft y lo publico.

Cuando trabajamos en un proyecto, independientemente de la herramienta que utilicemos para el análisis de código estático (Code Analysis, FxCop, etc.) siempre es recomendable aplicar las siguientes reglas

  • Como mínimo aplicar un conjunto mínimo de reglas de análisis a todos los proyectos. Basado en el principio de “menos da una piedra”, esto nos ayuda a protegernos de errores a futuro. En el caso de Code Analysis, el set de “Minimun Rules” es lo ideal.
  • Tienes que trabajar en un entorno de Integración Continua, a esto lo doy por hecho. En el caso de que el proceso de análisis consuma mucho tiempo en local, lo recomendable es no realizar la validación de Code Analysis en local. Eso sí, en el proceso de integración continua se debe forzar el análisis de código estático
  • Fundamental. No ignorar los Warnings en las builds, dedicarle tiempo y solucionar los problemas que se detectan en los mismos. Muchas veces prefiero cambiar el modo de aviso de Warning a Error, solamente para forzar a que se resuelvan los problemas que detecta en análisis de código estático.
  • Finalmente, y opcional. Si alguien quiere tener el detalle local, activa el proceso de Code Analysis en local. Visual Studio lo permite hacer en 2 clics.

 

Saludos @ Home

El Bruno

image image image

References:

List of tools for static code analysis

http://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis

Publicado 10/3/2012 20:55 por El Bruno | con no comments
Archivado en: ,

image

Buenas,

hoy Brian Harry nos comenta una interesante noticia:

Team Explorer Everywhere comienza a ser gratis al igual que Visual Studio Team Explorer.

Cuidado, esto no quiere decir que no haya que pagar por acceder a un servidor Team Foundation, todavía es necesaria una CAL (Client Access License) para cada cliente de trabajo con Team Foundation. Pero a partir de ahora, si trabajas en un entorno “no Visual Studio” pues solo necesitarás la CAL.

Dato interesante, si tenemos en cuenta que la versión TFS Express (link) nos permite que un equipo de hasta 5 personas pueda trabajar sin comprar licencias. Dicho en otras palabras, 5 Eclipses y un TFS Express Smile

Para detallarlo mejor, Brian Harry nos presenta 3 escenarios de ejemplo

  1. Team Foundation Service or CodePlex – Both of these provide online hosted versions of TFS that can be used by anyone (no CAL purchase necessary – subject to change when Team Foundation Service leaves “preview” but true for now).  This means that regardless of whether you use the Visual Studio based Team Explorer or the Eclipse based Team Explorer Everywhere, you can use these services without having to purchase any software.
  2. Team Foundation Server “Standard Edition” – You can acquire the standard Team Foundation Server with the full set of TFS capabilities a number of different ways – through MSDN, as a separate purchase, etc.  Having purchased it and a CAL, where necessary, you can use either the Visual Studio based Team Explorer or the Eclipse based Team Explorer Everywhere with no additional purchases.
  3. Team Foundation Server Express – I recently announced the availability of a Team Foundation Server Express 11 Beta that enables a team of up to 5 people to experience much of the power of TFS for free.  You can now use TFS Express along with Team Explorer and/or Team Explorer Everywhere all for no charge (up to 5 users – additional users will need to purchase CALs).

Y finalmente comentar que este cambio se aplica para la versión Team Explorer Everywhere 2010 Service Pack 1 y para la nueva versión Team Explorer 11.

Saludos @ Home

El Bruno

image image image

Fuente: http://blogs.msdn.com/b/bharry/archive/2012/03/08/even-better-access-to-team-foundation-server.aspx

image

Buenas,

después de terminar el evento, dejo en el post los materiales del mismo. Por un lado la presentación

y el link de acceso al source code de ejemplo.

https://skydrive.live.com/redir.aspx?cid=bef06dffdb192125&resid=BEF06DFFDB192125!3876&parid=BEF06DFFDB192125!3842&authkey=!AE5qtqzNkUihsc0

 

Saludos @ Home

El Bruno

image image image

image

Buenas,

volvemos un poco al Kinect SDK después de 5 días en los que he dormido bastante poco para migrar una aplicación bastante grande de la Beta 2 a la versión actual de Kinect SDK.

Ahora bien, el nuevo SDK ha cambiado mucho y en algunas cosas es mucho más coherente que el anterior. Por ejemplo al momento de agregar la referencia a nuestro proyecto, en este caso ya tiene un nombre oficial:

Microsoft.Kinect

image

Si seguimos adelante podremos ver que dentro de KinectSensor tenemos un evento especial para la captura de los estados de los sensores: StatusChanged. Este evento además nos puede servir para detectar cuando se conecta o desconecta un sensor al puerto USB.

Un ejemplo, con este código en una aplicación de consola:

   1: static void KinectSensorsStatusChanged(object sender, StatusChangedEventArgs e)
   2: {
   3:     Console.WriteLine("{0} - New Status: {1}", DateTime.Now.TimeOfDay.ToString(), e.Status);
   4:     _kinect = e.Sensor;
   5:     if (e.Sensor != null)
   6:     {
   7:         Console.WriteLine("{0} - Sensor Status: {1}", DateTime.Now.TimeOfDay.ToString(), _kinect.Status);
   8:     }
   9:     else
  10:     {
  11:         Console.WriteLine("{0} - No Sensor", DateTime.Now.TimeOfDay.ToString());
  12:     }
  13: }

Cuando lanzamos la aplicación podremos ver como la marca de tiempo, nos indica una pequeña diferencia entre el sensor conectado y el sensor activo (líneas 2y3 vs líneas 4,5)

   1: 20:23:32.9637224 - Start sample application
   2: 20:23:40.0351074 - New Status: Initializing
   3: 20:23:40.0351074 - Sensor Status: Initializing
   4: 20:23:44.7783652 - New Status: Connected
   5: 20:23:44.7783652 - Sensor Status: Connected
   6: 20:23:51.2279666 - New Status: Disconnected
   7: 20:23:51.2279666 - Sensor Status: Disconnected
   8: 20:23:59.2548372 - New Status: Initializing
   9: 20:23:59.2558370 - Sensor Status: Initializing
  10: 20:24:03.5861851 - New Status: Connected
  11: 20:24:03.5861851 - Sensor Status: Connected
  12: 20:24:08.8158976 - New Status: Disconnected
  13: 20:24:08.8158976 - Sensor Status: Disconnected

Si además queremos aprovechar este evento para inicializar el sensor, tenemos que tener en cuenta que solo podremos hacerlo cuando el estado del sensor sea “connected”.

El siguiente ejemplo completo muestra una forma de hacerlo.

   1: using System;
   2: using Microsoft.Kinect;
   3:  
   4: namespace KinectStatus01
   5: {
   6:     class Program
   7:     {
   8:         private static KinectSensor _kinect;
   9:         static void Main(string[] args)
  10:         {
  11:             Console.WriteLine("{0} - Start sample application", DateTime.Now.TimeOfDay.ToString());
  12:             KinectSensor.KinectSensors.StatusChanged += KinectSensorsStatusChanged;
  13:             Console.ReadLine();
  14:             if(_kinect != null)
  15:             {
  16:                 _kinect.Stop();
  17:             }
  18:         }
  19:  
  20:         static void KinectSensorsStatusChanged(object sender, StatusChangedEventArgs e)
  21:         {
  22:             Console.WriteLine("{0} - New Status: {1}", DateTime.Now.TimeOfDay.ToString(), e.Status);
  23:             _kinect = e.Sensor;
  24:             if (e.Sensor != null)
  25:             {
  26:                 Console.WriteLine("{0} - Sensor Status: {1}", DateTime.Now.TimeOfDay.ToString(), _kinect.Status);
  27:                 if (_kinect.Status == KinectStatus.Connected)
  28:                 {
  29:                     _kinect.DepthStream.Enable();
  30:                     _kinect.ColorStream.Enable();
  31:                     _kinect.SkeletonStream.Enable();
  32:                     _kinect.Start();
  33:                     Console.WriteLine("{0} - Sensor Started", DateTime.Now.TimeOfDay.ToString());
  34:                 }
  35:             }
  36:             else
  37:             {
  38:                 Console.WriteLine("{0} - No Sensor", DateTime.Now.TimeOfDay.ToString());
  39:             }
  40:         }
  41:     }
  42: }

 

Saludos @ Home

El Bruno

image image image

image

Buenas,

el equipo de ALM Rangers está cada vez más activo. A través de este post, me entero de los proyectos que están en fase Beta (por más que ahora no se lleve más eso de Beta, RC, RTM, etc.) de un proyecto para la implantación de Kanban para Team Foundation Server.

Si no conoces Kanban, el video que comento en este post es una excelente introducción al tema y obviamente, sino las 20 páginas que le dedico en mi libro “Trabajando en equipo con Visual Studio ALM” también dan un acercamiento de Kanban para TFS.

Pero bueno, a lo que iba. El equipo de ALM Rangers está cerrando un proyecto llamado “Practical Kanban Guidance” que pretende ilustrar el uso de esta metodología en TFS con los siguientes contenidos (fusilados de codePlex)

  • Guidance contains scenario based practical guidance, frequently asked questions and quick reference posters
  • Hands-on Lab contains the HOL that provides a walkthrough of the planning, based on the guidance
  • HOL Package includes a setup part which prepares and configures your environment for this lab
  • HOL Videos which showcase the hands-on labs and guidance in quick 5-10min videos

Ya lo tengo en modo “follow” y seguiré de cerca los avances de este proyecto.

Saludos @ Home

El Bruno

image image image

Fuente: http://blogs.msdn.com/b/visualstudioalm/archive/2012/02/29/welcome-to-visual-studio-11-alm-rangers-readiness-beta-wave.aspx

image

Buenas,

cuando salió la versión Consumer Preview de Visual Studio 11, una de las cosas que intenté hacer fue trabajar con el mismo en lugar de Visual Studio 2010. Me pegué un par de golpes en el camino y lo tuve que dejar, pero ahora con la Beta de Visual Studio 11, vuelvo a hacer la prueba.

Personalmente pienso que esas personas que escriben posts sobre novedades de un producto, y que lo hacen sobre pruebas de 10 minutos en una máquina virtual, pues aportan bien poco para los que trabajan de verdad. En mi caso, trato de utilizar las versiones Beta para mi trabajo del día a día y sobre las mismas escribo mis experiencias.

Aclaración: ¿se nota un aire medio asqueado? pues sí. Hay mucho ladrón en internet que solo sabe hacer copy/paste. O escribir sobre algo sobre lo que no tiene ni idea.

En mi caso, trabajar con Visual Studio, significa trabajar con Visual Studio + ReSharper. Así que después de unos días de tirar líneas “en limpio” sin ReSharper, decidí preguntar a los que saben y gracias a un post de Hadi Hariri (@hhariri) me encontré con la versión 7 en modo EAP para Visual Studio.

En el post de Hadi podes ver los detalles sobre la versión para Visual Studio 11, y obviamente no hace falta recordar que es una versión para Early Adopters sobre un producto Beta Smile

En mi caso, por ahora viene bien … veremos que tal después de un par de semanas.

 

Saludos @ Home

El Bruno

image image image
Source: http://blogs.jetbrains.com/dotnet/2012/03/resharper-70-eap-visual-studio-11-beta-edition-is-nowopen/
Publicado 4/3/2012 23:13 por El Bruno | con no comments
Más artículos Página siguiente >