Introducción

Como en otros tantos aspectos de las nuevas tecnologías, en el mercado del hosting, tenemos varias posibilidades en cuanto a sistema operativo se refiere. Las dos mayoritarias a día de hoy, GNU/Linux y Microsoft Windows, se reparten una gran cuota de mercado lo que no quiere decir que no existan otras alternativas, como por ejemplo servidores basados en NetBSD o FreeBSD. En este artículo veremos desde el punto de vista de cliente de una empresa de hosting, qué puede hacer que nos decantemos entre una u otra opción.

A priori, cualquier linuxero (entre los que me incluyo) no pensaría en ningún momento en usar un servidor basado en Internet Information Services (el servidor web de Microsoft) sobre un Microsoft Windows Server 2008. Sin embargo, os puedo asegurar que hay circunstancias en las que no sólo es recomendable usar esta opción, sino necesario. De todas maneras si nosotros somos los que elegimos la tecnología a usar y no nos imponen ciertas restricciones (si estamos trabajando para alguien) un poco “especiales”, en líneas generales podríamos decir que la mejor opción es usar GNU/Linux.

Veamos a continuación, desglosados un poco más los detalles que pueden hacer que nos decantemos por una alternativa o por otra.

Precio

Puesto que a la hora de la verdad en todo lo referente a negocios privados, el aspecto más determinante de todos es el presupuesto, comencemos por el precio medio de los hosting. Dado que para poder tener un servidor corriendo bajo Microsoft Windows Server 2003 o 2008, hace falta pagar una licencia comercial y a un precio que no es bajo ni mucho menos, los hosting que ofrecen sistemas Windows suelen ser más caros que los basados en GNU/Linux. Antes de seguir me gustaría aclarar que hay muchas empresas que venden hosting con las dos posibildiades y uno a la hora de contratarlo, elige cuál le interesa.

Siguiendo con el tema económico, hay que contar que en un servicio de hosting, el precio que se paga por un sistema o por otro, no es sólo la licencia del sistema operativo en sí. Hay muchos factores aparte como por ejemplo, el coste del soporte, el gasto energético o la necesidad de comprar licencias de terceros programas, entre otras.

El coste del soporte era una de las excusas esgrimidas por Microsoft sobre el coste real de mantener un servidor en GNU/Linux, porque afirmaban que el soporte era bastante más caro que en GNU/Linux. Sin embargo, debido a la mayor automatización de muchos procesos en GNU/Linux y lo que es más importante, a su mayor difusión, cada vez el soporte es más barato y fácil para este sistema.

En cuanto a los otros factores que hemos también mencionado, el gasto de energía y la necesidad de comprar licencias a terceros, decir de la primera que para ver un consumo de energía real habría que hacer una serie de test y benchamarks con mucha exactitud para poder emitir un juicio objetivo. En el segundo caso, en el de comprar software de terceros, en Windows suele ser más frecuente esta necesidad, aunque en GNU/Linux también puede darse este caso y por supuesto, en ambos se puede utilizar software libre para satisfacer muchas necesidades.

Seguridad

Se ha hablado tantísimo de este aspecto, comparando además a Windows y a Linux, que creo que no es necesario dar mucha información. La seguridad de los sistemas GNU/Linux está más que contrastada, más aún en ambientes de hosting; y además la facilidad de actualización que tiene el software instalado en este sistema hace que ante cualquier versión nueva que tape algún agujero, la actualización sea rápida y no haya de por medio problemas como obligar a reiniciar el servidor.

Este y otros muchos detalles, provenientes de un sistema que nació en un ambiente profesional, hacen de GNU/Linux el ganador por diferencia de este apartado.

Eficiencia

Este aspecto depende mucho del hardware que se use en la máquina en la que resida el servidor así como de la línea que tenga contratado con su ISP (proveedor de servicios de Internet) nuestro servicio de hosting. A priori puede que GNU/Linux distribuya mejor la carga de trabajo que Microsoft Windows, pero es un aspecto que más que preocuparnos a nosotros que somos los que contratamos el host debe preocuparle al que ofrece el servicio.

También es verdad que cada vez son más las aplicaciones web basadas en tecnologías no tan eficientes como PHP, por ejemplo Ruby On Rails o Python (bastante más eficiente que Ruby pero aún así más lento que PHP) con Django o Turbo Gears; que requieren una mayor cantidad de recursos.

Posibilidades y necesidades específicas

En este punto es donde quizás nos tengamos que decantar por una solución Microsoft Windows por obligaciones de los requisitos. Imaginemos que necesitamos usar por obligación una base de datos SQL Server, de Microsoft. Ante este caso, dado que este sistema gestor de base de datos sólo ejecuta en el sistema operativo de Microsoft, estaremos obligados a usar un host con Windows Server que ofrezca esta posibilidad. También es verdad que éste no suele ser el caso más común, por fortuna, y que para muchísimas otras circunstancias, la solución correcta es Linux, por razones casi idénticas. Por ejemplo, a día de hoy, es difícil encontrar un sistema basado en Windows que ofrezca soporte para ejecutar aplicaciones web implementadas con Ruby o Python, dos tecnologías en alza.

Por lo tanto en este apartado, dependiendo de nuestro caso deberemos elegir una plataforma u otra, aunque como repito en la mayor parte de los casos el resultado es favorable para GNU/Linux. De hecho, en mi caso personal, por ejemplo, nunca elegiría trabajar con ASP.NET y SQL Server, por ejemplo, pudiendo trabajar con tecnologías libres que cubren las mismas necesidades ya que además de resultarme más barato, dispongo de una cantidad de documentación y soporte mucho mayor (aparte de que las tecnologías de Microsoft no son código abierto). Sin embargo, si tenemos un encargo profesional y por razones ajenas a nosotros hay que utilizar dichas tecnologías, tendremos que dencantarnos por un host con Windows Server.

Adaptabilidad

Normalmente, las tecnologías libres suelen estar mejor estandarizadas que sus equivalentes propietarias, por lo que de cara a migrar datos de un sistema gestor de base de datos a otro distinto, o a la hora de cambiar el servidor, si estamos operando con un host que trabaje con GNU/Linux, posiblemente se nos presenten menos problemas.

Futuro

Tanto el soporte como las nuevas versiones de software, están prácticamente aseguradas en los dos sistemas. Los costes de actualización de una versión a otra en el caso de software privado, no os repercutirán demasiado, dado que al igual que el coste de la licencia, estos son gastos que paga la empresa a la que contratamos. Por esta razón suelen ser más caros los servicios de host basados en sistemas Windows. Aparte de eso, aunque este es un tema importante a la hora de elegir un servicio de host, el asegurarnos que el software está siempre actualizado y alejado de posibles vulnerabilidades, no existen diferencias de un sistema a otro.

Conclusiones

A lo largo del artículo, habréis observado que para la mayor parte de las necesidades, excepto para las que necesitan expresamente ciertas tecnologías como .NET, podemos usar GNU/Linux por multitud de razones. Comenzando por el precio, terminando en la seguridad y pasando por variedad de otros aspectos como por ejemplo la capacidad de adaptación, GNU/Linux suele ser el más idóneo o en casos extraños, estar al nivel de su rival. También es cierto que como digo haya aplicaciones que por cuestiones de los requisitos necesiten sistemas Windows o en todo caso ejecuten con Mono (no os lo recomiendo si vais a usarlo como un sistema en producción y no en pruebas o de uso personal). En un futuro, también habrá que tener en cuenta aspectos como la virtualización en servidores, tecnología bastante avanzada ya pero que no se ofrece en muchos servicios de host.

Elegido el sistema, tenéis que elegir la empresa de hosting que contratar. En otros artículos os contarán mejor cómo seleccionar a dicha empresa de entre todas las que se ofertan en la red, pero como primer paso os recomiendo no comprobar sólo la cantidad de servicios que ofrecen, sino la calidad de los mismos.

Por último, os dejo unos cuantos enlaces en la sección “En la red”, de servidores web disponibles para GNU/Linux y un poco más de información para que leáis en la red sobre las versiones de servidor de Microsoft Windows y el servidor web que usan, Internet Information Services.

Aunque esta entrada no forma parte del curso de Mono, sí está muy relacionada con esta entrega dedicada a tipos de datos.

Si tenemos una variable u objeto y no sabemos su tipo con seguridad, disponemos de dos métodos que usaremos para ver cuál es realmente el tipo del mismo. Veamos:

• getType(): obtiene el tipo de la instancia actual
• Type.GetType(“tipo de objeto”): lo usamos para obtener una referencia con la que comparar

Por ejemplo, ¿cómo saber si el objeto “auxiliar” es un entero con signo de 32 bits (el entero más estándar, el que usamos al poner int simplemente)?

if(auxiliar.GetType() == Type.GetType("System.Int32"))
   return true;
else
   return false;

Al igual que con enteros, podemos hacer la comprobación para cualquier tipo:

• Boolean: valor booleano
• Byte: ocho bits sin signo
• Char: carácter UNICODE
• DateTime: fecha con tiempo
• Decimal: número decimal
• Double: pnto flotante de precisión doble
• Int16: entero con signo de 16 bits
• Int32: ídem pero de 32 bits
• Int64: ídem pero de 64 bits
• SByte:  8 bits con signo
• Single: punto flotante de precisión simple
• UInt16: entero sin signo de 16 bits
• UInt32: ídem pero de 32 bits
• UInt64: ídem pero de 64 bits

¿Qué es una excepción?

Una excepción es una situación anormal que se da a lo largo de la ejecución del programa. El manejador de la excepción, es una estructura de control que permite ejecutar un código de acuerdo a esa situación anormal de forma controlada.

¿Qué tipo de acciones se suelen realizar?

Por un lado tenemos acciones de tipo terminación. En lugar de aparecer un mensaje de error del sistema operativo, el programa mismo lo emite informando de qué va a terminar su ejecución.

Por otro lado, tenemos manejadores que modifican el comportamiento del programa en cierto momento. Para este tipo de acciones, podríamos decir que las excepciones representan más una forma de control del flujo que un recurso de emergencia.

¿Qué otros mecanismos existen para esta misma problemática?

Ejemplos típicos de excepciones son:

• Cuando tratamos de dividir entre cero
• Cuando tratamos de llamar a un método de una instancia que es nula
• Cuando tratamos de convertir una cadena en número y la cadena no tiene formato numérico

Y así podríamos seguir un largo etcétera de posibles excepciones. Como comprobaréis todas estas excepciones, podrían comprobarse como se hace en lenguajes que no tienen este mecanismo: mediante condicionales cada vez que hay una operación que pueda sufrir error. ¿Por qué es mejor usar excepciones?

Ventajas de las excepciones

¿Para qué complicarnos la vida con un nuevo concepto si podemos usar directamente comprobaciones?

1. Separar el código principal del programa, del tratamiento de errores
2. Propagar el error en la pila de ejecución, de forma
3. Agrupar y clasificar los errores

¿Cómo detectar y tratar una excepción con Mono y C#?

Para detectar una excepción en C# usamos la siguiente estructura (veámoslo con un ejemplo):

int a = 1;
int b = 0;
try{
	int c = a / b; // zona protegida
}catch(DivideByZeroException exc){
	Console.Write("Ha intentado dividir desde cero"); // código a ejecutar
}

Como véis, estamos hablando directamente de la excepción de división entre cero. Si queremos controlar cualquier tipo de excepción, sólo tendremos que usar en lugar de DivideByZeroException, la clase de excepciones de la que heredan todas las demás, Exception. También podremos combinarlas, de forma que podamos atender a cierto tipo de excepciones y a cualquier otra que no hayamos controlado.

Veamos un caso de control para un tipo de excepción concreta (la de formato incorrecto) y el control para cualquier otro caso:

string cadena = "2a";
try{
	int valor = int.Parse(cadena);
}catch(FormatException exc){
	Console.Write("Ha ocurrido una excepción por el formato del fichero. Detalles:\n" + exc.Message);
}catch(Exception exc){
	Console.Write("Ha ocurrido otro tipo de error. Detalles:\n" + exc.Message);
}

Entregas anteriores

• Curso C# con Mono – Conversión de tipos e información cultural
• Curso C# con Mono – Declaración de clases y estructuras
• Curso C# con Mono – Espacio de nombres y regiones
• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!

Esto es lo que se llama la información cultural, que se sitúa dentro del ensamblado: System.Globalization, y que aparte de en este tema es conveniente conocer para otras tareas.

Casting

Es la forma más simple de hacer una conversión de datos. Está directamente heredada de C y puede ser implícita (si no se especifica) o explícita (cuando sí lo hacemos). Tiene grandes limitaciones porque básicamente sólo permite no convertir, sino camuflar, para una instrucción en concreto el tipo de dato.

Veamos un ejemplo:

int i = 10;
float f = 0;
f = i;  // conversión implícita
f = 0.5F;
i = (int)f;  // conversión explícita. Existe pérdida de información, los decimales

Métodos ToString

Al igual que en otros muchos lenguajes de programación, a este nivel de abstracción, existe un método ToString, definido en cada clase, que convierte cualquier objeto en una cadena. Si tenemos un entero que tiene dentro el valor 1, devolverá una cadena “1″; igualmente pasará  con un decimal, pero aquí es donde entra la información cultural en juego. Si tenemos la cultura predefinida como la española, mostrará comas y punto de acuerdo a nuestra forma de hacerlo, si definimos otra cultura predefinida, el comportamiento cambiará conforme a eso. También podemos cambiar de forma puntual la cultura predefinida para un punto en concreto.

Veamos ejemplos de uso avanzado de ToString usando especificadores, para mostrar el mismo número por pantalla con decimales, sin ellos, en formato moneda, con porcentaje…

decimal valor = 16325.62m;
string especificador;
// Sin especificador
Console.WriteLine("Sin el especificador tenemos el valor: " + valor.ToString());
// Especificador numérico estándar
especificador = "G";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 16325,62
especificador = "C";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 16.325,62€
especificador = "E04";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 1,6326E+004
especificador = "F";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 16325,62
especificador = "N";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 16.325,62
especificador = "P";
Console.WriteLine("Con el especificador: " + especificador + " tenemos el valor: " + valor.ToString(especificador));
// Muestra: 1.632.562,00%

Veamos un ejemplo de uso con información cultural (CultureInfo):

System.Globalization.CultureInfo culture  = new System.Globalization.CultureInfo("EN-us");
Console.WriteLine("Cambiando a cultura de inglés de Estados Unidos tenemos: " + valor.ToString(culture.NumberFormat));
// Muestra: 16325.62

Existen objetos, que a pesar de tener un método de este tipo, la cadena que devuelven no contiene prácticamente nada de la información del objeto. Por ejemplo, si tenemos un DataTable y le invocamos el método ToString, probablemente la salida sea sólo que es una instancia del tipo de objeto DataTable.

Métodos Parse

Podríamos decir que las funciones Parse, son la funciones inversas a los métodos ToString. A diferencia de los primeros, de una cadena, son capaces de leer su contenido y plasmarlo en un tipo de dato concreto, por ejemplo, de cadena a entero.

En C existían unas cuantas funciones que hacían esa misma labor: atoi, atol…. Además de ser verdaderamente útiles en interfaces gráficos y web, recordad que los datos que introducen los usuarios suelen venir en formato cadena, por la propia constitución de este tipo de interfaces.

Además son verdaderamente útiles cuando tratamos con tipos de datos a los que no podemos hacer casting directamente, ya que la solución más práctica es hacer un ToString seguido de un Parse.

Veamos ejemplos:

string valor = "1";
int a = int.Parse(a);
Console.WriteLine("El valor de a es: " a.ToString());

Como podréis imaginar, si queremos pasar datos decimales con comas y puntos de tal manera o de tal otra, también deberemos usar en este punto la información cultural.

Nos vemos en la próxima entrega.

Entregas anteriores

• Curso C# con Mono – Declaración de clases y estructuras
• Curso C# con Mono – Espacio de nombres y regiones
• Curso C# con Mono – Ensamblados
• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!

Ensamblados

Para resolver este problema, la estructura en Mono (y en .NET) los ensamblados. Éstos pueden ser tanto ejecutables (con extensión .exe), como de librería (con extensión .dll). Ambas extensiones son una herencia de las tecnologías Microsoft desde los tiempos del MS-DOS. Los ensamblados son ficheros en donde se encuentran, compiladas en su lenguaje intermedio, una serie de clases.

Estructura básica de un ensamblado

Los ensamblados más básicos están instalados en el sistema nada más instalar Mono. El sistema que se encarga de organizarlos y evitar problemas de versionado (la propia arquitectura de los ensamblados está orientada a evitar problemas como el infierno de las DLL) es el llamado GAC, The Global Assemblie Cache (la caché global de ensamblados).

Cuando un proyecto Mono hace referencia a un ensamblado busca en tres partes:

1. Primero, en la localización del ensamblado (en la misma ruta)
2. Segundo en la ruta definida por la variable de entorno MONO_PATH
3. Finalmente, pide al GAC el ensamblado si no lo ha encontrado por lo métodos anteriores

¿Cómo referenciar ensamblados desde nuestro proyecto con MonoDevelop?

Ya que conocemos, aunque sea por encima, cómo se organizan las librerías y clases y en Mono, lo siguiente es poner esto que acabamos de explicar en práctica.

Cuando creamos un proyecto en MonoDevelop, de forma automática se añaden los ensamblados básicos para lo que busquemos: proyecto en consola, con GTK#…

Sin embargo, si necesitamos incluir más ensamblados deberemos hacerlo de forma manual. ¿Dónde? En la parte izquierda de nuestra pantalla, tenemos la estructura de la solución. Dentro de ella, tras el nombre, dentro del árbol, hay un nivel que pone: Referencias, hacemos clic derecho sobre él y elegimos Editar referencias….

Se nos abre un diálogo como el que acabamos de mostrar. Se nos presentan tres pestañas:

• Paquetes: Todos los ensamblados que maneja el GAC
• Proyectos: Ensamblados de otros proyectos
• Ensamblados .NET: Cualquier ensamblado en dll o exe que tengamos, podemos unirlo y empezar a trabajar con él

En la siguiente entrega hablaremos de los espacios de nombres y de cómo llamar a las funcionalidades y cómo se estructuran en el código a través de los espacios de nombres.

Entregas anteriores:

• Curso C# con Mono – Variables y constantes
• Curso C# con Mono – Tipos de datos y uso de referencias
• Curso C# con Mono – ¡Hola Mundo!

¿Por qué hablamos hoy de él? Porque Microsoft ha decidido liberarlo bajo una licencia Apache y está disponible dentro de Codeplex (el repositorio de la empresa de Redmond para proyectos de código abierto) el código del compilador y las librerías básicas del lenguaje.

¿Por qué comento esto? Porque de un tiempo para acá, estoy comprobando que Microsoft se está portando con la Comunidad mejor que otras empresas que en otros tiempos eran más aliadas del código libre como Oracle y Apple.

Estoy bastante asustado por el futuro de Java, MySQL y OpenOffice; pero noticias como ésta, aunque sean granos de arena en el desierto, son positivas.

Un par de ejemplos de F# antes de terminar:

(* Esto es un comentario *)
(* Ejemplo de típico ¡Hola Mundo! *)
printfn "Hello World!"

Y una recursividad básica para calcular el factorial:

let rec factorial n =
    match n with
    | 0 -> 1
    | _ -> n * factorial (n - 1)

La idea de este curso no es hablar de qué es una iteración, ni siquiera profundizar en los aspectos más detallados del uso; sino dar unos conceptos breves pero importantes, para que podáis profundizar vosotros mismos.

Introducción

Al igual que en todos los lenguajes en C# existen los tipos de datos. Se tratan de una forma muy similar a Java y como nota destacable sólo comentaré que:

• El carácter por defecto, char, es UNICODE. Es decir no ocupa 8 bits, sino 16, y puede manejar todo tipo de símbolos (acentos, eñes, etc) por defecto.
• Si vienes de C y buscas utilizar enteros: 0 y distinto de 0 (falso o verdadero), el tipo bool es la herramienta para hacerlo.
• Además de los tipos de datos de C# al completo, siempre podrás almacenar en variables referencias a objetos, vectores, etc. o incluso a tipos de datos básicos.

Para pasar referencias a funciones de tipos de datos básicos usamos las palabra claves out y ref (ahora veremos el uso de ambas). Esta es una diferencia relevante con Java, donde las variables de tipos de datos básicos se pasan siempre por valor.

Dualidad objeto/tipo de dato

Al igual que ocurre en Java, los tipos de datos básicos corresponden en realidad a clases. Por ejemplo, el tipo de dato float es en realidad una abreviatura para instanciar la clase System.Single.

Veamos un ejemplo:

float a;
System.Single b = new System.Single();

Estamos declarando, dos variables para almacenar valores en punto flotante de precisión simple de formas. La variable a la declaramos al estilo C y la variable b en realidad representa a una instancia de la clase System.Single.

Si dentro de los using tenemos declarado el espacio de nombres System, se puede hacer directamente: Single b = new Single().

Utilización del parámetro out

Veamos directamente sobre un ejemplo el uso del parámetro out. Inicializaremos dos variables a 0, llamaremos a una función donde variaremos su valor. Tras la asignación volvemos a leer el valor de las variables y comprobamos que han cambiado.

Veamos el código:

public static void Main (string[] args)
{
	int a = 0;
	int b = 0;
	Console.WriteLine("Valor de: a = {0}, b = {1}
        antes de llamar a la función", a, b);
	probarOut(out a,out b);
	Console.WriteLine("Valor de: a = {0}, b = {1}
        tras llamar a la función", a, b);
}
public static void probarOut(out int a, out int b)
{
	a = 100;
	b = 200;
}

Dentro de la función probarOut no hemos intentado leer las variables porque no sería posible. Si queremos hacerlo, de forma similar a lo que haríamos con & en C, debemos usar ref.

El parámetro out se usa en algunas funciones de conversión de datos, por ejemplo, TryParse.

Utilización del parámetro ref

Para terminar con este artículo, veremos el uso de la palabra reservada ref. Haremos una función que intercambie el valor de dos enteros. Previamente los inicializaremos, los imprimimos por pantalla y tras comprobar la llamada a la función, volvemos a imprimir por pantalla para comprobar que su valor ha cambiado.

Veamos el código:

public static void Main (string[] args)
{
	int a = 1;
	int b = 2;
	Console.WriteLine("Valor de: a = {0}, b = {1}
        antes de llamar a la función", a, b);
	intercambiar(ref a, ref b);
	Console.WriteLine("Valor de: a = {0}, b = {1}
        tras llamar a la función", a, b);
}
public static void intercambiar(ref int a, ref int b)
{
	int tmp = b;
	b = a;
	a = tmp;
}

Como veréis, los mecanismos de referencias en C# son mucho más naturales que en Java. Si queremos pasar una referencia de un tipo de dato básico en Java, debemos usar mecanismos como las llamadas: AtomicReference.

Ya sabéis que cuando se trata de objetos que no son tipos de datos básicos, no hay problema.

Entregas previas:

• ¡Hola Mundo!

Puesto que el poder de Microsoft en el mercado de escritorio es innegable, muchos de nosotros, nos veíamos abocados a desarrollar con esta herramienta por desgracia para todos, ya que si al pseudo-monopolio le sumas por un lado tecnología de desarrollo, por el otro el sistema operativo y encima le sumas el entorno de desarrollo… la situación es dramática.

Muchos me comentaréis que hay otras tecnologías que sustituyen muy bien el conjunto formado por .NET en Windows como por ejemplo Java (incluso en Windows). Sin embargo, hay situaciones en las que es imposible buscar alternativa: ya sea por factores técnicos o por obligaciones de superiores.

¿La solución?

La solución a este problema es usar un entorno libre. El entorno, SharpDevelop no tiene mucho que envidiar a Visual Studio y cada año crece y mejora. Con él podemos hacer cualquier aplicación de escritorio de una forma cómoda, gráfica y efectiva, sin tener que usar el IDE de Microsoft. Además se nos abren posibilidades gracias a su integración con otras tecnologías libres como IronPython y está muy relacionado con el proyecto Mono.

El software libre tiene que avanzar en todos los terrenos y nada mejor que hacerlo en pleno territorio enemigo y conseguir quitarle cuota de mercado a unos de los buques insignia de la compañía de Redmond, Visual Studio (que por cierto, es un gran producto… pero no es libre). Por cierto, el enlace a la página de SharpDevelop donde podéis descargarlo es éste.

Cuando el otro día hablábamos de cómo ejecutar un programa Windows sobre Linux con Wine, nos preguntaron por los programas que están implementados con .NET, que por cierto cada día son más en plataformas Windows.

Desde estas líneas os recuerdo que al igual que Java, .NET es una plataforma pensada para tener un carácter multiplataforma (aunque en la realidad el grado de compatibilidad es mucho menor) por lo que con una máquina virtual que soporte la ejecución de dicho programa a priori no habría problema.

¿Existe un entorno de ejecución de .NET en Linux? Sí que existe, es Software Libre y es uno de los proyectos libres que más me interesan (por suerte o por desgracia trabajo a diario con entornos .NET en mi trabajo). Hablamos del Proyecto Mono y he de deciros que es uno de los proyectos más polémicos de todo el universo libre por razones de cercanía a Microsoft.

Ejecución

Un ejecutable creado con .NET para plataformas de escritorio podemos ejecutarlo directamente desde la consola con la siguiente orden:

$ mono fichero.exe

Tendremos que tener instalado el entorno de ejecución de Mono (normalmente llamado mono-runtime si queréis buscarlo en vuestro gestor de paquetes).

Es muy posible que el instalador del programa que queremos ejecutar no esté implementado en Mono, por lo que habría que seguir dos pasos:

1. Ejecutar el instalador con Wine
2. Buscar la ruta dónde se ha instalado y ejecutarlo con Mono. Os doy un consejo, mirar en vuestro directorio home la carpeta “.wine”, dentro de ella “drive_c” y ahí “Archivos de programa”, al más puro estilo Windows.

En ese directorio: $HOME/.wine/drive_c tendréis una emulación del disco principal del sistema imitado por Wine.

Hace ya unos cuantos meses escribí para Linux+ un artículo sobre esto que os comento hoy, una introducción al desarrollo de aplicaciones web con Mono. Concretamente fue en el número de febrero. Ha pasado el tiempo y la editorial ha tornado sus miras hacia un entorno más abierto. Primero fue el lanzamiento de la revista en formato PDF y de distribución gratuita (antes era de papel y costaba unos cuantos euros) y ahora han lanzado un blog, llamado Revista Linux, donde irán publicando los artículos más relevantes de la revista en formato post, lo que seguro que tanto vosotros como los motores de búsqueda lo agradeceréis.

Uno de los primeros artículos que han publicado es este que os comento, aquí tenéis el enlace al mismo y un desglose de su contenido.

Introducción al desarrollo de aplicaciones web con Mono

1. Introducción
2. Preparación e instalación
   1. XSP
   2. Apache con mod_mono
      1. Instalación
      2. Prueba
      3. Eliminación de un sitio
3. Ejemplos de interacción con MySQL
   1. Instalación de la base de datos y creación de los datos de ejemplo
   2. Descarga y activación del conector
   3. Código del ejemplo y archivo de configuración
   4. Aplicando estilos
4. Conclusiones

Las palabras clave son: #region y #endregion para indicar el comienzo y el fin de la región, respectivamente. Podéis ver el resultado en las siguientes imágenes, como podéis apreciar MonoDevelop te genera un extracto del contenido de la región:

Debido a que utilizo SharpDevelop, software libre para desarrollo .NET en plataformas Windows, en el trabajo hace tiempo ya descubrí que existía la posibilidad de hacer desarrollos para el intérprete de .NET/Mono en lenguaje Python. Posteriormente, hace no mucho viendo un vídeo de Miguel de Icaza, comprobé que el padre de Gnome también hablaba de esta misma posibilidad.

Pasado el tiempo y como veo que es un tema que puede interesar a muchos os presento a IronPython.

¿Qué es IronPython?

Es una implementación del intérprete de Python sobre en entorno de trabajo de .NET/Mono de forma que podemos compilar código Python a código intermedio CLI de entornos .NET/Mono con las ventajas que puede traernos ésto en entornos Windows.

Boo

Los que estéis metido dentro del mundo del software libre en plataformas Windows y sobre todo en el mundo del Proyecto Mono, conoceréis a Boo. Boo es un lenguaje de programación de la familia .NET/Mono con una sintaxis muy parecida a Python pero que no llega a ser exactamente igual. El desarrollador de Python se sentirá cómodo con Boo pero no llegará a poder compilar ni interpretar su código Python directamente.

IronPython

Con IronPython este problema no existe porque de hecho se pueden incluso compilar paquetes de Python, tal como pude leer hace dos días en el blog oficial de desarrollo de SharpDevelop. Las ventajas de usar IronPython son muchas y todo el que esté obligado a desarrollar en Windows por cualquier razón lo debería contemplar como una opción.

Aparte de las ventajas y de la facilidad que nos transmite Python tenemos a nuestra disposición las bibliotecas propias de .NET con las ventajas de integración y facilidad de desarrollo que esto supone en los sistemas de la factoría de Redmond.

Os dejo un enlace a la web oficial de IronPython y os invito a que probéis esta tecnología con el IDE libre para .NET/Mono en Windows, SharpDevelop.

Introducción

Ya que no hay demasiado documentación de Mono en la red y creo que es una alternativa muy válida para muchos proyectos, voy a seguir publicando más tutoriales y tips sobre este tema.

Mi intención hoy es comentar cómo referenciar el conector de MySQL dentro de un proyecto de Mono con MonoDevelop, de forma que podamos utilizarlo con la arquitectura y las funcionalidades de ADO.NET para manejar datos con un servidor de base de datos MySQL. El conector os valdrá tanto para aplicaciones web como locales.

Si no conocéis ADO.NET os recomiendo que os leáis el artículo al que os referencio de la Wikipedia porque realmente es una arquitectura muy útil para el manejo de datos, aunque los más puristas la rechazarán por venir de Microsoft.

Instalación

Lo primero será estar seguros de que tenemos instalados Mono, MonoDevelop y que tenemos a nuestro alcance un servidor de MySQL al que conectarnos. Si no lo tenéis instalados podéis instarlo prácticamente seguro desde vuestro gestor de paquetes y en todo caso, desde la web oficial del Proyecto Mono. Una vez hecho esto descargaremos el conector desde este enlace en la web de MySQL. Elegimos la plataforma: “.NET & Mono”. Se os descargará un fichero dll con los ensamblados correspondientes.

Referencia dentro de un proyecto

Ahora nos dirigimos a Mono Develop y creamos una solución nueva (da igual si de consola o GTK#). Al crearse la solución nos dirigimos a las Referencias del proyecto y desde allí importamos el ensamblado. Para ello seleccionáis  “Editar referencias…”. De las tres opciones que aparecen en el diálogo entramos en “Ensamblado .NET”, elegimos el fichero dll que acabamos de descargar y lo añadimos.

Prueba

Para terminar vamos a probar que todo está bien. En el Main.cs vamos a implementar el típico ¡Hola Mundo!, añadiéndole al comienzo una referencia al conector. Si compila correctamente hemos llegado a nuestro objetivo.

using System;
using MySql.Data.MySqlClient;
namespace ejemplo_mono_ado
{
	class MainClass
	{
		public static void Main(string[] args)
		{
			Console.WriteLine("Hello World!");
		}
	}
}

En un futuro post explicaré más sobre el uso y la potencia de esta herramienta.

¿Por qué escoger este binomio en lugar de XSP? La respuesta es fácil: XSP es un servidor de pruebas, no de producción y si queremos tener un servicio o aplicación web ejecutando de forma decente en producción, mejor utilizar Apache y mod_mono. Las razones no son sólo por la escalabilidad y eficiencia que permite Apache, sino que están relacionadas por la seguridad que provee el servidor más utilizado a nivel mundial y por la gran variedad de opciones que nos ofrece.

De todas maneras sigo pensando que al igual que el servidor de pruebas de Django es útil para las pruebas, XSP es un buen servidor de pruebas para practicar con nuestro PC cuando estemos aprendiendo ASP.NET. Cuando la aplicación se hace compleja y sobre todo queramos pasarla a producción, Apache.

Instalación y configuración

Como consecuencia de esto que os cuento, desde siempre he tenido un interés especial por poder crear mis desarrollos utilizando esta tecnología en Linux. El Proyecto Mono proporciona prácticamente todas las posibilidades de la plataforma, con software libre y para todo tipo de entornos y sistemas (cierto es que está verde en algunas parte pero por lo general está muy depurado y tiene muchas posibilidades).

Bueno a lo que íbamos. Entre las posibilidades del Proyecto Mono también se encuentra la creación y ejecución de aplicaciones web. Para ello nos proporciona un servidor ligero escrito en C# (aunque a algunos ambos términos a la vez le resulten opuestos) llamado XSP y que para pequeñas aplicaciones de producción y para desarrollo es muy válido. Para aplicaciones de más tamaño, recomiendo utilizar Apache con mod_mono.

¿Cómo instalar y configurar XSP?

Siempre tendréis la opción de descargar del SVN la última versión estable, pero os recomiendo instalarlo mediante vuestro gestor de paquetería. El paquete en cuestión se llamará, dependiendo del repositorio, mono-xsp o mono-xsp2 (en caso de estar disponibles ambos, elegid el que soporta ASP.NET 2, es decir, mono-xsp2).

Una vez hecho esto poco más hay que hacer. Lo mejor es descargarse el paquete con los ejemplos, su nombre será algo así como: asp.net2-examples. Tras instalarlo ya podéis probar

1. Antes de nada deberéis moveros al directorio de los ejemplos: /usr/share/asp.net2-demos/
2. Arrancamos el servidor: xsp2
3. Introducimos en nuestro navegador la siguiente dirección (puerto 8080 de nuestro equipo): http://localhost:8080.
4. Veremos los ejemplos. A partir de ahí… ya tenéis camino libre para desarrollar aplicaciones ASP.NET con Linux.

Parece que el post ha aparecido en Menéame. Si os ha gustado ya sabéis, menearla.