viernes, 29 de junio de 2012

Jugando un poco con Vala

Vala es un nuevo lenguaje de programación, que ha surgido en torno a Gnome, más documentación en Wikipedia, ¿dónde sino?

Me parecio interesante, porque es muy parecido a C#, y con toda la potencia de los lenguajes modernos, pero a parte sin las penalizaciones de una máquina virtual. Lo malo es que no es multiplataforma, pero creo que el objetivo de este lenguaje, es más bien, la velocidad y la productividad que dan los lenguajes modernos.

Para empezar con el típico ejemplo de Hello World
/*compile: $valac file_name.vala*/
/*execute: $./file_name*/

using GLib; 

public class test{

 public static int main (string[] args) 
 { 
  stdout.printf ("Hello World\n");
   return 0; 
 } 
} 
Hace tiempo vi un mini-tutorial, para empezar a escribir algo y aquí está el resultado.
/*compilying: $valac --pkg gtk+-2.0 file_name.vala*/
/*executing: $./file_name*/

using GLib; 
using Gtk;

public class test{

 public static int main (string[] args) 
 { 
  Gtk.init(ref args);
 
  var win = new MainWindow();
  win.show_all();
  
  Gtk.main();
   return 0; 
 } 
} 

public class MainWindow : Gtk.Window
{
 Gtk.Button btnOk; 
 public MainWindow()
 {
  this.destroy.connect(Gtk.main_quit);
  
  btnOk = new Gtk.Button();
  btnOk.label = "Press Me!";
  btnOk.clicked.connect(btnOk_clicked);
  this.add(btnOk);
 }

 private void btnOk_clicked()
 {
  stdout.printf("btnOk_clicked!!!\n");
 }
} 

Como se puede observar, está el concepto de eventos y delegados, como lo hay en otros lenguajes. El concepto es el mismo, simplemente cambia la sintáxis.
La ejecución del código.

.NET y NCurses

Quien haya visto lo de ncurses, habrá pensado que eso es de la época de las cavernas. Simplemente quería jugar un poco y probar como se relaciona .net con librerías externas a su propio sistema.

El ejemplo de código es para linux (GNU/Linux, para que no se enfade nadie), con la librería libncurses.so.5 instalada en el sistema.
using System;
using System.Runtime.InteropServices;

public class Curses {
 const string Library = "libncurses.so.5";

 [DllImport(Library)]
 private extern static IntPtr initscr( );

 [DllImport(Library)]
 private extern static int endwin( );

 [DllImport(Library)]
 private extern static int mvwprintw(IntPtr window,
 int y, int x, string message);

 [DllImport(Library)]
 private extern static int refresh(IntPtr window);

 [DllImport(Library)]
 private extern static int wgetch(IntPtr window);

 private IntPtr window;
 
 public Curses( ) 
 {
  window = initscr( );
 }
 ~Curses( ) {
  int result = endwin( );
 }
 public int Print(int x, int y, string message) 
 {
  return mvwprintw(window, y, x, message);
 }
 public int Refresh( ) 
 {
  return refresh(window);
 }
 public char GetChar( ) 
 {
  return (char)wgetch(window);
 }
}
public class HelloCurses 
{
 public static void Main(string [] args) 
 {
  Curses Curses = new Curses( );
  Curses.Print(10, 10, "Hello, curses!");
  //Curses.Refresh( );
  char c = Curses.GetChar( );
  Curses = null;
 }
} 
Tuve complicaciones con la librería, porque no la encontraba.
 Lo que tuve que hacer es buscar la librería ncurses que tenía en el sistema, con el comando locate, exactamente lo que escribí fue: 'locate ncurses', con el nombre que me dio, lo puse en el programa y listo.

En este caso concreto el nombre de la librería es libncurses.so.5, como indica la captura de pantalla.

El resultado de la ejecución

Inversion Of Controler -- Dependency Injection

El tema de esta entrada es tratar este patrón. Está realmente muy bien explicado en Wikipedia. En el libro de Carlos Ble, también lo trata fenomena, y es ahí donde lo oí por primera vez y lo entendí.



Ya que tenía un poco de tiempo he decidido estudiar un poco y ver un video sobre este tema de TekPub, que lo explican fenomenalmente bien.

El tema es que tengo una xubuntu 12.04 instala con monodevelop 2.8 y ni corto ni perezoso me puse a reproducir el ejemplo para ver si lo conseguía. Tengo que decir que todo ha ido de maravilla y funciona a la perfección.






Generalmente tengo la manía de hacer un proyecto en blanco y luego le voy añadiendo las distintas partes, si tiene web, pues un proyecto de web, si hay algo de test unitarios, su proyecto de test unitarios, ... También lo que hago es dentro del proyecto hacerme una carpeta, que se llama lib y ahí  meto todo lo externo que utilizo; en este caso el ninject. Por lo tanto como se puede ver en la captura de pantalla un proyecto en blanco y luego el proyecto de consola.

 
using System;
using Ninject;
using Ninject.Modules;

namespace ShoGun.Console
{
 class Program
 {
  public static void Main (string[] args)
  {
   var kernel = new StandardKernel(new RangerModelue());
   var sam = kernel.Get();
   
   sam.Attack("The unwashed masses");
   
   System.Console.Read();
  }
 }
 
 class SamuraiModelue:NinjectModule
 {
  public override void Load()
  {
   Bind<IWarrior>().To<Samurai>();
   Bind<IWeapon>().To<Sword>();
  }
 }
 
 class RangerModelue:NinjectModule
 {
  public override void Load()
  {
   Bind<IWarrior>().To<Ranger>();
   Bind<IWeapon>().To<Shuriken>();
  }
 }
}  
Es la clase principal, donde se juega con las clases Samurai, Sword, Rangery Shuriken, para luego inyectarlas a otras clases.

using System;

namespace ShoGun.Console
{
 public interface IWeapon
 {
  void Hit(string target);
 }
        
        public interface IWarrior
 {
  void Attack(string target);
 }
 }
Interfaces que no falten por favor.

 
using System;

namespace ShoGun.Console
{
 public class Shuriken : IWeapon
 {
  public Shuriken ()
  {
  }
  
  public void Hit(string target)
  {
   System.Console.WriteLine("Pierces {0}'s armor", target);
  }
 }
        public class Sword : IWeapon
 {
  public Sword ()
  {
  }
  
  public void Hit(string target)
  {
   System.Console.WriteLine("Chopped {0} clean in half", target);
  }
 }
}
Las armas, importante para luchar.
 
using System;
using Ninject;

namespace ShoGun.Console
{
 public class Samurai:IWarrior
 {
  private IWeapon _weapon;
  
  [Inject]
  public Samurai (IWeapon weapon)
  {
   _weapon = weapon;
  }
  
  public void Attack(string target)
  {
   _weapon.Hit(target);
  }
 }
}
El guerrero, interesante detalle [Inject], en el constructor, que indica que ese objecto se va a inyectar.
De esta forma también compruebo que  en linux (GNU/Linux, para no ofender a nadie) también funcionan las cosas.

jueves, 28 de junio de 2012

Curso para aprender a programar de verdad

Parece raro que en la universidad se enseñe a programar de verdad, pero la uji, oferta un interesante curso para aprender a programar bien; de forma ágil.

miércoles, 27 de junio de 2012

Keavy McMinn

Estoy actualizando/limpiando mi repo de github, porque estoy haciendo un petporject, para aprender un poco de mvc 2 (sigo siendo igual de paquete). Ojeando el blog de la empresa, me he dado cuenta de que una de sus empleadas es Keavy McMinn y que a parte de tener blog y las demás cosas sociales, entrena para IronMan, bueno en este caso IronWoman (por cierto tiene una bonita Cervélo, me recuerda a la de Ana Burgos).

Siempre me pregunto cómo lo harán. Trabajar en un sitio tan cool, como GitHub, entrenar(18 horas a la semana, solo para terminarlo), y seguro que tiene tiempo para estar con la familia. Bueno se me olvidaba, tiempo para estar al día en este mundillo y ser tan buena, como para estar ahí.

Tengo mucho que aprender ... :-)

lunes, 25 de junio de 2012

Música por Internet

Ayer recibí un email con un enlace a una página, el sitio en cuestión es: http://uwall.tv/. Lo he estado probando y está genial. Una de las cosas que me gusta es que al grupo que busques carga una lista de reproducción.

Es lo primero que vemos cuando se carga la página.








Escuchando algo de los RATM, ya que han vuelto a la escena musical.





También escuchando a los Foo Fighters, su mítica canción 'The Best of You'.

viernes, 22 de junio de 2012

Escuchar música con Html 5

Al ver tanto html 5 por todas partes a uno le despierta cierta curiosidad, así que viendo una página que estaba reproduciendo una bonita música de fondo, le he dado a que me muestre el código y he encontrado un bonito reproductor, hecho con esa tecnología.


jueves, 21 de junio de 2012

Técnica Pomodoro

Hace unos meses un compañero de trabajo -es lo bueno de trabajar con más personas y con parecidas inquietudes- me mando un email con este boletín de campus MVP. Hice una lectura rápida, pero sin determe mucho. Al poco tiempo escuché a Carlos Ble, hablando de la técnica Pomodoro. Entonces ya me empezó a interesar. Después de leer lo bueno que resulta, he decidido probarlo.

Me he descargado esta aplicación. He rellenado con las tareas que tenía planificado hacer en ese día y a por ello. Los resultados no pudieron ser mejores; porque me dio tiempo a estudiar y terminé de forma bastante satisfactoria todo lo que tenía previsto hacer en ese día. lo que veo que hay que tener bastante disciplina interior -que es básico para sacar cualquier cosa adelante-. Lo malo que veo es que con equipos de trabajo de varias personas, haciendo cosas diferentes, es complicado llevar esta técnica a buen término.

Cuando estaba haciendo mi segundo pomodoro, me acordé de este podcast que habla de productividad personal para todo tipo de personas.

Foo Fighters World & Friend of a Friend

Escuchando música me he encontado con esta canción. Creo que es una joya escondida.



Aprovechando que estoy hablando de buenas canciones de este grupo, añado otra

BDD & .NET

En una primera instancia están las pruebas unitarias (Unit Test, puede o no hacerse TDD), pero a un nivel más alto está  el  BDD, son pruebas de comportamiento (Behavior).
Para el mundo el .NET está la herramienta SpecFlow, para mono también está disponible. Me supongo que esto viene del Mundo Pepino que se encuentra en Ruby On Rails


Me he encontrado con dos videos (video1 y video2), que son bastante aclaradores sobre cómo funciona, cómo utililizarlos. he de comentar, que el segundo video es de los chicos de TekPub.

Seguro que hay muchas más cosas, porque parece que esto está creciendo bastante.

MVC HtmlHelpers

Estudiano un poco de MVC, y viendo videos de los de TekPub, he descubierto una cosa que me puede ayuar para montar los helpers para css, imágenes o ficheros de jscript.

En el servidor
namespace System.Web.Mvc
{
    public static class HtmlHelpers
    {
        private const string pubDir = "/content";
        private const string cssDir = "css";
        private const string imageDir = "images";
        private const string scriptDir = "javascript";

        public static string CSS(this HtmlHelper htmlHelper, string fileName)
        {
            if(! fileName.EndsWith(".css"))
            {
                fileName += fileName + ".css";
            }
            
            return string.Format("<link rel='stylesheet' type='text/css' href='{0}/{1}/{2}'/>\n",pubDir, cssDir ,fileName);
        }

        public static string JavaScript(this HtmlHelper htmlHelper, string fileName)
        {
            if (!fileName.EndsWith(".js"))
            {
                fileName += fileName + ".js";
            }

            return string.Format("<script type='text/javascript' src='{0}/{1}/{2}' ></script>\n", pubDir, scriptDir, fileName);
        }

        public static string Image(this HtmlHelper htmlHelper, string fileName)
        {
            return string.Format("<img src='{0}/{1}/{2}' />\n", pubDir, imageDir, fileName);
        }
    }

}
En el lado del cliente
        <%= Html.CSS("Site.css")%>
        <%= Html.JavaScript("jquery-1.4.1.js")%>
        <%= Html.JavaScript("colorpicker.js")%>

Una regla de la informática es que no hay que re-inventar la rueda -la otra es si funciona para qué tocar, pero con los test unitarios y demás prácticas ágiles, eso ya está quedando obsoleto-. Por lo tanto he descubierto que ya hay alguien que ha deicado tiempo y esfuerzo a desarrollar interesantes helpers

lunes, 18 de junio de 2012

La Universidad y ser buen desarrollador

Desde hace tiempo voy viendo que gente que es muy buena en la programación, incluso personas que trabajan en Microsoft y no tienen título universitario, pero que son unas máquinas tirando líneas de código.
Me pregunto si de verdad merece la pena pasar por la universidad para ganarse la vida con esto de la programación.
Me he encontrado esto, que es bastante interesante.

viernes, 15 de junio de 2012

Publicar código en el blog

He encontrado una página donde indica cómo publicar código en blogger.
El resultado está bien, aunque perfecto no hay nada.
namespace Test
{
    public class Prueba
    {
          public bool Probando(T historiaDeUsuario){ return true;}
    }
} 

Lo que hay en el html es lo siguiente
 
namespace Test
{
    public class Prueba
    {
          public bool Probando(T historiaDeUsuario){ return true;}
    }
}

jueves, 14 de junio de 2012

Interfaces & Mockito

Poco a poco estoy aprendiendo cómo están programando otras personas.

En el libro Profesisonal ASP.NET Design Patterns -un tocho de más de 1000 páginas, solo me leí los primeros capítulos- explica la importancia de programar con interfaces, de esa manera, el dessarrollo depende del comportamiento y no de la implementación, es menos propenso a errores. Por lo tanto sigue el principio de "fácil extender, difícil de modificar".

He estado jugando con esto de las interfaces, a raíz de este video, además le he añadido Mockito, para hacerlo más divertido. El código es algo muy trivial, de hecho hay un muy buen ejemplo que particularmente me aclaró mucho.

De todas formas voy a poner el pequeño código que he generado.

using System.Drawing;
namespace BrosPaint
{
    public interface IPintable
    {
        Color CurrentColor { get; set; }
        Color ChangeColor(Color newColor);
    }
}
Una pequeña interfaz de pintado.

using System.Drawing;

namespace BrosPaint
{
    public class Vehicle: IPintable
    {
        public Color CurrentColor { get; set; }
        public string Model { get; set; }

        public Color ChangeColor(Color newColor)
        {
            CurrentColor = newColor;
            return newColor;
        }
    }
    public class Truck:Vehicle
    {
    }
}
Implementando una clase genérica, que es vehículo. Luego su clase concreta tractor -Truck-.

namespace BrosPaint
{
    public class Car:Vehicle
    {
    }
}
Jugando un poco con el concepto de herencia, representado en la clase coche -Car-

using System.Drawing;
using NUnit.Framework;
using BrosPaint;

namespace BrosPaint.Test
{
    public class CarTest
    {
        [Test]
        public void PaintCar_Test()
        {
            IPintable item = new Vehicle();
            item.CurrentColor = Color.DimGray;

            item.ChangeColor(Color.DarkViolet);

            Assert.AreEqual(Color.DarkViolet, item.CurrentColor);
        }
    }
}
No puede falta el test ...

namespace BrosPaint
{
    public interface IRepository<t>
    {
         T Get(T element);
    }
}
Un interfaz muy genérica que extrae un elemento de un repositorio, que puede ser una base de datos, un fichero, un servicio web, ...

using NUnit.Framework;
using Moq;
using BrosPaint;

namespace BrosPaint.Test
{
    public class IRepositoryTest
    {
        [Test]
        public void RepositorySimpleTest()
        {
            var mock = new Mock<irepository<car>&gt;();
            var filter = new Car();
            var result = new Car();
            result.Model = "Ferrari";
            mock.Setup(x =&gt; x.Get(It.IsAny<car>())).Returns(result);


            var RepositoryCar = mock.Object;

            Car expectedCar = new Car();
            expectedCar.Model = "Ferrari";
            Car getCar = RepositoryCar.Get(new Car());

            var pp = getCar.Model;
            var ss = expectedCar.Model;

            Assert.IsNotNull(getCar);
            Assert.IsNotNull(expectedCar);
            Assert.IsTrue(expectedCar.Model == getCar.Model);
        }
    }
}
Test, que prueba el repositorio, utilizando mockito -moqueándolo-

jueves, 7 de junio de 2012

Cliente nativo de GitHub para Windows

Desde hace algo de tiempo vengo utilizando github, como repositorio de código. Principalmente lo utilizo para las Katas de programación. Este fin de semana he sacado un rato para subir una Kata, para mi sorpresa me he bajado el cliente nativo para windows. Además está hecho con metro. Se nota que estos tíos son muy buenos.

Un ejemplon de lo dicho.
Cliente nativo de GitHub, para windows














Para más información

Programadores en España

Opiniones sobre la informática-programadores en España.

viernes, 1 de junio de 2012

AutoMapper

Investigando esto del ASP.NET MVC, me encontré con la herramienta AutoMapper. Después ver este video ya he entendido para qué sirve.

Principalmente sirve para crearte los dto´s desde la entidades, para pasar los datos entre capas. Parece que es un proyecto bastante utilizado en este tipo de proyectos.