Motivación o imposición

Es una cuestión que lleva muchos días dándome vueltas en la cabeza...

Los tiempos que corren son tremendamente competitivos, donde los márgenes son ajustados, los plazos cortos y la exigencia de calidad y funcionalidad es muy alta. Es por ello que a todo responsable de equipos o proyectos le exigen más eficiencia y por lo tanto un aumento de la productividad.
Pero mi pregunta es... ¿cómo?
Por otro lado tenemos, de forma general, gente menos motivada, faltos de ilusión y como consecuencia, faltos de compromiso. Personalmente percibo en mis compañeros de trabajo (algunos ya son ex compañeros) que este año pasado, no han recibido el reconocimiento que esperaban... ¿tenemos falsas expectativas?, ¿nos valoran de manera objetiva y justa?, es evidente que la situación económica de las empresas, condiciona las valoraciones y las mejoras retributivas al personal...entonces...¿es realmente justo? ¿Es justo que se estanquen o deceleren las carreras profesionales por causas ajenas a tu actividad laboral?, no obstante creo que es algo que debemos intentar comprender y saber razonar.

¿Mejorar la productividad? Ummm, no dejo de darlo vueltas... pero la pregunta sigue siendo: ¿cómo? ... seguro que tiene que haber alguna fórmula...
El caso es que mi jefe me dijo hace unos días: "Este año tenemos que mejorar la productividad de los equipos un 10%" y el eco resuena en mi cabeza "diezporciento, zporciento, ciento, ento, ento..."
Eso se traduce en que cada miembro de cada equipo tiene que ser más productivo en su especialidad (el programador, el analista, el tester, el diseñador...), es decir que tienen que hacer el mismo trabajo pero un 10% más rápido, por lo tanto tenemos que terminar la ejecución de las tareas cuando estas lleguen al 90% de la estimación.

foreach persona in equipos.personas
{
persona.productividad += 10%;
}
Ojala tratar con personas fuese tan fácil como tratar con máquinas...
Para construir software tenemos: Personas, Herramientas y Procesos.
Y el objetivo es hacer software en plazo, funcionalidad y con un coste de un 10% menos.
(Cómo veis he colocado a los individuos y su interacción por encima de los procesos y herramientas)... Es que desde hace algún tiempo hago unos estiramientos todas las mañanas y me estoy volviendo muy ágil.
Las herramientas son las que nos proporciona el mercado, unas mejoras, otras peores, más productivas, menos... son las que son y están las que están, y ¡creedme! No se ha incrementado tanto la productividad como aseguraban las campañas de marketing con cada versión de Visual Studio.
Los procesos los define tu metodología de desarrollo y están muy depuradas y optimizadas, solo tenemos que seleccionar una e incorporar esos procesos.
Yo creo que la clave está en las personas... Hace tiempo leí que para ser ágil había que serlo con las personas adecuadas http://www.elraul.com/?p=812 ¡Y estoy de acuerdo!
Pero es evidente que el Racing de Santander no puede prescindir de todos sus jugadores y contratar a los Ronaldinhos de turno. ¡Hay que mejorar la productividad de la gente que tienes! (salvo excepciones)
Pero mi pregunta es... ¿cómo? ¿Motivación o imposición?
 Yo tengo muy clara esta disyuntiva, creo que la motivación es el mejor remedio para aumentar la productividad. Mi opinión es que de la imposición obtienes beneficios instantáneos, pero la productividad desciende de manera exponencial en el tiempo. Esta conclusión es a la que llego, haciendo memoria y examen de conciencia, al experimentar estas dos técnicas sobre mi propio trabajo. Mi experiencia profesional ha sido mas enriquecedora, creativa y productiva cuando mas motivado me he encontrado, cuando he percibido un alto nivel de confianza y la presión ha sido la justa y necesaria. Por otro lado, cuando he recibido imposición, he intuido desconfianza y eso ha implicado desmotivación. Entiendo que no todas las personas somos iguales, ni reaccionamos de la misma forma a los agentes externos, pero sí creo que para profesiones que requieren un alto grado de pericia, creatividad y concentración es muy necesario sentirse motivado.
¿Todavía sigues leyendo? ... ¡qué bien! Porque hasta ahora no he dicho nada interesante, pero ahora viene mi propuesta para combatir la baja productividad.
¿Qué factores mejoran la motivación?

En realidad no he conseguido realizar una ordenación que me satisfaga, así que lo dejaré así tal y como se ve en la pirámide y espero que me hagas un comentario con el orden que estimes e incluyas alguno que falte, ya que esto es algo muy personal.


Todos estos factores hay que cruzarlos con el índice de motividad (lo acabo de buscar en google y no sale nada así que me apropio el término y el copyright ;)), que no es más que la capacidad y facilidad que tiene una persona para ser motivada, generalmente ausente en personas negativas. Además los seres humanos seguimos un axioma que define nuestro comportamiento y es que se basa en estados de ánimo, es por ello que este factor también influye de forma considerable.
Pues bien, ahora viene mi estrategia para conseguir mejorar la productividad del 10% el equipo:
  • Interés en el proyecto: Tenemos que intentar conseguir proyectos interesantes y asignarlos a las personas menos motivadas y con un índice de motividad alto. Es necesario que lo vean como una oportunidad para expresar su capacidad. Por supuesto esto varía dependiendo de los intereses de cada uno, por eso es importante conocer a las personas, averiguar sus intereses y tener comunicación continua.
  • Formación y conocimiento recibido: Es muy importante que la gente se forme en cursos o de compañeros de más nivel y aprenda nuevas tecnologías y técnicas de desarrollo. Creo que este aspecto nos diferencia de otras profesiones, la necesidad imperiosa del reciclaje tecnológico.
  • Ambiente de trabajo: Para mejorar el ambiente de trabajo es necesario transmitir cercanía, cordialidad y compañerismo, no excederse en la presión, promover la justicia entre compañeros y evitar las rivalidades y enfrentamientos. En definitiva tratar de crear un grupo de compañeros que tengan un objetivo común y velen por su cumplimiento de una forma agradable.
  • Salario percibido: Esto es lo más complicado pero creo que dentro de nuestras posibilidades tenemos que intentar ser justos y evidenciar y notificar las injusticias en este aspecto.
  • Responsabilidad y confianza: Dar responsabilidad a alguien denota confianza y por lo tanto es una compensación y una expresión de un trabajo previo bien hecho.
  • Horario flexible: La diferencia entre un trabajo manufacturero y uno artístico, como es la construcción de software, reside en el número de decisiones que se toman por unidad de tiempo, y para tomar esas decisiones de la manera más eficiente debemos tener un estado mental de alta concentración, es por ello que aunque sí es bueno que tengamos un horario marco de trabajo, no debamos ceñirnos a él, al son de una bocina.
  • Evolución profesional: Es importante generar perspectivas de crecimiento profesional en las personas, mantener un cierto grado de ilusión, por una progresión, que, aunque no sea inmediata es algo que se valora a la hora de elegir un empleo y creo que también influye en la motivación, al menos a mi me influye. También es importante para tu propio crecimiento, que el equipo crezca contigo.
Es evidente que no solo basta con estas medidas, pero si me parece que son las mas destacables. Y si, además de estas medidas personales las complementamos y  trabajamos de una manera mas efectiva la faceta comercial e intentamos desarrollar de manera estandarizada, es decir orientarlo a productos o al repeat business seguro que vamos a mejorar aún mas la productividad.
En resumen, ¡motivación! ¡motivación! y ¡motivación! es la mejor gasolina para mover el motor de la creatividad y productividad.
Me satisface enormemente que hayas llegado al final de la lectura... ahora me gustaría saber tu opinión.
¿estás de acuerdo con este planteamiento?

Tomado de...
martes, marzo 22, 2011
Posted by Carlos
viernes, marzo 11, 2011
Posted by Carlos

Internet Information Server (IIS) Express y Visual Studio 2010 SP1

jueves, marzo 10, 2011
Posted by Carlos

Anuncio de Entity Framework Code-First (CTP5 Release)

miércoles, marzo 09, 2011
Posted by Carlos

WHERE IN con LINQ

 //Si usamos Linq2SQL usar   
 NorthwindDataContext nc = new NorthwindDataContext();   
 NorthwindEntities ne = new NorthwindEntities();   
 var suppliers = from s in ne.Suppliers   
       where (s.CompanyName.StartsWith("E"))   
       select s.SupplierID;   
 int[] supplierIDs = suppliers.ToArray();   
 var products = from p in ne.Products   
       where (supplierIDs.Contains((int)p.SupplierID))   
       select p;   
Posted by Carlos
Tag :

XNA Pong game

Muy simple y solo como ejemplo de la primera aplicación que hice.

Crear el proyecto

NewProject

Crear los sprites con los que se jugara, muy simples ya que solo están como ejemplo:

Sprites

Crear la clase que manejara a los jugadores: Paddle

  1. /// <summary>
  2. /// Creata una paleta
  3. /// </summary>
  4. class Paddle
  5. {
  6.     /// <summary>
  7.     /// Variable con la posicion
  8.     /// </summary>
  9.     public Point pos;
  10.  
  11.     /// <summary>
  12.     /// Velocidad de la paleta
  13.     /// </summary>
  14.     public int speed;
  15.  
  16.     /// <summary>
  17.     /// Constructor
  18.     /// </summary>
  19.     /// <param name="x"></param>
  20.     /// <param name="y"></param>
  21.     public Paddle(int x, int y)
  22.     {
  23.         /// La paleta inicia en la posicion que se le pase al constructor
  24.         pos = new Point(x, y);
  25.         /// Velocidad por defecto
  26.         speed = 3;
  27.     }
  28. }

Crear la clase que maneja el objeto : Ball

  1. /// <summary>
  2. /// Creaa un objeto con la pelota
  3. /// </summary>
  4. class Ball
  5. {
  6.     /// <summary>
  7.     /// Posicion de la pelota
  8.     /// </summary>
  9.     public Point pos;
  10.     /// <summary>
  11.     /// Velocidad horizontal y vertical
  12.     /// </summary>
  13.     public int h_speed, v_speed;
  14.  
  15.     /// <summary>
  16.     /// Constructor
  17.     /// </summary>
  18.     /// <param name="x"></param>
  19.     /// <param name="y"></param>
  20.     public Ball(int x, int y)
  21.     {
  22.         /// La posicion inicial de la pelota se le pasa al constructor
  23.         pos = new Point(x, y);
  24.         /// La velocidad inicial y la direccion es randomica
  25.         Random rand = new Random();
  26.         h_speed = rand.Next(3, 7);
  27.         if (rand.Next(0, 2) == 0) h_speed *= -1;
  28.         rand = new Random();
  29.         v_speed = rand.Next(3, 7);
  30.         if (rand.Next(0, 2) == 0) v_speed *= -1;
  31.             
  32.     }
  33. }

En la clase Game1.cs, crear variables que contengan a los “jugadores” y la pelota, además una variable que maneje generación de valores randomicos y una con el estado del teclado.

  1. GraphicsDeviceManager graphics;
  2. SpriteBatch spriteBatch;
  3. Texture2D t_paddle1, t_paddle2, t_ball;
  4. Paddle paddle1;
  5. Paddle paddle2;
  6. Ball ball;
  7. Random rand = new Random();
  8. KeyboardState currentState;

Crear un método que inicializa las posiciones de los Sprites en el juego, se llama ResetGame, e  incluimos una llamada desde el constructor:

  1. /// <summary>
  2. /// Allows the game to perform any initialization it needs to before starting to run.
  3. /// This is where it can query for any required services and load any non-graphic
  4. /// related content.  Calling base.Initialize will enumerate through any components
  5. /// and initialize them as well.
  6. /// </summary>
  7. protected override void Initialize()
  8. {
  9.     // TODO: Add your initialization logic
  10.     base.Initialize();
  11.  
  12.     ResetGame();
  13. }
  14.  
  15. /// <summary>
  16. /// Inicializa los valores del juego
  17. /// </summary>
  18. void ResetGame()
  19. {
  20.     paddle1 = new Paddle(10, 200);
  21.     paddle2 = new Paddle(770, 200);
  22.     ball = new Ball(385, 285);
  23. }

 

En el método LoadContent, que se ha generado automáticamente agregamos la carga de nuestros Sprites:

  1. /// <summary>
  2. /// LoadContent will be called once per game and is the place to load
  3. /// all of your content.
  4. /// </summary>
  5. protected override void LoadContent()
  6. {
  7.     // Create a new SpriteBatch, which can be used to draw textures.
  8.     spriteBatch = new SpriteBatch(GraphicsDevice);
  9.  
  10.     // TODO: use this.Content to load your game content here
  11.     t_paddle1 = Content.Load<Texture2D>("paddle");
  12.     t_paddle2 = Content.Load<Texture2D>("paddle");
  13.     t_ball = Content.Load<Texture2D>("ball");
  14.  
  15. }

En el método Draw, agregamos:

  1. /// <summary>
  2. /// This is called when the game should draw itself.
  3. /// </summary>
  4. /// <param name="gameTime">Provides a snapshot of timing values.</param>
  5. protected override void Draw(GameTime gameTime)
  6. {
  7.     GraphicsDevice.Clear(Color.CornflowerBlue);
  8.  
  9.     // TODO: Add your drawing code here
  10.     spriteBatch.Begin();
  11.     spriteBatch.Draw(t_paddle1, new Rectangle(paddle1.pos.X, paddle1.pos.Y, t_paddle1.Width, t_paddle1.Height), Color.CornflowerBlue);
  12.     spriteBatch.Draw(t_paddle2, new Rectangle(paddle2.pos.X, paddle2.pos.Y, t_paddle2.Width, t_paddle2.Height), Color.CornflowerBlue);
  13.     spriteBatch.Draw(t_ball, new Rectangle(ball.pos.X, ball.pos.Y, t_ball.Width, t_ball.Height), Color.CornflowerBlue);
  14.     spriteBatch.End();
  15.  
  16.     base.Draw(gameTime);
  17. }

Si se compila y ejecuta en este momento, tenemos el siguiente resultado:

InitGame

Movimientos Humano y Computadora, Detección de colisiones

Dado que se jugara HumanoVsComputadora, lo primero que se hace es capturar la entrada de teclado y actualizar el movimiento de la paleta del Humano, además validamos que no salgamos de los límites de la ventana, esto lo hacemos desde un nuevo método, UpdatePaddles:

  1. void UpdatePaddles()
  2. {
  3.     /// Capturamos las pulsaciones del teclado
  4.     currentState = Keyboard.GetState();
  5.     Keys[] currentKeys = currentState.GetPressedKeys();
  6.     /// Solo hacer caso de las teclas que requerimos
  7.     foreach (Keys key in currentKeys)
  8.     {
  9.         if (key == Keys.Up)
  10.             paddle1.pos.Y -= paddle1.speed;
  11.         if (key == Keys.Down)
  12.             paddle1.pos.Y += paddle1.speed;
  13.         if (key == Keys.Escape)
  14.             this.Exit();
  15.     }
  16.     /// Varificar que no salimos de la ventana
  17.     if (paddle1.pos.Y <= 10) paddle1.pos.Y = 10;
  18.     if (paddle2.pos.Y <= 10) paddle2.pos.Y = 10;
  19.     if (paddle1.pos.Y + t_paddle1.Height >= Window.ClientBounds.Height - 10)
  20.         paddle1.pos.Y = Window.ClientBounds.Height - t_paddle1.Height - 10;            
  21.     if (paddle2.pos.Y + t_paddle2.Height >= Window.ClientBounds.Height - 10)
  22.             paddle2.pos.Y = Window.ClientBounds.Height - t_paddle2.Height - 10;
  23. }

La “inteligencia” de la computadora, se reduce a que su paleta sigue la posición Vertical de la pelota, por lo que el anterior método quedaría así:

  1. void UpdatePaddles()
  2. {
  3.     /// Capturamos las pulsaciones del teclado
  4.     currentState = Keyboard.GetState();
  5.     Keys[] currentKeys = currentState.GetPressedKeys();
  6.     /// Solo hacer caso de las teclas que requerimos
  7.     foreach (Keys key in currentKeys)
  8.     {
  9.         if (key == Keys.Up)
  10.             paddle1.pos.Y -= paddle1.speed;
  11.         if (key == Keys.Down)
  12.             paddle1.pos.Y += paddle1.speed;
  13.         if (key == Keys.Escape)
  14.             this.Exit();
  15.     }
  16.     /// La paleta de la computadora solo sigue a la pelota
  17.     paddle2.speed = ball.h_speed;
  18.     if (paddle2.pos.Y + (t_paddle2.Height / 2) > ball.pos.Y)
  19.         paddle2.pos.Y -= paddle2.speed;
  20.     else if (paddle2.pos.Y + (t_paddle2.Height / 2) < ball.pos.Y)
  21.         paddle2.pos.Y += paddle2.speed;
  22.     /// Varificar que no salimos de la ventana
  23.     if (paddle1.pos.Y <= 10) paddle1.pos.Y = 10;
  24.     if (paddle2.pos.Y <= 10) paddle2.pos.Y = 10;
  25.     if (paddle1.pos.Y + t_paddle1.Height >= Window.ClientBounds.Height - 10)
  26.         paddle1.pos.Y = Window.ClientBounds.Height - t_paddle1.Height - 10;
  27.     if (paddle2.pos.Y + t_paddle2.Height >= Window.ClientBounds.Height - 10)
  28.         paddle2.pos.Y = Window.ClientBounds.Height - t_paddle2.Height - 10;
  29. }

Ahora se requiere mover la pelota, se lo hace desde un nuevo método UpdateBall:

  1. void UpdateBall()
  2. {
  3.     /// Actualiza la posicion de la pelota
  4.     ball.pos.X += ball.h_speed;
  5.     ball.pos.Y += ball.v_speed;
  6.  
  7.     /// Verificar limites
  8.     /// Inferior
  9.     if (ball.pos.Y > (Window.ClientBounds.Height - 10 - t_ball.Height))
  10.         ball.v_speed *= -1;
  11.     /// Superior
  12.     if (ball.pos.Y < 10)
  13.         ball.v_speed *= -1;
  14. }

Finalmente implementamos un “detector de colisiones”, que simplemente compara las posiciones de los Sprites de la pantalla, y según eso calcula la nueva dirección de la pelota, velocidad después de “golpearla” y si una de las paletas no ha alcanzado a golpear la bola, en cuyo caso el juego comienza de nuevo, llamando al método ResetGame:

  1. void CheckCollisions()
  2. {
  3.     /// Verificar si la pelota esta yendo a la izquierda
  4.     if (ball.h_speed < 0)
  5.     {
  6.         /// Verifica si la pelota a rebasado la paleta
  7.         if (ball.pos.X < paddle1.pos.X + 20)
  8.         {
  9.             /// Si la pelota no fue golpeada, fin del juego
  10.             if ((ball.pos.Y + t_ball.Height < paddle1.pos.Y) || (ball.pos.Y > paddle1.pos.Y + t_paddle1.Height))
  11.             {
  12.                 ResetGame();
  13.             }
  14.             else
  15.             {
  16.                 /// Se golpea la pelota, se cambia su direccion
  17.                 /// y se le da una velocidad inicial randomica, entre 3 y 7
  18.                 if (ball.h_speed < 0)
  19.                     ball.h_speed = rand.Next(3, 7);
  20.                 else ball.h_speed = rand.Next(-6, -2);
  21.  
  22.                 if (ball.v_speed < 0)
  23.                     ball.v_speed = rand.Next(3, 7);
  24.                 else ball.v_speed = rand.Next(-6, -2);
  25.             }
  26.         }
  27.     }
  28.     else
  29.     {
  30.         /// Verifica si la pelota a rebasado la paleta
  31.         if (ball.pos.X + t_ball.Width > paddle2.pos.X)
  32.         {
  33.             /// Si la pelota no fue golpeada, fin del juego
  34.             if ((ball.pos.Y + t_ball.Height < paddle2.pos.Y) || (ball.pos.Y > paddle2.pos.Y + t_paddle2.Height))
  35.             {
  36.                 ResetGame();
  37.             }
  38.             else
  39.             {
  40.                 /// Se golpea la pelota, se cambia su direccion
  41.                 /// y se le da una velocidad inicial randomica, entre 3 y 7
  42.                 if (ball.h_speed < 0)
  43.                     ball.h_speed = rand.Next(3, 7);
  44.                 else ball.h_speed = rand.Next(-6, -2);
  45.  
  46.                 if (ball.v_speed < 0)
  47.                     ball.v_speed = rand.Next(3, 7);
  48.                 else ball.v_speed = rand.Next(-6, -2);
  49.             }
  50.         }
  51.     }
  52. }

Implementamos la lógica de actualización del juego, desde le método Update:

  1. /// <summary>
  2. /// Allows the game to run logic such as updating the world,
  3. /// checking for collisions, gathering input, and playing audio.
  4. /// </summary>
  5. /// <param name="gameTime">Provides a snapshot of timing values.</param>
  6. protected override void Update(GameTime gameTime)
  7. {
  8.     // Allows the game to exit
  9.     if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
  10.         this.Exit();
  11.  
  12.     // TODO: Add your update logic here
  13.     UpdatePaddles();
  14.     UpdateBall();
  15.     CheckCollisions();
  16.  
  17.     base.Update(gameTime);
  18. }

F5 y a jugar!

Los fuentes, aquí:

domingo, marzo 06, 2011
Posted by Carlos
Tag :

Proveedor Oracle para EntityFramework

Posted by Carlos
Tag :

Instaladores de PEX

Posted by Carlos

Importar archivos de texto con LINQ

Tenemos un archivo con 3 columnas y un Total que es producto de la segunda por la tercera, el archivo esta delimitado por comas:
Zanahorias, 5,0 .50
Naranjas, 6, 1.25
Manzanas, 7, 2.50
Usamos un método que recorra el archivo y nos devuelva las líneas, en un IEnumerable<String>:
  1: public static IEnumerable<string> ReadLinesFromFile(string filename)
  2: {
  3:     using (StreamReader reader = new StreamReader(filename))
  4:     {
  5:         while (true)
  6:         {
  7:             string s = reader.ReadLine();
  8:             if (s == null)
  9:                 break;
 10:             yield return s;
 11:         }
 12:     }
 13: }

Hacemos la consulta LINQ usando este resultado como fuente de datos:
  1: var products = from line in ReadLinesFromFile(@"c:\import.txt")
  2:                let item = line.Split(’,’)
  3:                select new
  4:                {
  5:                    Producto = item[0],
  6:                    Cantidad = Convert.ToInt32(item[1]),
  7:                    Precio = Convert.ToDecimal(item[2]),
  8:                    Total = Convert.ToInt32(item[1]) * Convert.ToDecimal(item[2])
  9:                };

Y finalmente pasamos el resultado a un DataGrid:

  1: GridView1.DataSource = products;
  2: GridView1.DataBind();
viernes, marzo 04, 2011
Posted by Carlos
Tag :

Hola mundo con Smart Client Software Factory

  1. Crear un nuevo proyecto de aplicación de Smart Client
  2. En Visual Studio 2010, seleccione Nuevo en el menú Archivo y, a continuación, haga clic en Project.
    1. En el cuadro de diálogo New Project Smart Client Development.
    2. Seleccione la aplicación Smart Client (C #) Visual Studio template.
    3. En el cuadro Nombre, escriba HelloWorldApplication, a continuación, haga clic en Aceptar.
    4. En el asistente, acepte la configuración predeterminada, seleccione Show documentation after recipe completes y a continuación, haga clic en Finish.
  3. Crear un módulo de Hello World
    1. En el Explorador de soluciones, haga clic en la solución, seleccione Smart Client Software Factory, a continuación, haga clic en Add Business Module (C#).
    2. En el cuadro de diálogo Agregar nuevo proyecto, HelloWorldModule en el cuadro Nombre.
      Haga clic en Aceptar.
    3. En el asistente, acepte la configuración predeterminada, seleccione Show documentation after recipe completes y a continuación, haga clic en Finish.
  4. Añadir la vista
    1. En el Explorador de soluciones, haga clic en HelloWorldModule, seleccione Smart Client Software Factory, a continuación, haga clic en Add View (with presenter).
    2. En el cuadro de diálogo Add View (with presenter), escriba HelloWorldView en el cuadro Ver, seleccione Show documentation after recipe completes y a continuación, haga clic en Finish.
    3. En el Explorador de soluciones, haga doble clic en el archivo HelloWorldView.cs para poder ver el Diseñador. Arrastre un cuadro de texto en la vista, y escribir Hola Mundo.
  5. Configurar HelloWorldView para mostrar la vista en el Shell
    1. En el Explorador de soluciones, abrir ModuleController.cs en el proyecto HelloWorldModule.
    2. Agregue el siguiente código .
    3. using HelloWorldApplication.Infrastructure.Interface.Constants;
    4.  En el método AddViews agregue el siguiente código.
    • HelloWorldView hwview = ShowViewInWorkspace< HelloWorldView >(WorkspaceNames.RightWorkspace);
  6. F5 compilar y ejecutar...

    jueves, marzo 03, 2011
    Posted by Carlos

    Como ganar siempre al jugar piedra,papel y tijeras


    1) Rock it – Muchos tienen la tendencia de hacer “Piedra” en su primera lanzada. Si están jugando contra una de estas personas, lancen papel.

    2) Tijeras revertidas – Jugadores experimentados tirarán papel (basándose en la primera regla). Tenemos que contrarrestarlos con Tijeras.

    3) Copycat – Jugadores con poca experiencia (o cansados) van a tirar subconscientemente la forma contra la que perdieron en la última ronda. Contrarrestar con su opuesto

    4) Dobles Rocas – Cuando vean a alguien lanzar dos rocas, sepan que el próximo lanzamiento será Tijeras o Papel. Las personas detestan ser predecibles y una firme indicación de ello es lanzar lo mismo tres veces. Contrarrestar con Piedra.

    5) Descubrimientos en los dedos – Cuando el oponente se prepara a lanzar, fijarse en los dedos cuidadosamente. Los dedos se tensarán o moverán de acuerdo a la forma del lanzamiento. Para Piedra, los dedos estarán tensos. Para papel, estarán sueltos y para Tijeras, sólo los dedos utilizados para la forma estarán sueltos.

    6) Papel por favor – El Papel es el menos usado en un match. Utilízenlo como una opción inesperada. El papel es sólo tirado el 29.6% del tiempo, mientras que la roca tiene un 35.4% y las tijeras, 35%.

    7) Preparación previa – Ver al oponente jugar contra otros. Tienen una forma favorita, o mantienen una plantilla a la hora de lanzar

    8 ) Spock & Roll – Cuando todo parezca perdido, vayan por el Spock. Es inesperado y altamente ilegal, pero también imposible de contrarrestar.
    martes, febrero 15, 2011
    Posted by Carlos

    Amistad

    Es lindo cuando un extraño se convierte en tu amigo, pero es triste cuando un amigo se convierte en un extraño... Yo NUNCA quiero perderte como amigo... Te conocí como un extraño, ahora te tengo como un amigo, espero encontrarte... en nuestro próximo camino donde la amistad jamas termina... Puede que no sea la persona mas importante en tu vida... Yo solo espero que cuando escuches mi nombre sonrías y digas: Ese es mi amigo!!!
    viernes, febrero 11, 2011
    Posted by Carlos
    Tag :
    martes, febrero 08, 2011
    Posted by Carlos

    Extender un IList para devolver un Datatable

     

    1. /// <summary>  
    2. /// Exiende un metodo sobre una Lista para devolver un Dataset  
    3. /// con las columnas del objeto de la lista  
    4. /// </summary>  
    5. /// <typeparam name="T"></typeparam>  
    6. /// <param name="pList"></param>  
    7. /// <returns></returns>  
    8. public static DataTable ConvertTo<T>( this IList<T> pList )  
    9. {  
    10.   DataTable table = CreateTable<T>();  
    11.   Type entityType = typeof( T );  
    12.   PropertyDescriptorCollection properties = TypeDescriptor.GetProperties( entityType );  
    13.   foreach ( T item in pList )  
    14.   {  
    15.        DataRow row = table.NewRow();  
    16.        foreach ( PropertyDescriptor prop in properties )  
    17.             row[prop.Name] = prop.GetValue( item );  
    18.        table.Rows.Add( row );  
    19.   }  
    20.   return table;  
    21. }  
    22. /// <summary>  
    23. /// Devuelve un item de tipo T  
    24. /// </summary>  
    25. /// <typeparam name="T"></typeparam>  
    26. /// <param name="pRow">The p row.</param>  
    27. /// <returns></returns>  
    28. private static T CreateItem<T>( DataRow pRow )  
    29. {  
    30.   T obj = default( T );  
    31.   if ( pRow == null )  
    32.        return obj;  
    33.   obj = Activator.CreateInstance<T>();  
    34.   foreach ( DataColumn column in pRow.Table.Columns )  
    35.   {  
    36.        PropertyInfo prop = obj.GetType().GetProperty( column.ColumnName );  
    37.        object value = pRow[column.ColumnName];  
    38.        prop.SetValue( obj, value, null );  
    39.   }  
    40.   return obj;  
    41. }  
    42. /// <summary>  
    43. /// Crea un DataTable con columnas del tipo T  
    44. /// </summary>  
    45. /// <typeparam name="T"></typeparam>  
    46. /// <returns></returns>  
    47. private static DataTable CreateTable<T>()  
    48. {  
    49.   Type entityType = typeof( T );  
    50.   DataTable table = new DataTable( entityType.Name );  
    51.   PropertyDescriptorCollection properties = TypeDescriptor.GetProperties( entityType );  
    52.   foreach ( PropertyDescriptor prop in properties )  
    53.        table.Columns.Add( prop.Name, prop.PropertyType );  
    54.   return table;  
    55. }
    lunes, febrero 07, 2011
    Posted by Carlos

    Extender un Datatable para devolver un IList

    Necesito pasar el contenido de un Datatable a un IList de tipo T, aprovechando la facilidad de extender clases, quedo así:

    1. /// <summary>  
    2. /// Extiende un metodo sobre el objeto Datatable para devolver un IList  
    3. /// </summary>  
    4. public static IList<T> ConvertTo<T>(this DataTable pDataTable) where T : new()
    5. {
    6.     PropertyInfo[] entityImportProperties = typeof(T).GetProperties();
    7.     IList<T> colEntityImportList = new List<T>();
    8.     if (pDataTable == null)
    9.         return null;
    10.     if (pDataTable.Rows.Count == 0)
    11.         return colEntityImportList;
    12.     foreach (DataRow actualRow in pDataTable.Rows)
    13.     {
    14.         T objNewImportEntity = new T();
    15.         foreach (PropertyInfo propertyEntityImport in entityImportProperties)
    16.             if (propertyEntityImport.CanRead)
    17.                 for (int i = 0; i <= pDataTable.Columns.Count - 1; i++)
    18.                     if (pDataTable.Columns[i].ColumnName == propertyEntityImport.Name)
    19.                         if (actualRow[propertyEntityImport.Name] == null)
    20.                         {
    21.                             if (actualRow[propertyEntityImport.Name] == DBNull.Value)
    22.                                 propertyEntityImport.SetValue(objNewImportEntity, null, null);
    23.                             else
    24.                                 propertyEntityImport.SetValue(objNewImportEntity, actualRow[propertyEntityImport.Name], null);
    25.                             break;
    26.                         }
    27.         colEntityImportList.Add(objNewImportEntity);
    28.     }
    29.     return colEntityImportList;
    30.  
    31.     DataTable vSystemModulesTable = SystemManager.GetDataTable();
    32.     IList<SystemModule> vColSystem = vSystemModulesTable.ConvertTo<SystemModule>();
    33. }

    Y se usa, de esta manera:

    1. DataTable vSystemModulesTable = SystemManager.GetDataTable();
    2. IList<SystemModule> vColSystem = vSystemModulesTable.ConvertTo<SystemModule>();
    martes, febrero 01, 2011
    Posted by Carlos

    MF.COM

    MF.COM...
    lunes, enero 31, 2011
    Posted by Carlos
    Tag :

    Full-Text Search

    Tenia la necesidad de buscar una cadena en un campo de tipo varchar, esto podría solucionarse con un simple:
    1: Select Name From Person Where Name Like '%Juan%Perez%'
    Pero el problema radica en que el patrón de la cadena de búsqueda no necesariamente tiene un orden predefinido, por lo que podría requerir buscar:
    Juan Perez, Perez Juan, Juan Jose Perez, Jose Perez, etc.
    Como solución lo primero que hice fué crear el catalogo de busquedas:

    Podría dar un error si no esta habilitada la funcionalidad, si esto sucede ejecutar el SP

    1. sp_fulltext_database 'enable'

    1: CREATE FULLTEXT CATALOG PersonNameFTS
    Luego, se crea un índice :
    1: CREATE FULLTEXT INDEX ON Customer.tPerson(Name)
    
    2:   KEY INDEX PK__tPerson__7058F441 ON PersonNameFTS
    
    3:   WITH CHANGE_TRACKING AUTO
    Y finalmente las consultas funcionan:
    1: SELECT t.IdPerson, t.NAME, t.IdentityCardNumber FROM Person t
    
    2:    WHERE CONTAINS ( t.[Name] ,'JUAN AND JOSE AND PEREZ')
    
    3: SELECT t.IdPerson, t.NAME, t.IdentityCardNumber FROM Person t
    
    4:    WHERE CONTAINS ( t.[Name] ,'PEREZ AND JOSE AND JUAN')
    Posted by Carlos

    Crisis de los vídeo juegos

    El siguiente articulo fue tomado de Wikipedia ya que al parecer sera borrado de ahí. Al ser muy interesante opte por copiarlo aquí.


    La Crisis del videojuego de 1983 fue un suceso que marcó el mundo de los videojuegos para siempre y poniendo en riesgo la existencia de estos hasta llevarlos al punto de casi desaparecer.

    Ocurrió a finales de 1983 e inicios de 1984 seguidos de 3 largos años de "oscuridad" donde la actividad de los videojuegos se redujo a las consolas vendidas y que funcionaban en los hogares de todo el mundo. Cientos de juegos se cancelaron en 1983 y los que lograron alcanzar las tiendas se hundieron al fracasar.

    A principios de los años 1980 se empieza a detectar la primera crisis, que afectó sobre todo al sector de empresas derivadas de los juegos tipo arcade. Una de las causas fue la abundancia de consolas de videojuegos y microordenadores, los clientes optaban por comprar los juegos originales y piratas antes que derrochar el dinero en los recreativos.

    Las empresas respondieron con la creación de sus propias consolas o desarrollando para las existentes.

    La segunda decisión fue la de mejorar las máquinas recreativas añadiéndole una nueva forma de jugar, en vez de jugar con un joystick el jugador lo hacía más real mentiendose en un coche o montándose en una moto que mediante unos sensores representaba en el juego los giros, la aceleración, etc.

    Fue entonces cuando se abandonó la primera crisis del videojuego y las máquinas recreativas tomaron otro plano respecto de los usuarios y fueron avanzando según las nuevas tecnologías

    Causas

    • La extensa cobertura y exageración de los medios de comunicación que hablaban de un "fracaso total", lo que provocó un desinterés repentino y salió la creencia de muchos videojugadores diciendo que los videojuegos solo fueron una moda.
    • La agresiva propaganda de la Commodore 64, una computadora personal que decía: "Por qué comprarle a tus hijos un videojuego y distraerlos de la escuela cuando puedes adquirir para él una computadora personal que los prepara para el colegio"
    • El fracaso de los dos escasamente aceptados juegos que estropearon la entonces exitosa Atari 2600.
    • La falta de profesionalidad de los medios de comunicación. Incluso al tratarse de periódicos como el New York Times, lo cierto es que la capacidad de un reportero para informar sobre videjuegos era muy escasa.
    • Ningún juego tenía derechos de autor. Uno podía hallar en una consola una versión muy buena del Pac-Man, y días después se llevaría un engaño absoluto al probar el juego en una Atari 2600.
    • Sobresaturación del mercado. Viendo un potente mercado naciente, varias compañías como Mattel lanzaron consolas y videojuegos mediocres. Ni la industria pornográfica se quedó atrás lanzando el controvertido "Custer's Revenge"

    Atari: Pac-Man y E.T.

    Pacman

    Una ironía de la vida, pero el más recordado personaje de los videojuegos, junto con Mario Bros., puso en peligro los videojuegos como los conocemos. Es cierto, los de Atari quisieron pasar al éxito de su base original (Las arcade) a su consola exitosa y se apoyaban en esta fórmula: Videojuego más vendido + consola más exitosa = muchas ganancias.

    Pero el juego salió a la venta como producto final sin haber sido testeado y el resultado fue un desastre: pésimos gráficos, control defectuso y de los 4 fantasmas uno era de color estable y los otros 3 parpadeaban dándole al jugador la impresión de que solo había un fantasma.

    Habían algunas explicaciones: la pantalla era horizontal y no vertical, algo obvio porque hablamos de televisores. Pero el problema surgía al ver los gráficos: los puntos eran rayas, colores malos, los fantasmas parpadeaban y Pac-Man solo veía a izquierda y derecha. Ni al bajar o subir miraba abajo.

    E.T.

    El juego está considerado uno de los peores de la historia. Se acercaba Navidad y para tener ventas disparadas los de Atari decidieron sacar un nuevo juego, estaba diseñado por Howard Scott Warshaw (Creador de un gran título llamado "Hit Yar's Revenge".El tiempo de elaboración fue el ridículo récord de 6 semanas y se le estimaron como al Pac-Man Atari grandes ventas, y aunque se vendió bien hubo una superproducción y quedaron bastantes en los almacenes. Se dice que los cartuchos sin vender fueron enterrados por Atari en un lugar remoto en Nuevo Mexico aunque esto ha sido desmentido por Atari.

    La trama era casi tan torpe como el juego en sí. Originalmente planearon hacer un juego estilo Pac-Man, pero será por su fracaso de Pac-Man anterior, o por las prisas, que lanzaron algo nuevo. Bien simple: E.T. debía encontrar tres pedazos de un teléfono espacial para llamar a su nave para que lo rescatara. Pero hubieron errores: los primeros glitches (De la nada salían hoyos), jugabilidad casi imposible y hasta cambios en los colores; E.T. era mostaza y no marrón, pese a que el color era posible en la Atari 2600.

    Reacciones inmediatas Como pasa frente a toda crisis, los efectos son inmediatos. Viendo el mercado saturado de consolas y de videojuegos, los gamers no sabían como distinguir un "buen" juego de un "mal" juego. La prensa "videojuegil" aún no había sido inventada.

    La prensa, por primera vez en la historia, hace que los videojuegos salgan en los periódicos de todo el mundo. Las noticias son lamentables: despidos, pérdidas millonarias, devoluciones. En unos días, lo que antes era un mercado naciente se convirtió en una crisis global. Los efectos más duros fueron en Estados Unidos, donde era fácilmente pirateable una consola. Japón no sufrió el impacto de la crisis hasta unos meses después, con la escasez de videojuegos los productores estadounidenses envían los títulos devueltos. Pese a todo, el mercado japonés soporta un poco más con las arcades, pero el negocio de las consolas se viene abajo. No es hasta 1983 que el mercado vuelve a nacer. Lo curioso, y lo inexplicable de toda la crisis, fue como un personaje cuyo oficio era ser fontanero, pudo salvar el mercado.

    La caída de Atari

    En 1983 se produce uno de los episodios más desconocidos y curiosos de la historia de los videojuegos. Mientras en Atari se trabajaba en el nuevo chip MARIA, que debía ser la base de la nueva generación de consolas, se recibe una carta de Minoru Arakawa, presidente de Nintendo, quien está interesado en entrar en el mercado de Estados Unidos con su nueva consola Famicom, por lo que invita a una representación de Atari a conocer a fondo su producto, en vistas de llegar a un acuerdo comercial. Los representantes de la compañía americana viajan a Kyoto en abril para ver una demostración unos meses antes de su lanzamiento en Japón, y prueban unas versiones beta de Donkey Kong Jr. y Popeye. La cúpula directiva de Atari de todos modos debate si seguir adelante con la propuesta de Nintendo, o esperar a que el chip MARIA esté listo para lanzar de nuevo una consola propia, ya que ambos chips parecen estar a la par en precio y capacidades. Se decide alargar las negociaciones lo máximo posible, hasta que la primera versión estable de MARIA esté acabada (a principios del verano). Así que a mediados del mes de mayo, una delegación de Atari se desplaza de nuevo a Kyoto para negociar un preacuerdo entre ambas compañías, por el que Atari fabricará y distribuirá mundialmente la consola, a cambio del pago de regalías a Nintendo. Atari adelantará 5 millones de dólares y se compromete a fabricar 2 millones de unidades en los cuatro años siguientes. Además Nintendo deberá producir 4 títulos según las exigencias de Atari para la campaña navideña.

    El acuerdo definitivo debe firmarse en junio en el Consumers Electronics Show de Las Vegas, pero en dicho evento todo se viene abajo cuando el presidente de Atari Ray Kassar presencia una demo del nuevo ordenador personal de Coleco, Adam, con una versión de Donkey Kong. Los derechos de dicho juego para ordenador eran propiedad de Atari, mientras Coleco solo tenía los derechos para versiones de consola. Kassar se enfurece con Nintendo, a quien acusa de estar haciendo doble juego, mientras Nintendo hace lo propio con Coleco, a quien acusa con llevar a juicio si no deja de usar inapropiadamente el juego.

    Tras la celebración del Consumers Electronic Show, Atari entra en una espiral de acontecimientos que hacen que ya nunca llegue a firmarse dicho acuerdo, y llevan a la compañía prácticamente a la bancarrota, lo que hizo que Nintendo acometiera su propia distribución años más tarde. En julio, Ray Kassar se ve obligado a dimitir de su puesto, junto con el vicepresidente Dan Groth, debido a la acusación de aprovechar información privilegiada para vender parte de sus acciones horas antes de anunciar los malos resultados del ejercicio de 1982, que provocaron una caída del valor de las mismas en un 40%, Kassar devolvió el dinero, y fue absuelto de las acusaciones, pero la presidencia de la compañía había cambiado ya de manos, y Kassar se retiró tras el escándalo a un segundo plano, sin volver a ocupar jamás ningún cargo directivo.

    La presidencia recae entonces en James J. Morgan, vicepresidente de Phillip Morris, quien se ve obligado a lidiar con la situación más delicada que la joven industria iba a padecer: la crisis de 1983 que desembocó en un cambio radical del mercado del videojuego tal y como se había conocido en los 5 años anteriores.

    El Fin de la Caída y el inicio de la 3º Generación

    La caída finalizó al salir al mercado el NES (Nintendo Entertainment System) que, con sus grandes títulos como Super Mario Bros, Metroid y The Legend of Zelda, atrajo mucha gente a la industria, revivió el interés, rompió la creencia de los videojuegos como una moda y abrió la 3º generación de videojuegos. Actualmente la NES se encuentra entre una de las consolas más apreciadas por los videojugadores, aunque todavía existen algunos afortunados que conservan una de las antiguas Atari.

    martes, diciembre 14, 2010
    Posted by Carlos

    Populares!

    - Copyright © - Oubliette - -Metrominimalist- Powered by Blogger - Designed by Johanes Djogan -