lunes, 9 de julio de 2012

Boys say GO!!!


Boys say Go!


Ya desde hace aproximadamente unos cinco años que la gigante empresa Google comenzó a trabajar en un nuevo lenguaje de programación. Desde 2007, al menos, tenemos noticias del desarrollo del lenguaje Go. Y desde fines del 2011 sabemos que está suficientemente estable como para darle una oportunidad en nuestras máquinas. En este artículo vamos a meternos un poco en las generalidades del lenguaje Go 1, y quién nos dice, quizá en los próximos podamos jugar un poco más con él.

Generalidades

En un anuncio de fines del año 2009, Google anunció la existencia de las primeras versiones beta del lenguaje de programación Go, autoproclamándose como rápido, productivo, y divertido para los desarrolladores. El concepto de “diversión de desarrolladores” me dejó algo preocupado. Los otros dos tampoco pasaron desapercibidos por mi cabeza.

En ese momento Goggle describió al lenguaje Go como experimental, y un intento de combinar la velocidad de trabajo de lenguajes dinámicos como lo es Python, con los niveles de performance que se pueden encontrar en C/C++. Cuando leemos las opiniones de algunos miembros del “Go team”, encontramos opiniones que lo ponen como “compilable en pocos segundos” y “veloz casi como el C/C++”.

Los que hemos tenido el gusto de trabajar con Java sabemos lo que eso significa, y cómo nuestros ojos se pueden llenar de lágrimas con el sólo hecho de pensar que la promesa de perfomance se cumpla de una vez por todas. Y si aparte hemos trabajado con Perl, Python ó Ruby, nos corre un frío por la espalda de pensar en términos de simplicidad de programación.

Según la literatura nativa del gigante de las nubes, el mundo ha cambiado radicalmente en términos de computación en la última década, pero no han emergido nuevos lenguajes de programación que los acompañen. Por ejemplo, la capacidad de procesamiento de las máquinas se ha multiplicado de forma exponencial, hecho no acompañado por un decremento en los tiempos necesarios para programar dichos sistemas.

Es cierto que la gente de sistemas lentamente (o no tanto) comenzó a dejar los leguajes de programación fuertes como lo son C/C++ y Java en favor de los interpretados como son Python y Javascript.

Por lo tanto, Go nace como respuesta a la creciente frustración generada en torno de los lenguajes y entornos de programación existentes, dado que la programación se ha vuelto en extremo complicada, así como la elección del lenguaje de programación adecuado para cada tarea. Dicha elección se debía basar en simplicidad en la programación versus rapidez en la compilación versus ejecución eficiente, no existiendo una combinación de las tres en un mismo lenguaje.

Go intenta cubrir el gap existente entre la simplicidad de programación existente en un lenguaje interpretado y dinámico con la eficiencia y velocidad de uno estático, del estilo de los compilados.

Algo de historia

Robert Griesemer, Rob Pike y Ken Thompson comenzaron a pensar en las bondades de este nuevo lenguaje de programación allá por el 21 de setiembre del 2007, cuando acá en Argentina estábamos festejando la primavera, y allá en USA estaban sintiendo los primeros fríos de otoño, y oían el ruido de empresas como Lehman Brothers que comenzaban a decir que tenían algunos problemitas económicos.

En unos pocos días los objetivos planteados se transformaron en un plan de desarrollo de una solución, y mejor aún, ya se sabía aproximadamente cómo debía ser esa solución. Claro está, en ese momento aún todo era una promesa, por lo que se trabajaba part-time en ese proyecto, mientras que se seguía con las tareas habituales.

En enero del 2008 Ken trabajó en un compilador sobre el cual volcar y explorar las ideas que se habían plasmado un tiempo atrás. Ese compilador ya generaba código C en su salida. Pero las cosas comenzaron a ponerse más jugosas para mediados del 2008.

En ese momento las acciones de Lehman Brothers habían bajado un 75%, AIG anunciaba que no podía seguir brindando seguridad para los fondos de inversión en USA, se veía en el horizonte una nueva crisis económica de dimensiones bíblicas, y en Google el proyecto se había vuelto de tiempo completo. Así es, todo el team comenzó a trabajar en forma intensiva en la generación del lenguaje de programación Go.

En mayo del 2008, IanTaylos de forma independiente comenzó a trabajar en un front end de GCC para Go usando el borrador de las especificaciones existentes. Para finales de ese mismo año, se unía al proyecto Russ Cox para ayudar a mover el proyecto del estado de prototipo al de realidad.

Así, Go se volvió público el 10 de noviembre del 2009, momento desde el cual mucha gente de diferentes comunidades contribuyeron con ideas, discusiones, y por supuesto, código.

De todo este proceso, obtuvimos un lenguaje nuevo, cuya sintáxis puede tener algo de parecido a C, pero con una intensa lavada de rostro, y alguna que otra cosa que nos hará la vida miserable a la hora de la depuración, como lo es la declaración del tipo de una variable luego de su nombre. Si antes pensábamos en “int x”, ahora debemos imaginar un “x int”.

Ah, también obtuvimos una mascota que es, desde mi humilde punto de vista, espantosa. La idea de ese bicho inmundo, dibujado por un niño que nunca la ha visto, con lápices gastados, y bajo los claros efectos de drogas pesadas, me deja pensando sobre la verdadera capacidad de la gente de marketing de Google. No entiendo cómo algunas cosas les salen tan bien y otras tan mal. Pero bueh, esta vez la gente de IT se llevó todas las rosas. Como debe ser, qué tanto.



Ni chicha ni limonada

Go es y no es un lenguaje orientado a objetos. Si bien tiene tipos y métodos y permite un estilo de programación orientada a objetos, no posee una jerarquía de tipos. El concepto de “interface” de Go provee un aspecto bastante diferente del que posee Java, por ejemplo, ya que se consideró desde el momento del diseño que como ahora está sería mucho más fácil de usar, y de una u otra forma, mucho más general.

Así y todo tenemos formas de embeber tipos dentro de otros tipos, logrando un comportamiento similar (nótese que digo similar, y no igual) al que tendrían las subclases. Luego, los métodos en Go son más sencillos que en C++ o Java, ya que se pueden definir para cualquier tipo de datos, aún para los incorporados en el mismo lenguaje.

En sí, en elementos como estos, o como los referidos al manejo de interfaces en general, funciones y métodos, o dispatch automático de método, vemos el intento de Google por generar un lenguaje de programación que simplifique muchas de las cosas que hoy en día nos molestan en otros lenguajes.



Empecemos

Sé que ya les debe estar picando el cuerpo por las ganas de probar este lenguaje de programación. Si no es así, hay médicos y otros dealers que pueden ayudarlos. Entonces vamos a ver cómo instalamos el lenguaje Go en nuestras máquinas, y comenzamos a hacer de las nuestras.

Lo primero será entender que tenemos dos tipos de compilador Go: uno llamado “gc”, independiente, y otro llamado “gccgo”, que apunta a ser parte del proyecto GCC. Duerman tranquilos, porque si ejecutan “yum search gccgo”, o “apt-cache search gccgo”, no van a encontrar nada.

Según dice Google, gc es más maduro y está mejor probado que gccgo. Por lo tanto, iremos por la primer opción.

Recordemos que para poder instalar gc nuestro sistema deberá poseer FreeBSD 7 o superior (al día de la fecha Debian GNU/kFreeBSD no está soportado), Linux 2.6.23 o superior con glibc (CentOS, RHEL, o sus derivados en versión 5 no están soportados, así como las distribuciones para ARM), MacOS X 10.6/7 (utilizando el gcc que obtenemos con Xcode), o Windows 200 o superior (usando mingw gcc, obviamente).

Bajaremos entonces el paquete correspondiente a nuestra distribución desde el URL http://code.google.com/p/go/downloads/list, lo descomprimiremos y destarearemos en /usr/local, y agregaremos los valores de este nuevo path a nuestras variables de entorno:

# cd /usr/local
# tar zxvf /home/hecsa/Downloads/go1.0.2.linux-amd64.tar.gz
...
$ vi .bash_profile
(agregar estas líneas)
export GOROOT=/usr/local/go
export PATH=$PATH:$GOROOT/bin
(salvar el archivo)
$ . ./.bash_profile
$ which go
/usr/local/go/bin/go

Listo, el prolongado proceso de instalación del lenguaje Go 1 ha llegado a su fín. Sencillo, ¿no?



La hora de la verdad

Como siempre, un programador no puede jactarse de serlo si no ha escrito su primer programa, es decir, el tan afamado “Hola, mundo!”. No podemos ser menos en este caso, así que aquí vamos:

$ vi hola.go
(agregar este contenido)
package main
import "fmt"
func main() {
fmt.Printf("Hola, mundo!\n")
}
(salvar el archivo)

Y como es de esperar, lo ejecutamos con el comando “go run”:

$ go run hola.go
Hola, mundo

Ahora bien, lo primero que me vino a la mente cuando ví este tan elaborado programa en base al cual se erigen cursos enteros de varios meses de duración fue analizar hasta dónde lo comentado por Google era o no real, y para eso, decidí armar dos programas más, también una nueva demostración de increíbles niveles de desarrollo por mi parte humildemente.

El primero es en C nativo:

$ vi hola.c
(agregar estas líneas al archivo)
#include
main()
{
printf("Hola, mundo!\n");
}
(salvar el archivo)

Y lo compilo con el GCC, pero utilizando el comando “time” antes, veremos para qué en breve:

$ time gcc -o hola hola.c
real 0m0.775s
user 0m0.085s
sys 0m0.079s

Como uno de los puntos de comparación es el lenguaje de programación Java, no quiero dejar de comparar el nivel de performance frente a un programa altamente elaborado como el que estamos escribiendo aquí.

Entonces, escribo su equivalente en Java:

$ vi HolaMundo.java
(agrego estas líneas al archivo)
class HolaMundo
{
public static void main(String args[])
{
System.out.println("Hola, mundo!");
}
}
(salvo el archivo)

Y lo compilo con el JDK 1.7.0_05 de Oracle:

$ time javac HolaMundo.java
real 0m2.020s
user 0m2.826s
sys 0m0.143s

Como el código de Go puede también compararse con un código interpretado (en palabras de los mismos desarrolladores, se lo compara en simplicidad con Python), he decidido armar el mismo código avanzadísimo, el “Hola, mundo!”, pero en Python:


$ vi Hola (nótese la mayúscula para diferenciarlo del programa en C)
(agregar estas líneas)
#!/usr/bin/python
print "Hola, mundo!"
(salvar el archivo)
$ chmod +x Hola

Ahora ha llegado la hora de la verdad. Ejecutaremos cada uno de los tres “Hola, mundo!”, y veremos el tiempo que significa para un mismo sistema:

$ time go run hola.go
Hola, mundo!
real 0m0.521s
user 0m0.433s
sys 0m0.074s

$ time java HolaMundo
Hola, mundo!

real 0m0.234s
user 0m0.138s
sys 0m0.040s

$ time ./hola
Hola, mundo!

real 0m0.003s
user 0m0.000s
sys 0m0.003s

$ time ./Hola
Hola, mundo!

real 0m0.077s
user 0m0.055s
sys 0m0.018s

Como podemos ver, el programa en C es por lejos una mejor opción para este tan elaborado ejemplo. Pero no olvidemos una pequeña trampa: nosotros nunca hemos compilado el programa en Go. Por lo tanto, si queremos ser justos, al menos en un primer momento, y con un razonamiento casi irracional, tendríamos que sumar los tiempos. Entonces:

Go:

real 0m0.521s
user 0m0.433s
sys 0m0.074s

C:

real 0m0.003s + 0m0.775s = 0m0.778s
user 0m0.000s + 0m0.085s = 0m0.085s
sys 0m0.003s + 0m0.079s = 0m0.082s

Java:

real 0m0.234s + 0m2.020s = 0m2.254s
user 0m0.138s + 0m2.826s = 0m2.964s
sys 0m0.040s + 0m0.143s = 0m0.183s

Python:

real 0m0.077s
user 0m0.055s
sys 0m0.018s

¿Es posible extraer una conclusión de esto? Sí, pero muy vaga: C es por lejos más rápido que Go, y ni que hablar que Java. La relación en tiempos de ejecución es de 1 a 180, aproximadamente. A Java directamente lo dejamos fuera de este partido, juega en otra liga, mucho más lenta, por supuesto. PERO, si consideramos que Go contempla también dentro de su entorno el interpretar el código, vemos que Python aún es más rápido que Go en una relación de 1 a 7.

Obviamente, no es esto lo que hay que evaluar en un lenguaje de programación, ya que estamos de acuerdo que escribir, por ejemplo, una página web utilizando C va a llevarnos notáblemente más tiempo que 0.778 segundos, así como dudo que podamos armar un driver en html.

Pero bueno, son las primeras pruebas que ejecuto, y son reales.

Conclusión

En este artículo hemos entregado sólo una breve reseña de lo que es el lenguaje de programación Go 1, y hemos hecho una despiadada demostración de genialidad de desarrollo al adentrarnos en complicadísimos algoritmos dignos de la más avanzada bibliografía (no se lo crean, por favor). En futuros números podremos ponernos a sacarle un poco más de jugo a este nuevo lenguaje, viendo para qué es bueno, y qué podemos hacer con él. ¡Hasta pronto, amigos!
Y recuerden: “Don't say no, boys say Go!”

Hernán “HeCSa” Saltiel
AOSUG leader
CaFeLUG Member
Boca happy fan
Club Amigos de Pumper Nic


PD: El título de este artículo y su frase final se refieren a un tema musical antiquísimo de Depeche Mode que se puede escuchar aquí, en su excelente versión en vivo en Londres, año 1986: http://www.youtube.com/watch?v=qVAUOxveuvc
Publicar un comentario en la entrada