Archivo para 18/11/09

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!!

¿No te ha pasado?

La fuerza de la costumbre ^^

PlasmaNotify, muestra las notificaciones de Firefox integradas en KDE con Plasma

Poco que comentar. Mira la imagen, ¿Queda claro, no?.

Visto en | Guill3
Descarga | PlasmaNotify

Google Chrome OS disponible en una semana

Google Chrome OS podria estar disponible en los proximos dias, De acuerdo al analista Michael Arrington del portal TechCrunch, que citó a “una fuente confiable” de Google, para informar del inminente lanzamiento de Google Chrome OS. De ser cierto, nada tan facil como descargarlo y probarlo (que a ciencia cierta hare ^^), ya os mantendre informados.

Mas informacion | Tu Experto | Rafaela

Magog White Icon Theme

Increible Pack de iconos para Gnome, puede quedar muy bien con Mac4Lin o en general cualquier otro tema.

Descarga | Gnome-Look

Oxygencolors KDE Icon Theme

Oxygencolors es un completo pack de iconos basados en el original oxygen 4.3 y que puedes “customizar” como tu quieras pues contiene un script para adecuarlo a tu distro o gustos. el pack incluye 25 logos de start, 35 iconos de carpetas disponibles en 20 colores diferentes y mas. Trabaja con kde 4.x





¿Es compatible tu equipo con Ubuntu?


( Muchos fondos de pantalla, aqui )

DESCARGATE SCIFI LIFE

365 Dias de Soledad
Me debes los sueños, las promesas y las noches rotas. Me debes la paz, la sonrisa y la esperanza robadas. Me debes la sangre, las lágrimas y el sudor vertido. Me debes las noches vacías, los abrazos anhelados. Me debes un beso de ajenjo de tu amarga boca.

The Ubuntu Counter Project - user number # 11961
Geo Visitors Map
noviembre 2009
L M X J V S D
« Oct   Dic »
 1
2345678
9101112131415
16171819202122
23242526272829
30  

Blog Stats

  • 30.943.352 hits