Ideas para el uso de Twitter en las empresas

50 ideas on using twitter for business: http://tinyurl.com/5u75pe

IE 6.0

Éste blog no funciona en Internet Explorer 6.0 para abajo… ¡y qué!

10 Puntos, gana un dominio, un año de hosting y mas!

Nunca he participado en un concurso como este, pero es un buen chance, no habría porque no intentarlo.

10puntos.info es un blog que desde mi punto de vista es muy original. Su contenido hace referencia a 10 puntos en forma de lista, acerca de diferentes temas que van desde curiosos, hasta interesantes. Desde que lo leí por primera vez, me llamo la atención y lo coloque en mi Blogroll para leerlo más seguido (claro, siempre y cuando el trabajo y el tiempo libre lo permita).

Como una forma de fortalecer la imagen del blog, su dueño a lanzado una convocatoria para participar en un concurso y poder ganar un servicio de hosting (para el primer lugar) y un dominio (para el segundo lugar) como premios importantes, gratis por un año (muy interesante)

Y bueno, aquí me ven participando en él, una vez que nunca de los nunca, ni siquiera en las canicas he ganado algo jojo.

Suerte a todos!

Nota: el concurso termina el 31 de agosto.

Actualización el 01/09/08

¡No gané!

Casi maestro

Según el CIA:

Nombre: Ramírez Leyva, José Roberto.
Grado: Maestría.
Programa: MATI - Mtro. en Administración de Tecnologías de Información.

Nombre Calificación Créditos
Entorno Empresarial 9 5.25
Negocios y las Tecnologías Información 10 5.25
Situación Organizacional 10 5.25
Evaluación Financiera de Tecnologías de Información 10 5.25
Planeación Estratégica Informática 10 5.25
Procesos de Negocios 10 5.25
Administración de Proyectos Informáticos 9 5.25
Dirección de Equipos de TI 10 5.25
Topico I 10 5.25
Gestión de Proyectos Informáticos 10 5.25
Topico II 9 5.25
Topico II 8 5.25
Formación Metodológica 10 5.25
Topico IV 10 5.25
Seminario de Tesis 10 5.25
Topico V 10 5.25

Una vez terminado mi programa academico, solo queda la tesis =)

Jack Johnson - Hope ♫

Your shadow walks faster than you
You don’t really know what to do
Do you think that you’re not alone?
You really think that you’re immune to it
Its going get that the best of you
Its going lift you up and let you down
Hmm hmm humm

It will defeat you then teach you to get back up
After it takes away all that you learn to love

Your reflection is a blur
Out of focus but in confusion
The frames the sun did burn
At the end of a roll of delusions
A ghost waiting its turn
And now I can see right through it
It’s a warning that nobody heard

It will teach you to love what you’re afraid of
After it takes away all that you’ve learn to love

But you don’t, always
Have to hold your head
Higher than your heart

You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better be hoping you’re not so…

Du du rut
Hope you’re not alone
Hmm hmm humm

Your echo comes back out of tune
Now you can’t quite get used to it
Reverb is just a room
The problem is that there’s no truth to it
It’s fading away too soon
Your shadow is on the move
And maybe you should be moving too

Before it takes away all that you learned to love
It will defeat you and then teach you to get back up

‘Cause you don’t, always
Have to hold your head
Higher than your heart

You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better be hoping you’re alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not alone
You better hope you’re not so…

Du ru ru ru ru
Hope you’re not alone
Hmm hmmm hmmmm
Better hooope
Huuu huuu hmmm
Better hope you’re not alone
Huuu huuu hmmm
hooope

Crónicas de un choque anunciado VII

A veces siento que vivo en una burbujita de aire y todo lo que existe dentro de ella es bueno, pero que tan equivocado estoy o lo he estado.

Pareciera que fue ayer el día que un desgraciado de la manera más cobarde, después de casi matarme, después de llevarlo a él y a su acompañante a su casa y de pensar de manera más positiva en que todo se arreglaría, este no se hiciera responsable de sus estupideces. Pues véanme ahora, ya paso más del año y medio y después de una infinidad de vueltas con el ministerio público (MP), estiras y aflojes, depresiones por observar el estado tan deplorable en el que se encuentran nuestras instalaciones de seguridad pública, esto aun no termina.

Hay algo positivo, esta semana me dieron una buena noticia los señores agentes del MP. Espero de una vez poder terminar con esto y ver al fulano tras-las-rejas o bien reponiéndome el daño.

10 tablas con CSS

Sin duda, algún día me deberán de servir en algún diseño web: http://tinyurl.com/6277ks

NHibernate for dummies

Sabemos hoy en día que la mayoría de las empresas basan sus aplicaciones en software analizado, diseñado y programado orientado a objetos. La empresa donde trabajo, los últimos meses se ha preocupado porque que cada vez en los desarrollos que se venden se utilicen objetos para crear modelos de negocio, que con esto, sin duda si creamos un modelo de dominio orientado a objetos será más claro el negocio para que el que lo necesite entender y código fácil mucho mas mantenible para los programadores que lo vayan a modificar.

Por otro lado tenemos la información, los datos, y probablemente todos nosotros en nuestros desarrollos hemos trabajado con bases de datos relacionales tales como SQL Server, MySQL, entre otras. Esta información seguramente necesitara cambiar e irse modificando, así como también necesitaremos tener esta información disponible cuando queramos, esto en al área de desarrollo de sistemas se le conoce como persistencia. Como se relaciona esto? el modelo relacional de datos es la representación más clara de los objetos de negocio que existen en nuestro dominio de sistema y este necesitara almacenar información de cada una de sus entidades dentro del mismo dominio (Clientes, Productos, Usuarios, etc) y al conjuntarse nace un concepto conocido como Object Relational Mapping (ORM).

NHibernate (NH) es un marco de trabajo ORM para ambientes en los que utilizamos .NET que nace de un port de Hibernate de Java y la gran utilidad es que ayuda a mapear los objetos de negocio que creamos en nuestras aplicaciones de .NET a bases de datos relacionales.

A partir de ahora intentaremos explicar cómo funciona a grandes rasgos NH y como podríamos aplicarlo a los nuevos desarrollos en la empresa. Para la práctica estaremos utilizando la versión 2008 del Visual Studio Team System (VSTS 2008) como IDE de desarrollo y la versión express del SQL Server 2005.

1. Crear un proyecto biblioteca de clases

Este proyecto deberá de contener nuestros objetos de negocio, y por lo tanto aquellos objetos que deseamos persistir. Como ya hemos mencionado en otros tutoriales, se recomienda como buena práctica crear un archivo de solución (sln) y en este agregar tantos proyectos vayamos a necesitar.

Para este tutorial he creado un proyecto llamado Tutorial.NH.BOL que es la biblioteca de clases que contendrá las entidades que representaran la base de datos.

2. Crear modelo de dominio

Nuestro modelo de dominio estará basado en usuarios (crearemos una carpeta con nombre Entidades en nuestro proyecto para depositar nuestras clases) y las diversas tareas que puede tener un usuario, sabemos que nuestras aplicaciones empresariales son más complejas, pero creo que bastará con explicar lo esencial para entender lo que es NH. La idea de esto es poder persistir estas entidades en nuestra base de datos relacional. Para hacer más sencillo el entendimiento de NH imagínense que una instancia de cada una de nuestras entidades en una fila de una tabla de la base de datos, pero no se casen con este concepto.

Es una buena práctica usar el diagramador de clases que por defecto cuenta el VSTS 2008, el trabajo es más limpio, mas controlado y lo mejor de todo en la mayoría de los casos ¡no tenemos que escribir código! =).

3. Crear modelo relacional

El modelo relacional estará representado por aquellas tablas de base de datos las cuales deberán de representar las entidades del modelo de dominio que queremos persistir. Ya sea en el IDE de VSTS 2008 o en la consola de Microsoft SQL Server deberemos de obtener algo como esto (algo ideal sería utilizar NH para generar el esquema de nuestra base de datos acorde a nuestro modelo de dominio, este método queda fuera del alcance del tutorial):

4. Mapeo ORM

La manera en cómo se mapeara el modelo de dominio con nuestro modelo relacional es a través de documentos XML, esto se hace con el fin de documentar la relación que existe entre nuestro objeto y la tabla que lo representa en la base de datos, es decir, el documento de configuración define que campos en la base de datos corresponden a los atributos en nuestro objeto y viceversa. La relación puede hacerse mediante código (con ayuda de la librería NHibernate.Mapping.Attributes.dll) en los atributos de la clase ó a través de archivos como los que acabo de comentar, archivos XML que tienen la extensión .hbm.xml, es por esto que nuestros archivos mapping deberan llamarse Usuario.hbm.xml y Tarea.hbm.xml. No hay que perder de vista que el .hbm es parte del nombre del archivo y es una convención que utiliza NH para identificar los archivos como mapping

Antes de empezar a trabajar con nuestro mapeo ORM debemos de descargar la versión 1.02 de NHibernate para .NET, la cual está disponible en la siguiente dirección: http://downloads.sourceforge.net/nhibernate/NHibernate-1.2.0.GA-bin.zip?modtime=1178204756&big_mirror=0

Se recomienza habilitar el Intellisense para el mapeo y la creación de estos archivos de configuración, para esto debemos de copiar los archivos nhibernate-configuration.xsd (para la configuración de las sesiones, algo que veremos más adelante en este tutorial) y nhibernate-mapping.xsd (para los mappings) a las carpetas de instalación de Visual Studio <VS .NET directorio de instalación>Common7Packagesschemasxml si usamos VS.NET 2003 y <VS 2005 directorio de instalación>XmlSchemas para VS.NET 2005 y 2008.

Dentro de nuestra librería de clases Tutorial.NH.BOL vamos a crear una carpeta llamada Mapping -esto con el fin de tener mas orden- la cual contendrá todos nuestros archivos de configuración y la implementación de estos la muestro a continuación:

4.1. Usuario.hbm.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Tutorial.NH.BOL" namespace="Tutorial.NH.BOL">
    <class name="Usuario" table="usuarios">
        <id name="Id" column="IdUsuario" type="int" unsaved-value="0">
            <generator class="identity" />
        </id>
        <property name="Nombre" type="String" length="50"></property>
        <property name="ApellidoMaterno" type="String" length="50"></property>
        <property name="ApellidoPaterno" type="String" length="50"></property>
        <property name="CorreoElectronico" type="String" length="50"></property>
        <property name="Telefono" column="TelefonoParticular" type="String" length="50"></property>
        <bag name="Tarea" cascade="all-delete-orphan">
            <key column="IdUsuario" />
            <one-to-many class="Tarea" />
        </bag>
    </class>
</hibernate-mapping>

Ahora podemos hablar un poco sobre el contenido del archivo XML. Todos los documentos para mapear XML deberán de declarar el espacio de nombre urn:nhibernate-mapping-2.2 (depende de la versión distribuida), así como de manera opcional los atributos assembly para indicar el ensamblado de nuestras clases y el namespace de nuestras clases en el proyecto. Existen otros atributos aplicables a nuestro archivo como el schema, que representa el nombre del esquema de la base de datos, entre otros que están fuera del alcance de este tutorial. Una vez hecho esto debemos de comenzar a tratar los atributos y elementos para la clase que deseamos mapear. Dentro de las etiquetas <class name=”Usuario”></class> estarán todas aquellas configuraciones para la clase. El atributo name corresponde al nombre de la clase incluyendo el nombre del assembly. El atributo table corresponde al nombre de la tabla en la base de datos.

Con la etiqueta <id> representamos la llave primaria de la tabla de la base de datos. Este elemento define el mapeo entre la propiedad de la clase y la llave primaria de la base de datos. Entre sus atributos se encuentra el name, que indica el nombre del identificador de la propiedad; columna, que representa la columna en la tabla; type, el tipo de dato y el unsaved-value indica que el objeto es nuevo y que no existe en la base de datos.

Debemos de continuar con todas las propiedades, entonces Nombre, Apellido Paterno, Apellido Materno, Correo Electronico y Telefono deberán de estar dentro de las etiquetas <property/> y representan propiedades persistentes de la clase.

Y como habíamos dicho al inicio del tutorial, lo complicaremos creando una relación one-to-many con la clase Tarea y de esta forma representaremos la relación en la base de datos, es decir, que a un usuario se le pueden asignar varias tareas.

4.2. Tarea.hbm.xml

1
2
3
4
5
6
7
8
9
10

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Tutorial.NH.BOL" namespace="Tutorial.NH.BOL">
    <class name="Tarea" table="tareas">
        <id name="Id" column="IdTarea" type="int" unsaved-value="0">
            <generator class="identity" />
        </id>
        <property name="NombreTarea" type="String"></property>
        <many-to-one name="Usuario" column="IdUsuario" cascade="all" />
    </class>
</hibernate-mapping>

Lo único representativo es el elemento <many-to-one> para la propiedad Usuario de nuestra clase. Esta representa una ordinaria asociación a otra clase persistente, en este caso la que tenemos en la base de datos.

Algo que debemos de saber es que en primera instancia NH está configurado de modo perezoso (lazy load) para todas las entidades creadas. Esto se recomienda dejarse así y no moverse. Debido a esto la regla es que todas las propiedades definidas en nuestras entidades deberán ser virtuales.

1
2
3
4
5

public virtual int Id
{
    get { return _id; }
    set { _id = value; }
}

Hay mucha más información relacionada a estos archivos mapping, pero sería algo complicado tratar de explicárselos paso a paso, además de que este tutorial perdería sentido, para ello, recomiendo consultar la referencia en línea sobre este mapeo de clases en http://www.hibernate.org/hib_docs/nhibernate/1.2/reference/en/html/mapping.html.

Hasta aquí nuestro explorador de soluciones deberá verse así:

5. Configurando NHibernate en VSTS 2008 .NET

Bueno hasta ahora, no hemos hecho mucho, pero ya empieza lo bueno =). Hay que decirle a NH con que proveedor de base de datos vamos a trabajar. Por fortuna NH soporta el más querido por nosotros en la oficina SQL Server.

Para hacer mas modular la aplicación, vamos a agregar una aplicación de consola a nuestra solución con el fin de consumir nuestro ORM. El nombre que yo le he puesto al proyecto es Tutorial.NH.App, tu puedes ponerle el que gustes. Importante agregar dentro de las referencias nuestro ensamblado de nombre Tutorial.NH.BOL. Pudimos haber utilizado Unit Test para probar nuestro proyecto en lugar de la aplicación de Consola, pero mejor eso veámoslo después.

5.1. Configuración en App.config

Agregaremos un archivo de configuración donde indicaremos las llaves necesarias para establecer la comunicación con nuestra base de datos.

1
2
3
4
5
6
7
8
9
10
11
12
13

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="nhibernate" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.3300.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
    </configSections>
    <nhibernate>
        <add key="hibernate.show_sql" value="false" />
        <add key="hibernate.connection.provider" value="NHibernate.Connection.DriverConnectionProvider" />
        <add key="hibernate.dialect" value="NHibernate.Dialect.MsSql2000Dialect" />
        <add key="hibernate.connection.driver_class" value="NHibernate.Driver.SqlClientDriver" />
        <add key="hibernate.connection.connection_string" value="Data Source=ROBERTOSQLEXPRESS;Initial Catalog=NHibernate;Integrated Security=SSPI;" />
    </nhibernate>
</configuration>

5.2 Configuración en hibernate.cfg.xml

Este es otra manera de realizar nuestra configuración de NH y consiste en agregar un archivo XML a nuestro proyecto con la siguiente estructura: hibernate.cfg.xml.

1
2
3
4
5
6
7
8
9
10
11

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-configuration  xmlns="urn:nhibernate-configuration-2.2" >
    <session-factory name="NH01">
        <property name="connection.provider">NHibernate.Connection.DriverConnectionProvider</property>
        <property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>
        <property name="dialect">NHibernate.Dialect.MsSql2005Dialect</property>   
        <property name="connection.connection_string">Data Source=ROBERTOSQLEXPRESS;Initial Catalog=NHibernate;Integrated Security=SSPI;</property>
        <property name="show_sql">false</property>
        <mapping assembly="Tutorial.NH.BOL" />
    </session-factory>
</hibernate-configuration>

Podemos utilizar cualquiera de los dos. Con este archivo de configuración le decimos a NH que queremos trabajar con Microsoft SQL Server como base de datos. Para nuestro ejemplo usaremos la segunda opción.

Y bien ya estamos listos para iniciar con nuestras operaciones CRUD.

6. Operaciones CRUD

Nuestro sistema hasta este punto ha sido preparado con lo esencial. Se han implementado características necesarias para el funcionamiento de NH, se ha creado el modelo de dominio se han definido los archivos mapping y se ha establecido la configuración a NH. Vamos poco a poco y ya llevamos algo recorrido =).

Empezaremos a darle uso y funcionalidad a nuestro dominio.

Ahora, vamos a agregar una carpeta a nuestro proyecto Tutorial.NH.BOL llamado Repositorio (esto lo especifica Domain Driven Design) y en el agregaremos una clase llamada IRepositorioUsuario.cs y la definimos de la siguiente manera:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

using System;
using System.Collections.Generic;
using System.Text;
using Tutorial.NH.BOL.Entidades;
 
namespace Tutorial.NH.BOL.Repositorio
{
    public interface IRepositorioUsuario
    {
        void Agregar(Usuario usuario);
 
        void Actualizar(Usuario usuario);
 
        void Eliminar(Usuario usuario);
 
        Usuario ObtenerUsuarioPorId(int IdUsuario);
 
        IList<Usuario> ObtenerUsuarios();
    }
}

Ahora, lo que sigue es implementar cada uno de los métodos definidos por la interfaz IRepositorioUsuario.cs. Comenzaremos con el primer método Agregar() que nos va a permitir agregar una instancia de un Usuario en nuestra base de datos.

Dentro de la misma carpeta (Repositorio) vamos a agregar una clase llamada RepositorioUsuario.cs y vamos a hacer que herede de la interfaz IRepositorioUsuario.cs, con esto haremos que la clase implemente cada uno de los métodos de la interfaz.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

using System;
using System.Collections.Generic;
using System.Text;
using NHibernate;
using Tutorial.NH.BOL.Entidades;
using Tutorial.NH.BOL.Genericos;
 
namespace Tutorial.NH.BOL.Repositorio
{
    public class RepositorioUsuario : IRepositorioUsuario
    {
        public void Agregar(Usuario usuario)
        {
            throw new NotImplementedException();
        }
 
        public void Actualizar(Usuario usuario)
        {
            throw new NotImplementedException();
        }
 
        public void Eliminar(Usuario usuario)
        {
            throw new NotImplementedException();
        }
 
        public Usuario ObtenerUsuarioPorId(int IdUsuario)
        {
            throw new NotImplementedException();
        }
 
 
        public IList<Usuario> ObtenerUsuarios()
        {
            throw new NotImplementedException();
        }
    }
}

Ahora, lo que sigue es crear el mecanismo para crear las sesiones que se van a comunicar con nuestra base de datos. Dentro del mismo proyecto, nos crearemos una Carpeta que nombraremos Genericos y agregamos una clase de nombre NHibernateClass.cs.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NHibernate;
using NHibernate.Cfg;
 
namespace Tutorial.NH.BOL.Genericos
{
    public class NHibernateClass
    {
        private static ISessionFactory _sessionFactory;
        private static ISessionFactory SessionFactory
        {
            get
            {
                if (_sessionFactory == null)
                {
                    var configuration = new Configuration();
                    configuration.Configure();
                    _sessionFactory = configuration.BuildSessionFactory();
                }
                return _sessionFactory;
            }
        }
 
        public static ISession OpenSession()
        {
            return SessionFactory.OpenSession();
        }
    }
}

Esta clase lo que hará por nosotros es crear una SessionFactory solo la primera vez que el cliente necesita una sesión. Que contiene este Singleton? Contiene un objeto del tipo Configuración que utiliza la configuración de nuestro hibernate.cfg.xml que creamos en la aplicación se escritorio y que se encarga de cargar el objeto ISessionFactory gracias al método BuildSessionFactory() y de esta forma poder comenzar a crear sesiones de tipo ISessionFactory.

Volvamos a nuestra clase RepositorioUsuario.cs e implementemos el método Agregar() de la siguiente manera:

1
2
3
4
5
6
7
8
9

public void Agregar(Usuario usuario)
{
    using (ISession sesion = NHibernateClass.OpenSession())
    using (ITransaction trans = sesion.BeginTransaction())
    {
        sesion.Save(usuario);
        trans.Commit();
    }
}

En el método Actualizar() escribiremos lo siguiente:

1
2
3
4
5
6
7
8
9

public void Agregar(Usuario usuario)
{
    using (ISession sesion = NHibernateClass.OpenSession())
    using (ITransaction trans = sesion.BeginTransaction())
    {
        sesion.Update(usuario);
        trans.Commit();
    }
}

En el método Eliminar() escribiremos lo siguiente:

1
2
3
4
5
6
7
8
9

public void Agregar(Usuario usuario)
{
    using (ISession sesion = NHibernateClass.OpenSession())
    using (ITransaction trans = sesion.BeginTransaction())
    {
        sesion.Delete(usuario);
        trans.Commit();
    }
}

Para el método ObtenerUsuarioPorId() haremos esto:

1
2
3
4
5

public Usuario ObtenerUsuarioPorId(int IdUsuario)
{
    using (ISession sesion = NHibernateClass.OpenSession())
        return sesion.Get<Usuario>(IdUsuario);
}

Y para obtener todos los usuarios:

1
2
3
4
5
6
7
8

public IList<Usuario> ObtenerUsuarios()
{
    using (ISession sesion = NHibernateClass.OpenSession())
    {
        var usuarios = sesion.CreateCriteria(typeof(Usuario)).List<Usuario>();
        return usuarios;
    }
}

Nota la creación del objeto sesión desde nuestra clase NHibernateClass.cs y tambien el uso de una transacción.

¡Y listo! podemos empezar a trabajar con nuestro modelo de NH para la persistencia de nuestras entidades de dominio.

Para guardar la información de un usuario y sus tareas una posible implementación es que desde nuestra aplicación de consola incluyamos esta implementación:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Tutorial.NH.BOL.Entidades;
using Tutorial.NH.BOL.Repositorio;
 
namespace Tutorial.NH.App
{
    class Program
    {
        static void Main(string[] args)
        {
            Usuario usr = new Usuario();
            usr.Nombre = "Roberto";
            usr.ApellidoPaterno = "Ramirez";
            usr.ApellidoMaterno = "Leyva";
            usr.CorreoElectronico = "jramirezleyva@gmail.com";
            usr.Telefono = "410-00-00";
 
            Tarea task = new Tarea();
 
            task.NombreTarea = "Tutorial de NHibernate";
            task.Usuario = usr;
            usr.Tarea.Add(task);
 
            IRepositorioUsuario rUsr = new RepositorioUsuario();
 
            rUsr.Agregar(usr);                      
        }
    }
}

Si bien recordamos cuando hicimos el modelo de dominio y las mapeamos con la base de datos, creamos unas propiedades que permitían las relaciones <many-to-one />, <one-to-many />. Esta es la verdadera magia, ¿se dieron cuenta que nunca utilizamos procedimientos almacenados o que nunca nos creamos rutinas de conexión y de creación de DataAdapters o DataSets, mucho menos DataReaders? Gracias a NH podemos persistir nuestros objetos de una manera limpia y orientada a objetos que es lo más importante.

Conclusión

En este sencillo ejemplo, pudimos observar cómo manejar un modelo de dominio y como cerrar el “gap” con nuestra base de datos relacional. Sabemos que este es un ejemplo básico y hay mucho más que explicar y que probar, pero por lo pronto espero que esto les haya servido como una introducción (al menos a mí si me ayudo jeje).

El código de ejemplo lo pueden descargar de aqui.

Mas información:

http://www.hibernate.org/hib_docs/nhibernate/1.2/reference/en/html/
http://darioquintana.com.ar/articles/tutorial-de-nhibernate-primeros-pasos

La maestría casi se acaba

Inspirado en un post del Guamu no quise dejar de comentar acerca de lo que represento en su momento la maestría en mi vida, y es que no es para menos, fueron ¡dos años! y si no fueron intensos, si ayudaron para reflexionar sobre el rumbo de mi vida, en donde me encuentro actualmente y hacia donde me dirijo.

Una vez fui de los que pensé que esta serie de programas académicos dirigidos a formar profesionales que propongan proyectos de TI y así satisfacer necesidades, no era para mí, no era lo que yo buscaba, pero es de sabios rectificar y ahora puedo decir que me siento orgulloso de pertenecer a este grupo de profesionales. Fueron mis maestros (agradecimiento especial a cada uno), las experiencias de todos y cada uno de los que alguna vez levantamos la mano para hacer una pregunta en alguna clase y qué decir de las tareas, lo que me ayudo a cambiar de parecer.

Lo último que puedo decir es que aun tengo mucho que mejorar y esto no se acaba aquí, hay mucho aprendizaje de por medio, muchas más ramas del área que explorar y algo mucho más importante, aplicar todo lo que he aprendido.

Aun tengo algunos pendientes. Uno de ellos es la clase de este jueves y por ultimo pero no menos importante, terminar el documento que me acredite como Maestro en Administración de TI (la famosa tesis), que va en buen camino por cierto.

Agradecimiento a la niña que contribuyó en todo momento en apoyar a su servidor en este reto, sin duda fuiste una parte muy importante en este proyecto de maestría, muchas gracias Alejandra ♥