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
