ASP.NET MVC 3: Layouts con Razor

Introducción

Este es un documento de trabajo para aprender como funcionan las capas en Razor. Sin más comienza el post.

Layouts con Razor

 

Las Layout views son las mater pages de razor. Usa los métodos RenderPage, RenderBody, RenderSection para dibujar la página. En el enlace [1] se pueden ver varios ejemplos de desarrollo.

En el código fuente siguiente podemos ver el uso de RenderBody:

<!DOCTYPE html>
<head>
<title>@ViewBag.Title</title>
<script src=”@Url.Content(“/Scripts/jquery.js”)” type=”text/javascript”></script>
</head>
<body>
@RenderBody()
</body>
</html>

Usando RenderSection

RenderSection se utiliza para indicar que una parte de la página va a contener una capa determinada, el método utiliza dos atributos, nombre de la Sección y un booleano. Una llamada de ejemplo puede ser la siguiente:




Declarando secciones

Las secciones se declaran con la directiva @Section NOMBRE-DE-LA-SECCION. Y entre llaves el código de la sección. Por ejemplo:


@Section Footer{
	Esto es el pie de página
}

Comentarios dentro de los layouts

Para realizar comentarios dentro del código de las layouts, utilizaremos arroba asterisco @* para iniciar el bloque de comentarios y para finalizarlo utilizaremos asterisco arroba *@ .

Localización de las Capas en el proyecto

Las capas se guardan dentro de la carpeta Shared,que a su vez está dentro de la carpeta Views.

Nombrado de las capas

Todas las capas comienzan por el carácter guión bajo _ y contienen la extensión cshtml.

Vista Inicial

Para indicar cual es la vista que se va a cargar utilizaremos el archivo _ViewStar.cshtml, contiene dentro una directiva para indicar la capa de inicio.

@{
	Layout="RUTA-DE-LA-CAPA-NOMBRE-DEL-ARCHIVO-EXTENSION-DOTCSHTML";
}

Enlaces:

[1] – http://www.dotnetcurry.com/ShowArticle.aspx?ID=636

Traducción: Mono.Addins – Punto de Extensión y Extensiones

Introducción

Este artículo es una traducción del original disponible en [1], las licencias aplicadas al original se aplican a la traducción.

mono-logo

La traducción

Una aplicación basada en Mono.Addins se compone de:

  1. Una aplicación huésped (o un huésped de complementos (add-in)), que contiene varios puntos de extensión (extension points).
  2. Varios complementos, que extienden los puntos de extensión del huesped (host)

Implementando un huesped de complementos

El código inmediatamente inferior es un ejemplo básico de una aplicación que contiene complementos, es decir, hace de huésped de complementos. Esta aplicación ejecuta un conjunto de comandos que pueden ser implementados como complementos (add-in).

   1:  using System;
   2:  using Mono.Addins;
   3:   
   4:  [assembly:AddinRoot ("HelloWorld", "1.0")]
   5:   
   6:  class MainClass
   7:  {
   8:      public static void Main ()
   9:      {
  10:          AddinManager.Initialize ();
  11:          AddinManager.Registry.Update ();
  12:          
  13:          foreach (ICommand cmd in AddinManager.GetExtensionObjects<ICommand> ())
  14:              cmd.Run ();
  15:      }
  16:  }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Este código muestra declaraciones e inicializaciones que tienen que hacerse en todas las aplicaciones extensibles:

  • El atributo [AddinRoot] aplicado a un ensamblado indica que ese ensamblado es un huésped de complementos. Todos los proyectos que incluyan gestión de complementos tendrán un identificador y una versión.
  • La llamada al método AddinManager.Initialize se encarga de inicializar el administrador de complementos (AddinManager). Ante de realizar cualquier operación con la clase AddinManager hay que realizar esta llamada.
  • Cuando se realiza la llamada al método AddinManager.Registry.Update, el motor de complementos inspeccionará la carpeta donde está alojada la aplicación (y otras carpetas indicadas por el programador) buscando complementos, esto actualizará el registro de complementos (add-in registry) que almacena la información sobre los complementos.
  • La llamada al método AddinManager.GetExtensionObjects se puede entender como una consulta a los puntos de extension. Devuelve una lista de objetos registrados en un determinado punto de extensión.

Para completar el ejemplo anterior deberemos declarar los puntos de extensión.

Declarando puntos de extensión

Los puntos de extensión se declaran como indica el siguiente código:

   1:  using Mono.Addins;
   2:   
   3:  [TypeExtensionPoint]
   4:  public interface ICommand
   5:  {
   6:      void Run ();
   7:  }

El atributo [TypeExtensionPoint] cuando se le aplica a una clase o a un interfaz indica que un punto de extensión acepta objetos de ese tipo. En el ejemplo, hemos creado un punto de extensión para los objetos que implementan el interfaz ICommand.

Implementando un Complemento (add-in)

Un complemento extiende un punto de extensión de la siguiente manera:

   1:  using System;
   2:  using Mono.Addins;
   3:   
   4:  [assembly:Addin]
   5:  [assembly:AddinDependency ("HelloWorld", "1.0")]
   6:   
   7:  [Extension]
   8:  public class HelloCommand: ICommand
   9:  {
  10:      public void Run ()
  11:      {
  12:          Console.WriteLine ("Hello World!");
  13:      }
  14:  }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Los complementos se desarrollan en ensamblados diferentes, tienen que estar marcados con el atributo [Addin] para ser reconocido como un complemento. Los complementos tienen que indicar a que huesped extienden utilizando el atributo AddinDependency, indicando el id del huesped o complemento y el número de versión.

Mediante la aplicación de la [extensión] atributo a una clase que se declara una nueva extensión del nodo que tipo que se agrega a un punto de extensión. El punto de extensión se determina observando la tipos base e interfaces de la clase. Así que en este ejemplo, la clase implementa la ICommand interfaz, y hay un punto de extensión definida para esa interfaz, por lo que es la extensiónpunto en el que el tipo se registrará. Si una clase implementa varias interfaces, podemos seleccionar el punto de extensión, especificando el nombre del tipo en el atributo, por ejemplo: [Extensión (typeof (ICommand))].

Traducción: Mono.Addins – Localización de Complementos por defecto

Introducción

Este artículo es una traducción del original disponible en [1], las licencias aplicadas al original se aplican a esta traducción.

mono-logo

La traducción

Mono.Addins incorpora un modelo flexible para indicar donde deberían estar los complementos (add-ins). Por defecto, los complementos están en dos rutas:

  • En la carpeta donde está el ejecutable de la aplicación, es decir, dónde está en .exe.
  • En la carpeta ‘addins’, que es la ruta de registro de los complementos.

Por ejemplo, si una aplicación está instalada en ‘/usr/lib/MiAplicacion/inicio.exe’, y la aplicación inicializa el motor de complementos tal que así:

   1:  AddinManager.Initialize("[ApplicationData]/MiAplicacion");

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Entonces los complementos se buscaran por defecto es:

  1. /usr/lib/MiAplicacion
  2. ApplicationData/MiApplication/addins

Incluyendo carpetas de complementos

Se pueden añadir rutas para la búsqueda de complementos utilizando el archivo .addins. Un archivo .addins es una archivo XML que se ve tal que así:

   1:  <Addins>
   2:     <Directory>/alguna/carpeta</Directory>
   3:     <Directory include-subdirs="true">/alguna/carpeta</Directory>
   4:     <Directory>../ruta/relativa/carpeta</Directory>
   5:     <Exclude>alguna/carpeta</Exclude>
   6:  </Addins>

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

Cuando un registro está buscando complementos en una carpeta y encuentra un archivo .addins, lo analizará sintácticamente y de manera recursiva buscará en las carpetas declaradas, que a su vez incluirán archivos .addins. La etiqueta Directory se usa para declarar nuevas carpetas, esta búsqueda no es recursiva por defecto, para activar la búsqueda recursiva utilizamos el atributo include-subdirs. La etiqueta Exclude se usa para no buscar en una carpeta determinada, puede ser una ruta o un archivo.

El sistema operativo de 1K-3A: el problema son las aplicaciones

Introducción

El sistema operativo de 1K-3A será una distribución Linux, actualmente es la versión alpha de OpenQbo, distribución de la que estoy esperando una actualización mayor para poder seguir usándola. Mientras tanto, he elaborado una arquitectura deseable de sistema operativo para 1K-3A que tendría la siguiente arquitectura:

linuxos

 

Arquitectura

Tendríamos varios niveles en el sistema operativo, por un lado el kernel de linux y los drivers de dispositivos. Posteriormente el sistema ROS, del que ya he publicado algún que otro artículo en el blog y después una capa de introspección. La capa de introspección nos permite poder utilizar cualquier lenguaje para acceder a los paquetes disponibles en ROS, este es un trabajo arduo y doloroso pero que tendría la contrapartida y gran ventaja de poder utilizar cualquier lenguaje para el que exista el binding. O mejor dicho, es más fácil crear bindings (adaptaciones) de lenguajes de programación para ROS. Así no nos limitaríamos a C,C++ y Python sino además otros lenguajes soportados por el proyecto Gnome. La capa final es la nube (Cloud), es decir, la conexión permanente de nuestro robot a la nube de servicios disponibles en internet.

ROS/Tutoriales/ComprendiendoLosNodosDeRos

Introducción

Este post es una traducción del original disponible en la web de ROS. Existen una anotación final en la cual hablo sobre la aplicación de la introspección en las librerías roscpp y su uso con otros lenguajes más allá de python y C++. Es una idea sin probar que iré desarrollando a lo largo del desarrollo de mi modelo de R2D2 (1K-3A). La traducción está inacabada.

Introducción a los grafos

Nodos

Un nodo no es más que un ejecutable dentro de un paquete. Los nodos ROS usan a un cliente ROS para comunicarse con otros nodos. Los nodos pueden publicar o suscribirse a un Tema. Los nodos además proporacionar o usar un servicio.

Librerías de Clientes

La liberías de clientes ROS proporcionan nodos escritos en distintos lenguajes para comunicarse:

  • rospy – librería de clientes python
  • roscpp – librería de clientes C++

roscore

roscore es la primera cosa que deberías iniciar cuando uses ROS.

Por favor corre:

$ roscore

Verás algo similar a esto:

... logging to /.ros/log/9cf88ce4-b14d-11df-8a75-00251148e8cf/roslaunch-bvo-13039.log
Checking log directory for disk usage. This may take awhile.
Press Ctrl-C to interrupt
Done checking log file disk usage. Usage is <1GB.

started roslaunch server http://bvo:33919/

SUMMARY
========

NODES

starting new master (master configured for auto start)
process[master]: started with pid [13054]
ROS_MASTER_URI=http://bvo:11311/

setting /run_id to 9cf88ce4-b14d-11df-8a75-00251148e8cf
process[rosout-1]: started with pid [13067]
started core service [/rosout]

Abre un nuevo terminal, usa rosnode para ver que hace roscore en ejecución…

Usando rosnode

rosnode muestra la información de los nodos que están actualmente en ejecución. El comandos rosnode muestra los nodos activos:

$ rosnode list

Verás:

/rosout

Este debería mostrarte unicamente el nodo rosout. Este siempre está ejecutándose.

El comando rosnode info devuelve la información acerca de un determinado nodo.

$ rosnode info /rosout

Este nos devolverá alguna información sobre rosout, como el hecho de que este publica en /rosout_agg.

--------------------------------------------------------------------------------
Node [/rosout]

Publications:
 * /rosout_agg [roslib/Log]

Subscriptions:
 * /clock [unknown type]
 * /rosout [unknown type]

Services:
 * /rosout/set_logger_level
 * /rosout/get_loggers

contacting node http://foo.local:54614/ ...
Pid: 5092

Ahora, vamos a ver más nodos, utilizando el comando rosrun tener otro nodo.

Usando rosrun

rosrun te permite usar el nombre de un paquete para iniciar un nodo con ese paquete (sin necesidad de especificar la ruta).

Usa:

$ rosrun [package_name] [node_name]

Ahora podemos ejecutar turtlesim_node en el paquete turtlesim, en un nuevo terminal:

$ rosrun turtlesim turtlesim_node

Veremos una ventana como la siguiente:

[…]

Resumen

[…]

Fuente: http://www.ros.org/wiki/ROS/Tutorials/UnderstandingNodes

ROS/Tutoriales/NavegandoPorElSistemaDeArchivos

1. Navegando por el sistema de archivos de ROS

Descripción: este tutorial introduce los conceptos sobre el sistema de archivos de ROS, y cubre el uso de roscd, rosls, y las herramientas de la línea de comandos de rospack.

2. Visión general de los conceptos del sistema de archivos

  1. Packages: son paquetes, es el nivel más bajo de organización del software en ROS. Pueden contener cualquier cosa: herramientas, ejecutables…
  2. Manifest: un manifiesto es una descripción de un paquete. El papel más importante es definir las dependencias entre paquetes.
  3. Stacks: son pilas, una colección de paquetes que forman una librería de alto nivel.
  4. Stack Manifest: son manifiestos como los anteriores pero para pilas.

Cuando observes el sistema de archivos, es fácil diferencias entre paquetes y pilas:

  • Un paquete es un directorio con un archivo manifest.xml.
  • Una pila es un directorio que contiene un archivo stack.xml

filesystem

3. Herramientas del sistema de archivos

Para ROS hay una gran cantidad de código esparcido através de varios paquetes y pilas. Navegando con la línea comandos utilizando comandos como ls o cd resulta tedioso en ROS. Por este motivo ROS dispone de su propias herramientas para ayudarte.

3.1 Usando rospack y rosstack

rospack y rosstack forman parte del juego rospack. Esto te permite obtener información sobre paquetes y pilas. En este tutorial unicamente vamos a ver el uso de la opción find, que devuelve la ruta de un paquete o de una pila.

Uso:

$ rospack find [package_name]
$ rosstack find [stack_name]

Ejemplo:

$ rospack find roscpp

Lo que devolverá:

TU_RUTA_DE_INSTALACION/ros/core/roscpp

3.2.- Usando roscd

roscd es parte del juego rosbash. Este comado permite cambiar de directorio (cd) directamente de un paquete o una pila.

Uso:

$ roscd [locationname[/subdir]]

Ejemplo:

$ roscd roscpp

Para verificar que hemos cambiado al directorio del paquete roscpp, usamos el comando de Unix pwd que nos indica el directorio de trabajo:

$ pwd

Devuelve:

TU_RUTA_DE_INSTALACION/ros/core/roscpp

Puedes comprobar que la ruta TU_RUTA_DE_INSTALACION/ros/core/roscpp es la misma que nos mostró el comando rospack find en el ejemplo anterior.

3.2.1.- Subdirectorios

roscd también permite cambiar de un subdirectorio a una pila o a un paquete.

Intenta:

$ roscd roscpp/include
$ pwd

Lo que devolverá:

YOUR_INSTALL_PATH/ros/core/roscpp/include

3.3.- Casos especiales para roscd

Hay pequeños casos especiales que te queremos contar para continuar que no afecta a los paquetes o a las pilas.

3.3.1.- roscd sin argumentos

roscd sin argumentos te devolverá el valor de la variable $ROS_ROOT. Prueba:

Verás:

Esta ruta es la misma definida en $ROS_ROOT.Prueba:

Verás:

3.3.2.- roscd log

roscd log acudirás al directorio donde están almacenados los archivos de log donde ROS los almacena.Posiblemente no tengas ningún archivo de log todavía.

Prueba:

$ roscd log

3.4.- Usando rosls

rosls forma parte del juego de comandos de rosbash. Permite hacer ls directamente sobre paquetes, pilas o lugares comunes dentro de las rutas de los paquetes de ros.

Formato:

$ rosls [locationname[/subdir]]

Ejemplo:

$ rosls roscpp_tutorials

Te devolverá:

add_two_ints_client         listener_unreliable
  add_two_ints_server         listener_with_tracked_object
  add_two_ints_server_class   listener_with_userdata
  anonymous_listener          Makefile
  babbler                     manifest.xml
  CMakeLists.txt              node_handle_namespaces
  custom_callback_processing  notify_connect
  listener                    srv
  listener_async_spin         talker
  listener_multiple           time_api
  listener_single_message     timers
  listener_threaded_spin

3.5.-  Autocompletado con el tabulador

[…]

4.- Conclusiones

[…]

Original en Inglés: http://www.ros.org/wiki/ROS/Tutorials/NavigatingTheFilesystem

Imagen: http://www.ros.org

Patrón de Diseño: Model View ViewModel (I)

logo

Introducción

El patrón de diseño Modelo Vista VistaModelo es usado por las tecnologías Windows Presentation Foundation, Silverlight y Moonlight. Es un patrón de interfaz de usuario como lo son Modelo Vista Controlador o Modelo Vista Presentación. En este post vamos a ver su uso en WPF/Silverlight/Moonlight.

El patrón MVVM

El patrón MVVM e compone de 3 elementos:

  1. El Modelo es la entidad que representa el concepto de negocio, puede ser cualquier cosa desde una entidad usuario hasta una entidad compleja de almacenaje (que contiene a su vez otras entidades).
  2. La Vista es la representación gráfica del control o un conjunto de controles que muestran el Modelo de datos en pantalla. Una vista puede ser desde un ventana de WPF, una página con Silverlight o una plantilla de un control de datos en XAML. La Vista es un observador (Observer) de la VistaModelo, tan pronto cambie la VistaModelo la interfaz de usuario se actualiza, para esto debe implementar el interfaz INotifyPropertyChanged e implentar el evento PropertyChanged.
  3. La VistaModelo es la que une todo. Contiene la lógica del interfaz de usuario, los comandos, los eventos y una referencia al Modelo. En MVVM, la VistaModelo no se encarga de actualizar los datos mostrados por el interfaz de usuario.

Proyecto en Moonlight bajo MonoDevelop

MonoDevelopLogo

Nota: la librería Moonlight no está disponible directamente para su uso cuando inicias un proyecto Moonlight en MonoDevelop, hay que obtenerla compilando el proyecto Mono, para más información recomiendo la lectura del enlace [2].

Creando la solución

Seleccionamos el menú Archivo|Nuevo|Solución, en la Ventana de Nueva Solución picamos en C# y posteriormente en Moonlight, teniendo dos posibles opciones:

  1. Librería de Controles: una librería con controles XAML sin ejecutables.
  2. Aplicación: una aplicación con un punto de entrada de ejecución.

Agregando las referencias

Para solventar la incidencia de las referencias bajo Windows, puedes utilizar tu instalación de Silverlight disponible en la ruta “C:\Archivos de programa\Microsoft SDKs\Silverlight\v2.0\Reference Assemblies”si tienes instalada la versión 4 o cualquier otra posterior a la 2 saldrá un mensaje de error informándote que requiere Moonlight 3 o Silverlight 2.

Tendrás que eliminar las referencias que vienen por defecto en el proyecto, e insertar las nuevas utilizando el apartado de Ensamblados .Net. Quedando las referencias como siguen:

silverlight_referencias

Pero…

Seguimos sin poder compilar debido a que surge un mensaje de error que nos dice lo siguiente:

Error: Framework ‘Silverlight 2.0’ not installed. (EjemploMoonlight)

Sin embargo si está instalado el SDK, una vez navegas por el foro de Mono te encuentras con que no está implementado el backend para proyectos Silverlight, y alguien debería hacerlo [1]:

Ideally someone would implement a SilverlightFrameworkBackend for the
DotNetTargetRuntime, so that MD could find the Silverlight SDK
assemblies. This would be very easy, but I don’t have time to do it
myself right now.

Editando el complemento Moonlight para MonoDevelop

Es necesario bajarse el código fuente de MonoDevelop de GitHub que parece la versión más actualizada del proyecto y preparar el entorno de desarrollo para Windows.

Pero eso será otra historia.

Bibliografía:

Building Enterprise Applications with Windows Presentation Foundation and the MVVM – Raffaelo Garofalo – Microsoft Press – ISBN 978-0-735-65092-3

Enlaces

[1] – http://go-mono.com/forums/#nabble-td1508851

[2] – http://go-mono.com/forums/#nabble-td2323130

Imagen Logo Moonlight: http://www.go-mono.com/moonlight/

Imagen Logo MonoDevelop: http://www.monodevelop.com

CartujaDotNet: Grupo de Usuarios de .Net en Sevilla

3_1

Introducción

@cartujadotnet es el grupo de usuarios de .net de Sevilla, por lo menos el único por ahora. Hoy hemos quedado 2 de los coordinadores de Cartuja Dot Net y otros programadores de .Net de Sevilla, aunque finalmente sólo hemos contado con la gran presencia de @jmaguilar, autor del blog Variable Not Found e impartidor de cursos en Campus MVP de Krasis.

Contacta con el grupo de usuarios

Para contactar con el grupo de usuarios, puedes seguir la cuenta @cartujadotnet a tu cuenta de twitter, acceder a la web del grupo de usuarios en facebook o escribir un correo electrónico a la dirección cartujadotnet@groups.facebook.com

Próximas charlas

Las charlas de @cartujadotnet las dan los propios componentes del grupo de usuarios, la temática de las charlas impartidas hasta ahora versan desde la robótica con Microsoft Robotics Studio, pasando por la programación en Gtk#, programación del puerto serie… todas ellas impartidas por profesionales que tienen a .Net presente en su vida profesional.

mfa-pro

La siguiente charla que impartirán los miembros de @cartujadotnet versará sobre "Programación de Android en .Net", la inscripción será obligatoria y limitada debido a que el espacio es cedido por una pequeña empresa sevillana dedicada a los blogs corporativos.

Imagen Logo .Net: www.microsoft.com

Imagen Logo Mono Android: http://mono-android.net

Copiado y Pegado:¿Todavía crees en los mitos? – Carlos Blé

Así que crees que tal o cual persona es un super gurú venido de otra galaxia como los personajes de Dragon Ball… claro…. te crees el mito y eres fan de tal persona, le idolatras. Amigo, tienes que madurar.

Nadie es mejor ni peor que tú. Nadie es mas ni menos especial que tú. Si todavía no lo ves, tienes que seguir madurando. Todos tenemos que seguir madurando, pero en lo que respecta a las expectativas que te creas de los demás, te invito a que las deseches.

Todos tenemos cosas relativamente únicas y a la vez todos somos iguales. Lo que realmente tiene magia es la interrelación y la colaboración. Entre todos, entre un equipo, las cosas sí salen adelante como por arte de magia y el grado de satisfacción es realmente sano.

Ultimamente voy a sitios donde no conozco a gente que ha oído hablar de mí y cuando me dicen que soy famoso o que soy un gurú me entra la risa.El efecto es el siguiente: cuando sólo han oído hablar de mí, recibo un trato especial, halagos y expectación. Cuando les digo a la cara que no soy mas listo ni más capaz que ellos y muestro mis fallos, entonces paso de ser una estrella a ser una mierda. Es la caída desde la alta expectativa. ¡ni una cosa ni otra!

No debemos evaluar a las personas por lo que dicen de ellas, los rumores son perversiones de la realidad. Me gustaría que me reconociesen por mi trabajo, por las ganas que le pongo y por tratar de mejorar, sobre todo cuando me equivoco. No que me tomen por lo que no soy cuando me conocen y luego me infravaloren cuando digo que soy como cualquier otro, que sólo trato de vivir la vida como voy entendiendo que quiero y puedo hacerlo. Escribo y hablo en público porque me gusta compartir, porque donde yo vivo no hay trabajo para que me quede quieto en casa. Si quiero hacer lo que me gusta tengo que moverme, ser activo. Ser un famosillo no es el objetivo, no debería serlo para nadie con mas de 15 años. Creer en famosillos tampoco. Cree en tí mismo.

Ultimamente está habiendo un movimiento curioso en la comunidad Agile-Spain y con el tema de la artesanía, que parece resaltar la figura del gurú todo-poderoso. Se piensa que determinadas personas son mágicas y aparecen fans por todas partes. Es un punto de vista erróneo (como siempre en mi opinion, que para eso es mi blog). El verdadero ideal de la artesanía del software es el de ser más profesionales, hacer mejor el trabajo, ponerle toda la atención posible y mejorar constantemente.
Paradójicamente, las técnicas ágiles se han inventado para hacer frente a nuestras limitadas cualidades intelectuales mediante disciplina, potenciando el trabajo en equipo, la participación. Y alguna gente anda pensando que se trata de seguir a un tío que sabe más que nadie y que tiene una barita mágica para iluminarnos. Wrong!

Tenemos que madurar y dejar de creer en cuentos. A mayor expectativa, mayor decepción. Lo que estamos persiguiendo es la excelencia técnica a través de la motivación de las personas, con ayuda de la comprensión, la empatía, la paciencia, constancia y el sentido común. La figura del “crack” no me pega para nada con las metodologías ágiles. Paradójicamente algunos se lo creen.

Alguna gente me dice que si sigo diciendo que soy normal y corriente perderé la fama de mito. ¡ojala! lo que quiero es ser reconocido como profesional, como currante, con ganas y buena voluntad. No me voy a cansar de repetir de que estoy continuamente aprendiendo y que me sigo metiendo buenas cagadas con desarrollos y con tantas otras cosas. Gracias a los métodos ágiles, cada vez voy equivocandome antes y así, readaptando y mejorando. Eso es la agilidad en mi opinion.

Los que están en esa posición de ser admirados deberían utilizarla para ayudar a los demás a sentirse más felices consigo mismos, con su vida profesional e incluso personal. Es cómodo acostumbrarse a los halagos y vivir en la nube, pero es engordar el ego para bien de nadie. Cuando te mueras, no te vas a llevar nada de eso. Quedará de tí lo que dejases en los demás.

Desgraciadamente parece que esta idea de que el desconocido y el extranjero son más que uno, es muy española. Como digo, lo peor es luego el efecto rebote. Cuando voy a trabajar como mentor y coach a las empresas, el efecto es muchísimo mayor cuando les han hablado bien de mí. Cuando entro por la puerta y me han vendido como una estrella, la gente escucha atentamente lo que digo y me hacen caso sin conocerme de nada. Si me conocen no me valoran. En un sitio donde nunca me han visto como Huesca, hacemos un dojo y se llena hasta la bandera. En Canarias les digo a los amigos del grupo que les doy un curso de TDD gratis y pasan del tema. Total como ya echamos las birras juntos… (ojo, no digo que mis amigos del grupo agile-canarias no me tengan estima).
Por exceso o por defecto, no hay una correspondencia con como creo que debería de ser. Hay que intentar aprender de todos, aprovechar lo bueno de cualquiera, y cuando alguien te presta ayuda, ser agradecido. Sea famoso, o sea tu peluquero.

Las personas de agile-spain con las que mejor me llevo son las que me han tratado exactamente igual antes de conocerme que despues de jartarnos de birras juntos o de ver código malo mío. Intentamos aprender unos de otros sin envidias ni exaltaciones.

La naturaleza de nuestro ego es querer sentirse distinto y especial, es humano. Por es la gente está orgullosa de pertenecer a una comunidad como agile-spain, porque creen que eso les convierte en algo diferente hacia mejor. Sin embargo, no veo nada distinto en agile-spain a lo que veía hace 10 años en las comunidades de usuarios de linux. Algunos buenos profesionales y algunos que necesitan madurar algo más que otros. Por esto la palabra “agile” suena mal en algunos ambientes, porque ha pasado a ser dogma (bueno, también porque la han usado pero luego no tenían ni idea de “agile”). Estar en la comunidad agile-spain no te hace mejor profesional. Demuestralo con tu trabajo, demuestralo siendo mejor compañero.
Cuando hablo con un cliente que no ha oído nada de “agile”, no voy diciendole “agile”, “scrum”, “tdd”… le hablo de valores. De entregas tempranas e iterativas. De colaboración, de valor, de satisfacción para el cliente.

Nos pasamos la vida comparando a los demás con uno,… “más listo”, “más tonto”, “más guapo”, “más feo”… cuando en realidad no hay mejor sensación que la de ver que los otros son capaces de sentir como uno, y viceversa. Sentir que somos iguales.

Para que las metodologías ágiles o cualquier otras pongan a nuestra profesión en el lugar que merece, tenemos que madurar nosotros primero. Dejarnos de pajas mentales y trabajar duro. En equipo, con humildad, con ilusión, sin límites mentales.

Definiendo el estado del servicio [traducción]

Introducción

Esta traducción es un pequeño fragmento del libro “Professional Microsoft Robotics Developer Studio” que he leído. Corresponde al capítulo 3 de dicho libro, Decentralized Software Services. El servicio es el bloque de construcción básico de MRDS, espero que esta pequeña traducción ayude a comprender mejor esta magnifica herramienta de Microsoft.

Traducción

El concepto de estado de servicio implica que debería contener toda la información necesaria para permitir salvar el estado, reiniciar el servicio posteriormente y cargando el estado salvado, continuar con la ejecución donde el servicio se apagó. El estado del servicio está disponible vía las operaciones Get y HttpGet. La operación Get está pensada para ser usada de manera programática, mientras que HttpGet está pensada con propósitos humanos, viendo el estado observando un navegador web.

La forma más simple, es mostrar el estado como un XML. Además, se puede iniciar el servicio sin necesidad de programar un interfaz de usuario. […]

[…]los siguientes pasos sirven para definir el estado de un servicio:

  1. Abres ServiceB en Visual Studio, dentro de éste el archivo llamado ServiceBTypes.cs.
  2. Baja el puntero hasta el estado del servicio y añade dos líneas como se puede ver aquí:

/// < summary >
/// The ServiceB State
/// < /summary >
[DataContract()]
public class ServiceBState
{
	[DataMember]
	public int Interval; 	// definido como público y
	[DataMember] // decorado con el atributo DataMember
	public int SensorValue;
}

 

Estos campos son parte del contrato del servicio y pueden ser serializados (a XML)cuando el estado es salvado o enviado en un mensaje.Si se declaran como privados serán ignorados durante la serialización.

Los puristas prefieren realizar una declaración como la siguiente:

private int _interval;

[DataMember]
public int Interval
{
	get { return _interval; }
	set { _interval = value; }
}

 

Debemos tener en cuenta que el atributo [DisplayName] únicamente puede ser aplicado a una propiedad no a un campo público.

3. Ahora el estado para el ServiceB contiene algunos campos, volvemos a ServiceB y rectificamos la función MainLoop como se muestra:

// Global flag to allow terminating the Main Loop
private bool _shutdown = false;

private IEnumerator < ITask > MainLoop()
{
	Random r = new Random();
	while (!_shutdown)
	{
		// Generate a random number from 0-100 and save it in the state
		_state.SensorValue = r.Next(100);
		Console.WriteLine(“B: “ + _state.SensorValue);
		// Wait a while
		yield return Arbiter.Receive(
			false,
			TimeoutPort(_state.Interval),
			delegate(DateTime time)
			{ }
		);
	}
}

 

Los cambios son como siguen:

  • Hemos añadido una bandera llamada _shutdown.
  • El bucle while ahora usa dicha bandera y puede finalizar.
  • Los valores aleatorios pueden almacenarse la propiedad state SensorValue.
  • El el intervalo del timer es leído desde la propiedad state Interval.

[…]

A %d blogueros les gusta esto: