Programando con Go (El lenguaje de Programacion de Google)

Hace unos dias Google presento “Go” , un nuevo lenguaje de programacion Open Source orientado al desarrollo rapido y de elevado rendimiento. Veamos en primer lugar como instalarlo en Ubuntu.
El detalle completo de la instalacion lo podeis ver en Mundo Geek, yo ire algo mas rapido.

– Define las siguientes variables de entorno y las añades al final de tu fichero .bashrc

export GOROOT=$HOME/go
export GOOS=linux
export GOARCH=386
export GOBIN=$HOME/bin
export PATH=$PATH:$GOBIN

$GOROOT indica donde se guarda el codigo fuente de go, $GOOS indica el sistema operativo sobre el que vamos a compilar las aplicaciones generadas, puede ser “linux”, “darwin” (Max OS X) o “nacl” (Native Client, para el navegador Google Chrome). $GOARCH indica la arquitectura, que puede ser “386” (32 bits),o “amd64” (64 bits), $GOBIN indica donde se guardaran los binarios de go

Para no reiniciar la consola y cargar esas variables, ejecutamos:

source ~/.bashrc

Nos tenemos que bajar el codigo fuente de GO antes de compilarlo, para ello
instalamos el cliente de sistema de control de versiones utilizado por
Google:

sudo aptitude install mercurial

Ahora descargamos el codigo fuente:

hg clone -r release https://go.googlecode.com/hg/ $GOROOT

Instalamos las siguientes librerias que necesitaremos para compilar:

sudo aptitude install bison gcc libc6-dev ed

Compilamos el codigo fuente:

mkdir $GOBIN
cd $GOROOT/src
./all.bash

Y si todo ha ido correctamente ya tendremos todas las herramientas
compiladas que necesitaremos en $GOBIN

Cogemos ahora nuestro editor de textos favoritos. El tipico “Hola Mundo”
seria asi:

package main

import "fmt"

func main()
{
fmt.Printf("Goooola mundo\n");
}

Lo guardamos como “hello.go”

Ahora lo compilamos para 32 bits con:

8g hello.go

Si lo quisieramos para 64 ejecutariamos:

6g hello.go

Se generara un archivo hello.6 u hello.8 (segun la opcion elegida) con el
codigo maquina. ahora para linkar usaremos 8l (para 32) o 6l (para 64):

8l hello.8

Que generara ya el binario compilado, el cual podremos ejecutar con:

./8.out

En la pagina principal de Go podremos encontrar un tutorial sobre el
lenguaje y del API de sus librerias.

Podriamos tambien crear nuestra propia libreria, p.ej para el tratamiento
de ficheros. Abre el editor y copia el siguiente fragmento:

package file

import
(
"os";
"syscall";
)

type File struct
{
fd      int;    // file descriptor number
name    string; // file name at Open time
}

func newFile(fd int, name string) *File {
if fd < 0 {
return nil
}
return &File{fd, name}
}

var
(
Stdin  = newFile(0, "/dev/stdin");
Stdout = newFile(1, "/dev/stdout");
Stderr = newFile(2, "/dev/stderr");
)

func Open(name string, mode int, perm int) (file *File, err os.Error) {
r, e := syscall.Open(name, mode, perm);
if e != 0 {
err = os.Errno(e);
}
return newFile(r, name), err
}

func (file *File) Close() os.Error {
if file == nil {
return os.EINVAL
}
e := syscall.Close(file.fd);
file.fd = -1;  // so it can't be closed again
if e != 0 {
return os.Errno(e);
}
return nil
}

func (file *File) Read(b []byte) (ret int, err os.Error) {
if file == nil {
return -1, os.EINVAL
}
r, e := syscall.Read(file.fd, b);
if e != 0 {
err = os.Errno(e);
}
return int(r), err
}

func (file *File) Write(b []byte) (ret int, err os.Error) {
if file == nil {
return -1, os.EINVAL
}
r, e := syscall.Write(file.fd, b);
if e != 0 {
err = os.Errno(e);
}
return int(r), err
}

func (file *File) String() string {
return file.name
}

Guardalo como “file.go”.
Ahora crea un nuevo fichero llamado “fichero.go” con el contenido:

package main

import (
"./file";
"fmt";
"os";
)

func main() {
hello := []byte{'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '\n'};
file.Stdout.Write(hello);
file, err := file.Open("/does/not/exist",  0,  0);
if file == nil {
fmt.Printf("can't open file; err=%s\n",  err.String());
os.Exit(1);
}
}

Si te fijas en la seccion del “import” estamos importando la libreria (file.go)
creada anteriormente con “./file”

Compila con:

8g fichero.go

Linka con:

8l fichero.8

Ejecuta con:

./8.out

jose@soledad:~/go/codigo$ ./8.out
hello, world
can't open file; err=no such file or directory

En el ejemplo estamos escribiendo por consola un contenido de un array
e intentando abrir un fichero que no existe (saltara la excepcion
correspondiente).

con “Go” podemos incluso crear un servidor web en apenas 4 lineas de codigo.
Abre un editor de textos y copia el siguiente fragmento:

package main

import (
"http";
"io";
)

func main() {
//define la funcion para manejar la peticion a "/test_go"
http.Handle("/test_go", http.HandlerFunc(RequestHandler));

//esperar conexiones entrantes en el puerto 1234
err := http.ListenAndServe(":1234", nil);

//si se produce algun error:
if err != nil {
panic("Error: ", err.String());
}
}

func RequestHandler(c *http.Conn, req *http.Request) {
//recuperar e imprimir los parametros:
str :=  "<strong>Protocol:</strong> " + req.Proto + "
" +
"<strong>Method:</strong> " + req.Method + "
" +
"<strong>User-Agent:</strong> " + req.UserAgent;

//escribir la respuesta:
io.WriteString(c, str);
}

Guardalo como “web.go”, compilalo, linkalo y ejecutalo:

8g web.go
8l web.8
./8.out

Al ejecutarlo crearas el servidor web que quedara esperando a las
peticiones entrantes.
Abre ahora un navegador y mete como URL: http://127.0.0.1:1234/test_go
De manera inmediata deberias poder ver la respuesta del server.

Daniel Sanchez, me comenta tambien de la creacion de un grupo español sobre “Go”
si te interesa el tema puedes entrar desde: golang-spanish

alli encontraras mas ejemplos de codigo y tutoriales traducidos.
Por ejemplo el siguiente Tip, que nos permitira tener el resaltado
de Codigo en nuestro Editor Gedit.

Quien quiera tener en el gedit el marcado para programar más
cómodamente en go, puede descargarlo de aquí:

http://go-lang.cat-v.org/text-editors/gedit/

Simplemente se baja el “go.lang”, y se pega en la carpeta /usr/share/
gtksourceview-2.0/language-specs , (obviamente, con permisos de
administrador). Cuando abran el gedit en “ver//modo resaltado//
fuentes”, encontraran el resaltado para Go.

ahora cuando estes editando un “fichero .go” desde Gedit, tendras
el remarcado de palabras clave en diferentes colores:

Let’s go!!