Las gemas de Ruby son paquetes de librerías para Ruby que se instalan en el sistema y quedan listas para ser usadas, con un simple require o con mecanismos que aporta el propio sistema de gemas para Ruby.

El gestor de gemas: rubygems

En distribuciones de GNU/Linux, e instalaciones automáticas para Windows, se nos habilita un comando, generalmente, que nos permite agregar librerías y código de un repositorio muy extenso de código listo para usar. Esto es conocido como el gestor de gemas, rubygems, o simplemente gem.

El gestor de gemas es un comando que nos permite listar las gemas instaladas, buscar gemas remotas o localmente (de las instaladas), instalar, actualizar y eliminar gemas. Se puede saber si está instalado simplemente ejecutando:

gem --version

La última versión a día de hoy es la 1.8.12, actualizar el sistema de gemas es tan simple como ejecutar:

gem update --system

Instalar una gema

Por ejemplo, si queremos usar el código siguiente:

require "rubygems";
require "json";
 
puts [ "hola a todos", 12, "C/Sin nombre, 25" ].to_json

Tendremos que instalar previamente la gema json. Para instalarla, solo tenemos que ejecutar el siguiente comando:

$ sudo gem install json
[sudo] password for marubio: 
Building native extensions.  This could take a while...
Successfully installed json-1.6.4
1 gem installed
Installing ri documentation for json-1.6.4...
Installing RDoc documentation for json-1.6.4...

Como se puede apreciar, se instala la gema y se genera la documentación para ri y rdoc. La generación de la documentación es bastante lenta y si tenemos que instalar muchas gemas, puede ser algo tedioso. Se puede eliminar esta tarea agregando al comando de instalación: --no-ri --no-rdoc

Ahora, cuando listemos los paquetes instalados podremos ver:

$ sudo gem list
 
*** LOCAL GEMS ***
 
json (1.6.4)

Nos indica la versión, ya que podríamos tener varias versiones instaladas y conviviendo, y desde el código emplear la que requiramos específicamente. Si queremos instalar una versión específica de un paquete, podemos hacerlo agregando la opción, por ejemplo: --v=1.6.1

Buscando una gema

Si queremos buscar una gema específica del directorio de gemas, podemos hacerlo a través de la propia página web: RubyGems; o a través del comando:

$ gem search -r jsonn
 
*** REMOTE GEMS ***
 
active_record_serialize_json (0.1.2)
activejson (0.1.2)
activeresource_json_patch (0.0.1)
assert_json (0.1.1)
capcode-render-json (0.2.0)
capybara-json (0.1.1)
colorful_json (0.9.1)
csv2json (0.2.0)
cucumber-json (0.0.2)
dm-json-search (0.0.3)
[...]

La base de datos de gemas tiene la friolera de más de 32 mil gemas, por lo que, no es de extrañar que ante algo trivial (como JSON) puedan aparecer cientos de gemas. A la hora de buscar deberemos de ser más precisos con los términos a elegir.

Conclusiones

Ha sido una introducción muy ligera a este entorno de gestión de paquetes de Ruby, lo sé, pero al menos complementa un poco la entrada de hace algunos meses sobre Bundler y da un poco de información sobre los comandos más usuales a la hora de instalar una librería en Ruby, ya sea para código scripting o para Rails.

Versión PHP

Empezaremos con la complicada. Este código se encarga de descargar el código del RSS y deserializar el XML en un array, para poder tratarlo a posteriori. El tratamiento lo haré en plan cutre, ya que me intentaré, sobretodo, basar en el proceso de descarga y deserialización.

Para esto, se requiere de una librería que no suele venir con PHP, pero sí está en PEAR, con lo que, se puede instalar fácilmente ejecutando la siguiente línea de comandos:

pear install XML_Serializer

Con esto, el código, en plan simple, sería el siguiente:

<?php
 
 
include 'XML/Unserializer.php';
 
function xml_to_array( $data ) {
    $options = array(
        "addDecl"            => true,
        "encoding"           => "utf-8",
        "mode"               => XML_SERIALIZER_MODE_SIMPLEXML,
        "indent"             => "    ",
        "linebreak"          => "\n",
        "scalarAsAttributes" => true,
        "attributesArray"    => '_a',
        "contentName"        => '_c',
        "rootName"           => 'rss'
    );
 
    $unserializer = new XML_Unserializer($options);
    $unserializer->unserialize($data);
    $doc = $unserializer->getUnserializedData();
 
    return $doc;
}
 
$data = xml_to_array(file_get_contents('http://www.debian.org/News/news'));
?>
<html>
<body>
    <? foreach ($data["item"] as $noticia) { ?>
    <h1><a href="<?=$noticia["link"]?>"><?=$noticia["title"]?></a></h1>
    <p class="date"><?=date("d/m/Y H:i", strtotime($noticia["dc:date"]))?></p>
    <p class="desc"><?=$noticia['description']?></p>
    <? } ?>
</body>
</html>

No pinta mal, conseguimos lo que nos proponemos sin tener muchas complicaciones.

Ahora la versión bonita

En Rails las cosas siempre tienden a ser más simples, o al menos mucho más cortas, muestra de ello, es la versión del código anterior en versión Rails. Este sería:

  def noticias
    require 'rss/1.0'
    require 'rss/2.0'
    require 'open-uri'
 
    source = "http://www.debian.org/News/news"
    content = ""
    open(source) do |s| content = s.read end
    @rss = RSS::Parser.parse(content, false)
  end

Aunque he puesto los require dentro de la función, realmente podrían ponerse en otro sitio (como en environment.rb) y no requieren de la instalación de ninguna gema extra. En la vista sería tan solo usar el código de la siguiente forma:

<% @rss.items.each do |i| %>
    <h1><%= link_to i.title, i.link %></h1>
    <p class="date"><%=i.date.strftime("%d/%m/%Y %H:%M")%></p>
    <p class="desc"><%=simple_format(i.description)%></p>
<% end %>

Los helpers ayudan bastante en la creación del código, haciendo que los enlaces se hagan de forma simple, así como el formateado de la fecha, y el parseo del texto para HTML.

Conclusiones

He estado revisando el repositorio PEAR, donde he podido ver que había un par de paquetes de RSS, uno de ellos sin mantenimiento ya (XML_RSS), y el resto de blogs que he visitado lo hacen como he mencionado, por lo que, obliga a conocer los distintos formatos de los que se van a rescatar noticias, ya sean Atom, RSS (la versión que corresponda), etc. Me parece que en este sentido Rails ha demostrado ser más serio o aplicado.

En principio, podemos decir que una de las grandes mejoras (para muchos), es que ya no trae por defecto prototype, sino que se han decantado por jQuery. No obstante, como todavía hay gente que considera el uso de prototype para sus desarrollos, pues lo que han hecho es que por defecto se instala jQuery, pero se puede indicar a través de una opción que se instale en su lugar prototype. Esto es gracias a que han extraído estas librerías a gemas independientes: prototype-rails y jquery-rails.

En segundo lugar, y siguiendo con el tema de la parte cliente, han integrado unos asset pipelines, que facilitan la generación de código CSS y JavaScript a través de elementos como CoffeeScript, Sass, Less… y todos ellos a través de Sprockets.

Con el uso de Ruby 1.9.2 (o Rubinius o JRuby en modo 1.9) y un servidor como Unicorn, podemos emplear otra de las nuevas características: HTTP Streaming. Esta característica permite la descarga de las imágenes, elementos CSS y JS, mientras se genera la vista del HTML.

Otra de las ventajas que sobresale en esta versión es el Identity Map. Esta característica de Rails, más en concreto de ActiveRecord, hace que cuando un objeto se rescata de la base de datos, si se solicita de nuevo el mismo objeto, no se solicite de nuevo, sino que se tome el que ya está recogido y en memoria. Esto lo hace solo para los objetos que se instancian en la petición en curso y que son eliminados de la caché cuando la petición finaliza.

El resto ya son mejoras menores, como:

• El uso de JSON en lugar de XML para el scaffold.
• La creación de helpers para la autenticación de HTTP Basic y Digest.
• El uso del método change en lugar de up y down en las migraciones, generando la marcha atrás el sistema de forma automática.
• El uso de up y down como métodos de objeto y no de clase.
• La posibilidad de crear serializadores de forma fácil (los de XML y JSON vienen por defecto).
• y muchas más…

Para más información, puedes leer la ficha de liberación completa (en inglés).

Realmente, Rails está avanzando mucho y desde que comencé a usarlo, hará ya tres años, lo he visto agregar cada vez más nueva tecnología y elementos que me han ayudado a aprender mucho sobre el desarrollo profesional de entornos web. Así da gusto.

Antes de comenzar, conviene que definamos un poco lo que es el modelo Actor. Según la wikipedia (versión inglesa) el modelo Actor es: un modelo matemático de computación concurrente que trata a los “actores” como las primitivas universales de la computación concurrente digital: en respuesta a mensajes que recibe, un actor puede tomar decisiones locales, crear más actores, enviar más mensajes y determinar cuando responder al siguiente mensaje recibido.

En este artículo me gustaría centrarme en Celluloid, un framework del modelo Actor para Ruby. Este framework nos permite tratar las instancias de los objetos como procesos autónomos, concurrentes, que atienden peticiones y mantienen su memoria, sin posibilidad de que pueda ser corrompida por dos mensajes simultáneos.

Un ejemplo de código de la propia página web, haciendo alusión al actor… vamos a castellanizarlo un poco:

class Bardem
  include Celluloid::Actor
 
  def initialize(nombre)
    @nombre = nombre
  end
 
  def pon_estado(estado)
    @estado = estado
  end
 
  def informa
    "#{@nombre} está #{@estado}"
  end
end

Para poder probarlo necesitamos de un entorno de pruebas que nos permita la ejecución de este código. Yo suelo usar rvm para poder instalar entornos de ruby de forma cómoda y poder probarlos, por lo que, solo hay que poner en consola:

rvm install 1.9.2-celluloid
rvm use 1.9.2-celluloid
gem install celluloid

IMPORTANTE: tener presente que Celluloid solo funciona en JRuby en modo 1.9, en Rubinius y en Ruby a partir de la versión 1.9.2, ya que las anteriores no tienen hilos de estado concurrente real.

En una consola de irb, se podría ejecutar lo siguiente:

ruby-1.9.2-p180 :001 > require "celluloid"
 => true
ruby-1.9.2-p180 :002 > require "./bardem.rb"
 => true
ruby-1.9.2-p180 :003 > javier = Bardem.spawn "Javier Bardem"
 => #
ruby-1.9.2-p180 :004 > javier.pon_estado "ha ganado!"
 => "ha ganado!"
ruby-1.9.2-p180 :005 > javier.informa
 => "Javier Bardem ha ganado!"
ruby-1.9.2-p180 :006 > javier.pon_estado! "gana asincronamente!"
 => nil
ruby-1.9.2-p180 :007 > javier.informa
 => "Javier Bardem gana asincronamente!"

Cuando se llama a spawn se crea el objeto dentro de su propio hilo. El paso de mensajes se realiza usando el manejador del actor específico (javier en este caso) y se puede pasar un mensaje de forma síncrona (esperando su resultado) o de forma asíncrona (con la exclamación) sin esperar a que retorne nada.

Supervisores

Los supervisores, son procesos que se encargan de supervisar que un proceso está levantado y funcionando (como los monitores), pudiendo reiniciarlos cada vez que se caen. Por ejemplo, podemos crear un supervisor del ejemplo anterior de la siguiente forma:

ruby-1.9.2-p180 :008 > penelope = Bardem.supervise "Javier Bardem"
 => #
ruby-1.9.2-p180 :009 > javier = penelope.actor
 => #

Así, creamos un supervisor (penelope) que supervisa al actor Javier Bardem. También podemos asignar un nombre al actor, de modo que:

ruby-1.9.2-p180 :011 > Bardem.supervise_as :javier, "Javier Bardem"
 => #
ruby-1.9.2-p180 :012 > javier = Celluloid::Actor[:javier]
 => #

De modo que el símbolo :javier se relacione con el proceso y pueda emplearse en lugar de Javier Bardem, cuando se realice una llamada.

Enlazado

Si se sucediese una excepción no manejada en cualquiera de los métodos del actor, ese actor se caería y moriría. Vamos a poner un ejemplo:

class JamesDean
  include Celluloid::Actor
  class CarInMyLaneError < StandardError; end
 
  def drive_little_bastard
    raise CarInMyLaneError, "that guy's gotta stop. he'll see us"
  end
end

Ahora, vamos a poner a James en el coche Little Bastard conduciendo y veamos que sucede:

ruby-1.9.2-p180 :001 > require "celluloid"
 => true
ruby-1.9.2-p180 :002 > require "./james_dean.rb"
 => true
ruby-1.9.2-p180 :003 > james = JamesDean.spawn
 => #
ruby-1.9.2-p180 :004 > james.drive_little_bastard!
 => nil
E, [2011-10-05T17:54:33.582990 #3929] ERROR -- : JamesDean crashed!
JamesDean::CarInMyLaneError: that guy's gotta stop. he'll see us
/home/marubio/tmp/james_dean.rb:6:in `drive_little_bastard'
[...]
ruby-1.9.2-p180 :005 > james
 => #

Cuando le dijimos a james de forma asíncrona que condujese Little Bastard, ¡lo mató! Si fuésemos Elizabeth Taylor, co-protagonista de la última película al tiempo de su muerte, querríamos saber cuando murió. ¿Cómo podemos hacer eso? Enlazando a los actores que estén interesados en las caídas de otros actores. Para recibir estos eventos, necesitamos usar el método trap_exit. Un ejemplo:

class ElizabethTaylor
  include Celluloid::Actor
  trap_exit :actor_died
 
  def actor_died(actor, reason)
    puts "Oh no! #{actor.inspect} ha muerto por #{reason.class}"
  end
end

Por lo que al ejecutar lo siguiente, obtenemos:

ruby-1.9.2-p180 :001 > require "celluloid"
 => true
ruby-1.9.2-p180 :002 > require "./james_dean.rb"
 => true
ruby-1.9.2-p180 :003 > require "./elizabeth_taylor.rb"
 => true
ruby-1.9.2-p180 :004 > james = JamesDean.spawn
 => #
ruby-1.9.2-p180 :005 > elizabeth = ElizabethTaylor.spawn
 => #
ruby-1.9.2-p180 :006 > elizabeth.link james
 => #
ruby-1.9.2-p180 :007 > james.drive_little_bastard!
 => nil
E, [2011-10-06T11:26:31.659461 #8552] ERROR -- : JamesDean crashed!
JamesDean::CarInMyLaneError: that guy's gotta stop. he'll see us
ruby-1.9.2-p180 :008 > Oh no! # ha muerto por JamesDean::CarInMyLaneError

Como vemos, Elizabeth es notificada inmediatamente a través del trap, permitiéndole reaccionar ante la caída de James. Pero también podríamos querer lanzar un objeto y enlazarlo al mismo tiempo.

Conclusiones

El resto del tutorial (en inglés) se encuentra en la página oficial de Celluloid, donde se mencionan otras formas de enlazado, registro y logs. Yo me quedo en este punto, porque creo que ha sido suficiente para adentar la programación de Modelo Actor al lenguaje Ruby. Espero que os sirva para resolver algún que otro problema de programación en el que usualmente se empleen semáforos, monitores o memoria compartida.

Orientación a Objetos, no a Clases

Teniendo en cuenta de que Ruby es un lenguaje orientado a objetos (y no a clases), huelga decir que, no solo se puede redefinir una clase (es decir, el objeto plantilla del que se generan otros objetos), sino que también se puede redefinir un objeto instanciado sin que afecte al resto de objetos del mismo tipo.

Sobre la orientación a objetos de Ruby, vamos a hacer este simple ejercicio desde irb para que se pueda ver algo más claro:

class A
end
 
a = A.new
 
a.class   # A
A.class  # Class
Class.class # Class

Como se puede ver, el objeto a es de tipo A, el objeto (que no clase) A es de tipo Class, y el objeto (que tampoco clase) Class es recursivo en sí mismo, ya que Class es el tipo raíz del que parten todos los objetos… como en Java lo es Object.

Reescribiendo Clases

Una de las mayores potencias de Ruby, es que una clase definida, se puede redefinir, ya sea para cambiar un comportamiento específico, o para agregarle mayor funcionalidad. Esto de cara a la programación orientada a objetos, es una aberración, realmente, porque rompe la encapsulación… peeeero, de cara al pragmatismo, es muy útil poder modificar un comportamiento general para adaptarlo a uno específico sin necesidad de tener que reescribir de qué clase se hereda.

Haciendo una prueba:

class A
end
 
a = A.new
puts a    # #<A:0x000000000000>
 
class A
  def to_s
    "Clase A"
  end
end
 
puts a    # Clase A
 
b = A.new
 
class << b
  def to_s
    "objeto b"
  end
end
 
puts b    # objeto b
puts a    # Clase A

Con esto se puede comprobar, que la redefinición de métodos se puede conseguir, tanto para objetos como para clases.

Y ahora… el yield

Otra de las potencias de Ruby es que, podemos definir un código, dejando una definición a medias para poder ampliarla en el momento el que sea llamada, por ejemplo:

def ordena( vector )
     (0..(vector.size-2)).each do |i|
         k = i
         (i+1..(vector.size-1)).each do |j|
             k=j if yield(vector[k], vector[j])
         end
         if k!=i
             tmp = vector[k]
             vector[k] = vector[i]
             vector[i] = tmp
         end
     end
end
 
vector = [ 5, 3, 2, 4, 6, 1 ]
 
ordena(vector) do |e1, e2|
    (e1 > e2)
end
 
puts vector  # [1, 2, 3, 4, 5, 6]
 
ordena(vector) do |e1, e2|
    (e1 < e2)
end
 
puts vector  # [6, 5, 4, 3, 2, 1]

En este ejemplo de código, la función yield no está definida, sino que equivale al bloque de código que se especifica más tarde, cuando se llama a la función ordena, en el caso mostrado, es como si las funciones yield fuesen en el primer caso:

def yield(e1, e2)
    (e1 > e2)
end

Y en el segundo caso, exactamente igual pero cambiando la comparación para que la ordenación sea en sentido descendente.

La definición del código es in-situ, en el momento de usarse es cuando se especifica qué hace yield.

Se puede hacer algo más complejo, por ejemplo, cambiando el array de enteros por un array de objetos específicos que tengan una comparación algo más complicada. Aún así, el código de ordena no habría que cambiarlo. Solo la llamada, y su bloque adjunto.

Conclusiones

Para los que no conozcan bien Ruby, esto les habrá sonado a chino, para los que lo conozcan bien, quizás algo ya más que sabido, pero lo importante, es que se tenga claro el concepto y lo que se puede hacer, ya que, la necesidad, de seguro, surgirá después.

La verdad es que, en el momento que vi el fichero de Gemfile, queda clara la misión de dicho fichero, ya que viene con una colección básica de gemas que se suelen instalar de forma base cuando se trabaja con rails (out of the box) y unos comentarios de gemas que aconsejan para ciertos usos cotidianos (opcionales).

Indagando un poco, topé con su web, en la que viene cantidad de documentación sobre su uso y, ejecutando, simplemente, desde la consola:

bundle install

Me encuentro con que el sistema comienza a instalar rails y todos los paquetes base necesarios para poder tener el proyecto activo y funcionando sin problemas.

Esta es otra de las joyas que hacen que Ruby on Rails sea fácil de usar para el desarrollo rápido de aplicaciones web. Lo recomiendo, merece la pena.

Hola 1
Hola 4
Hola 9
Hola 16
...

He realizado las pruebas en los lenguajes: C, Perl, Ruby, Python, PHP, Lua, Shell script, Erlang script y Java.

C

En lenguaje C se ha realizado el siguiente código:

#include <stdio.h>
 
main() {
        int i;
 
        for (i=0; i<100000; i++) {
                printf("Hola %d\n", i*i);
        }
}

Perl

En el lenguaje Perl, se ha implementado el código siguiente:

#!/usr/bin/perl
 
for ($i=0; $i<100000; $i++) {
        print "Hola " . ($i*$i) . "\n";
}

Ruby

En Ruby, el código escrito ha sido:

#!/usr/bin/ruby
 
(1..100000).each do |i|
        puts "hola " + (i*i).to_s
end

Python

En Python, el código ha sido:

#!/usr/bin/python
 
for i in range(1,1000000):
        print "Hola " + str(i*i)

PHP

En PHP el código escrito ha sido:

#!/usr/bin/php -q
<?php
 
for ($i=0; $i<100000; $i++) {
        print "Hola " . ($i*$i) . "\n";
}

Lua

El código de Lua escrito ha sido:

#!/usr/bin/lua
 
for i=1,100000 do
        print("Hola " .. (i*i))
end

Shell script

En shell script (en bash) se ha implementado lo siguiente:

#!/bin/bash
 
for i in $(seq 1 100000); do
        let RESULT=$i*$i
        echo "Hola $RESULT"
done

Erlang (Script)

Erlang también puede emplearse como lenguaje de scripting usando el intérprete escript. El código escrito para este intérprete ha sido:

#!/usr/bin/escript
 
main(_Args) ->
        loop(100000).
 
loop(0) -> 0;
loop(I) ->
        io:format("Hola ~p~n", [I*I]),
        loop(I-1).

Java

El código que se ha usado para la prueba de Java ha sido:

public class loop {
        public static void main( final String[] args ) {
                for (int i=0; i<100000; i++) {
                        System.out.println("Hola " + (i*i));
                }
        }
}

Resultado de las pruebas

Tras ejecutar 5 veces cada script, controlando el tiempo que toma cada uno hemos obtenido, según el equipo en el que se ha ejecutado. El equipo 1 es un Intel vPro con Debian GNU/Linux Lenny:

En el equipo 2, un Apple iBook G4 (PowerPC):

Ordenados por velocidad, se ve que el lenguaje C, como cabía esperar, es el más rápido, seguido de Perl, como el lenguaje de scripting más rápido.

Después de esta acción, shoes murió… era muy complicado encontrar un sistema shoes que funcionase y se compilase con las nuevas versiones de ruby, así como un tutorial tan completo como el que tenía why en su propia página web.

No obstante, en este mismo año, mental y más gente en la red, ha ido recopilando de las cachés y de lo que guardaban entre unos y otros y, amparándose en las licencias con las que fueron publicadas cada cosa, han vuelto a poner, eso sí, en otros enlaces distintos, cada una de las cosas que why dió de baja de Internet (salvo su twitter, claro).

La nueva web: http://hacketyhack.heroku.com

El código fuente se puede descargar de aquí.

Este libro, escrito por uno de los firmantes del manifiesto ágil (Dave Thomas) y otro de ellos como co-autor (Andy Hunt), es un libro que tiene en su interior, no solo el aprendizaje del lenguaje en sí, sino de una metodología de programación, una suma de buenas prácticas de programación que se orientan a sacar el mejor partido del lenguaje potenciando sus fortalezas y aprovechándolas con patrones de desarrollo ágiles que mejoran y potencian su uso.

Recomiendo el libro a todos aquellos que quieran adentrarse en la programación en ruby de la mano de personas que desarrollan día a día con él desde hace mucho tiempo, y no se han quedado estancadas (prueba de ello es que este libro es segunda edición y en 2008 salió la tercera edición, el cual no he podido leer aún, pero promete mayor y mejor contenido).

El mundo .NET

Como todo lo que tiene que ver con Microsoft, el mundo .NET se mueve, casi exclusivamente, con productos y herramientas desarrolladas por esta misma compañía. Funciona sobre Windows, con base de datos de Microsoft y se diseña con herramientas de Microsoft.

Lo bueno de Microsoft es que desarrollan los productos para un público general y sin conocimientos extensos. Los lenguajes suelen ser o muy fáciles (Visual Basic) o muy complejos (C++, C#), pero cumplen con todas las necesidades de los programadores a los que van dirigidas las herramientas. Así mismo, tienen un alto nivel de operatibilidad entre los diferentes productos, es decir, escribir código ASP con SQL Server es simple, gracias a ese nivel de compactación y simplificación.

Lo bueno de la simplificación lleva a lo malo de la complejidad también. Un programa que se hace de forma simple y fácil, siguiendo los pasos que Microsoft ha pensado para dar es simple, sencillo y rápido. Pero cuando la aplicación debe tener una forma específica o salirse un poco del camino típico, comienzan a surgir problemas solo saldables con código complejo.

Ximian, absorbida por Novell, ha realizado muchas aproximaciones a este mundo para portarlo al mundo del software libre a través de su escritorio Gnome y su proyecto Mono. No obstante, es un tema un poco espinoso, ya que quien usa software libre, por lo general, se aleja de las tecnologías propuestas por esta gran multinacional, por lo que, aunque es usada y tiene su cuota de mercado, Mono no llega a ser usado tanto como podría esperarse.

El mundo Java

El mundo de Java ha estado siempre en una lucha constante y abriéndose camino en el desarrollo de software, sin mucho éxito al principio, sobre todo en lo que respecta a las aplicaciones de escritorio. Esto fue debido a su naturaleza de pseudo-compilación y pseudo-interpretación, ya que es un lenguaje compilado e interpretado que se ejecuta sobre una máquina virtual, y las labores de interpretación de los bytecodes son algo costosos, en relación a código que se ejecuta de forma nativa.

No obstante, en la parte web, de interfaces, desde que comenzó, ha tenido una gran aceptación, puesto que permite el desarrollo de las aplicaciones en cualquier infraestructura (windows, linux, solaris, …) y se han desarrollado grandes herramientas para el desarrollo en este sentido.

Java siempre es el favorito y preferido de las consultoras (a menos en España), donde es empleado para el desarrollo de aplicaciones, tanto de escritorio como web en todos los sectores donde son contratados.

La mayoría de empresas que han tenido relación con Microsoft y han salido de malas con la grande, han terminado montándose al carro de Java y aportando a esta comunidad en modo de open source herramientas, conocimiento, etc. Además de Sun Microsystems (su fundadora), hay otras como IBM, RedHat, Oracle, etc. que se han sumado al carro de Java para el desarrollo y ampliación de esta comunidad.

Hay comunidades de software libre que se han sumado a la aportación de código para el mundo Java. Esto supongo que será erróneamente aportado como el voto útil, sin saber que en nada se beneficia al software libre en sí, sino solo al mundo Java que, aunque pueda parecer atractiva la idea de luchar contra el tirano, no es más que ayudar a una empresa a derrocar a otra. Esto puede ser muy discutible, sobre todo por los defensores de Java

El mundo del software libre

Al margen de la guerra entre .Net y Java, surgen los entornos, sistemas y elementos de software libre. Pensar que todo el mundo tiene que ser Java o .Net es un craso error, ya que hay muchos elementos que se pueden combinar a gusto propio del desarrollador y emplearlos como mejor convenga para obtener los mejores resultados para una tarea concreta.

A este respecto, una de las comunidades con más auge es la de desarrolladores de PHP, por ejemplo, que es el lenguaje que más proyectos de software libre tiene desarrollados, y es el más usado para el desarrollo de sitios como Facebook, Menéame, WordPress, etc.

Otra de las comunidades más activa en los entornos web es la de Ruby, Ruby on Rails más específicamente, que tiene un entorno fácil y profesional para el desarrollo rápido de sitios web. También Python, con su framework Django. Ambos presentes en el mundo Java a través de JRuby y Jython, respectivamente.

Entornos también desarrollados en lenguajes más específicos como Perl, Erlang, Tcl, etc. hacen que se complete el abanico de posibilidades para el desarrollo de software a través de las soluciones que aporta el software libre.

La nota negativa, es que los elementos no son altamente cooperativos, es decir, aunque se basan en estándares, normas y todos son abiertos, hay que realizar desarrollos para poder tener funcionando cosas entre unos y otros, debido a que en el software libre, no todo está hecho o viene dado fácilmente. Pero la nota positiva sobre esto, es que la dificultad que eso entraña es mucho menor que la que entrañaría el desarrollar algo no hecho o no pensado para hacerse, en Java o .Net.

Conclusión

En principio, no te quedes solo con uno, esto no son tres equipos a los que haya que apoyar a muerte, estas son tres formas de ver la tecnología y puede convenir cualquiera de las tres según el contexto en el que haya que ponerse.

Por ejemplo, en una empresa que se haya invertido en infraestructura y software Microsoft, se tenga todo montado en SQL Server, con ASP e interfaces desarrolladas en Visual Basic, desarrollar cualquier nueva ampliación o una nueva herramienta, cabe pensar que será siempre más fácil si nos ceñimos a lo ya establecido que si comenzamos a cambiar lo que hay.

Igualmente, en otra empresa en la que se haya realizado una inversión para Java, incluso con servidores Solaris, y bases de datos Oracle, no conviene pensar en desarrollar nada con Visual Basic, ni PHP, sino pensar en agregar más aplicaciones de tipo J2EE, que será lo más fácil de implementar.

Por último, en una empresa pequeña, con aspiraciones a crecer, que tengan todo desarrollado en PHP y MySQL, se podría cambiar a un framework de desarrollo para PHP, así como agregar elementos más complejos en caso de ser necesarios (como memcached).

En definitiva, no intentar cambiar lo que ya hay si funciona. Otro caso es que no funcione o que haya que realizar adaptaciones y se pueda aprovechar para agregar elementos más generales o estándares.