sábado, 19 de julio de 2014

Las mejores librería, recursos y herramientas de Android

Hola a todos, les quería compartir este pequeño proyecto, la idea del mismo fue realizada en la lista de correo de Desarrolladores Android donde participo activamente desde hace un buen tiempo.

Este es el proyecto:

La idea del mismo, es que entre todos podamos armar una lista de las librerías más importantes, herramientas que podemos utilizar, recursos como lecturas, personas a seguir en redes sociales, etc, etc. Todo lo que nos pueda ayudar en el desarrollo de aplicaciones para la plataforma Android.

Esta es una guía donde nos explica como podemos colaborar aquí.

Espero que el proyecto les sea de utilidad, y que compartan los enlaces que crean que puedan ayudar a otros.

Saludos a todos, Gabriel

lunes, 16 de junio de 2014

Como colaboro con la Wiki en español sobre el framework LibGDX?


Hola a todos, en este nuevo post, solo les quería anunciar, que ya tenemos una guía sencilla para que cualquier persona pueda colaborar con la traducción de la Wiki del framework LibGdx.



Con esta guía se pretende incentivar la colaboración de personas que no sepan usar Git, que nunca hayan utilizado Github y que provablemente no tengan grandes conocimientos de programación pero que si deseen aprender y que puedan colaborar con la comunidad de alguna manera.

En este caso ayudando a traducir la documentación, para que otras personas puedan utilizar esta gran herramienta, y ademas esto los va a ayudar a que aprendan a utilizar el framework y a poder armar sus propios videos juegos.

Para mas detalles vea esto


Saludos a todos, Gabriel

domingo, 8 de junio de 2014

Wiki en español sobre el framework LibGDX



En este post les quería hablar sobre un proyecto, que presente en una charla que di en la facultad UTN regional Rosario el 04/06/2014, sobre la traducción de la wiki de una herramienta libre llamada Libgdx para el desarrollo de video juegos múlti-plataformas.


Esta herramientas tiene una gran variedad de ventajas, algunas de ellas se encuentran explicadas en la presentación que armé para la charla:

Presentación Libgdx

Les dejo un enlace a la wiki que estoy armando:

Wiki LibGDX en español

La misma no esta terminada aun, cualquier ayuda, ya sea compartiendo este enlace, puntuar con una estrella el repositorio o mejor aun enviando un pull request ;) será bienvenido.

Estas son algunas de las imágenes de la charla en la UTN:






Espero que les sirva, personalmente creo que es de gran ayuda tener documentación en nuestro idioma, sobre todo para las personas que recién se inician en el mundo de la programación.

Saludos a todos, Gabriel

martes, 29 de abril de 2014

The Original Hacker quinta edición !!!

En este post, volvemos a presentar material escrito por Eugenia, en este caso la quinta edición de la revista The Original Hackers :D


Temas de esta edición:

INGENIERÍA DE SOFTWARE: MANIPULACIÓN DE WEB
FORMS Y CARGA DE ARCHIVOS CON PYTHON Y WSGI
SOBRE APACHE

En un principio creo que comenta algo muy cierto, la gran mayoría de los programadores Django (sin ofender ;) ) no saben de Python. Solo saben utilizar el framework, pero se olvidan de lo importante que es conocer con que están trabajando realmente. Lo que les va a dar la posibilidad de realmente elegir más adelante con que desean trabajar ;) y nos da varios enlaces interesantes sobre el tema.
Creo que el artículo te va a hacer comprender como manejan ese tipo de acciones los framework web's de Python en general, lo que lo hace muy importante y recomendable.

EUROPIO ENGINE LAB: DICT OBJECT, UN NUEVO
CONCEPTO EN OBJETOS PARA LAS VISTAS EN PHP

Realmente no conozco PHP, pero esta serie de artículos sobre Europio creo que son muy útiles para abrirnos la mente y ayudarnos a pensar en como implementar la arquitectura que deseemos utilizar en un framework o engine que deseemos desarrollar. Sin importancia del lenguaje que utilicemos, del objetivo del mismo e ir mirando como se nos puede plantear un problema y la forma de pensar que necesitamos para poder resolverlo.

SEGURIDAD INFORMÁTICA: MODELOS DE SEGURIDAD
PERMISIVOS COMO MECANISMOS DE PREVENCIÓN DE
VULNERABILIDADES

Nos habla de una forma en la que lo puede comprender la mayoría sobre lo que es un modelo de seguridad permisiva, y como nos puede beneficiar en nuestra búsqueda de seguridad, para nuestras aplicaciones. En resumen un artículo interesante sobre seguridad informática.

BASH SCRIPTING AVANZADO: DIVERSAS FORMAS DE
IMPLEMENTACIÓN DE MENÚS DINÁMICOS

Este último artículo para mi es simplemente excelente, como crear Menúes con Bash :D la verdad que es muy bueno ;)

Esta es la web de The Original hackers: http://originalhacker.org

Y pueden descargarla directamente desde aquí: Enlace

Saludos a todos, Gabriel

miércoles, 23 de abril de 2014

Como instalo algo en Slackware cuando no tengo un paquete .txz o un .tgz?

El otro día necesitaba instalar particularmente un programa llamado PgAdmin en un Slackware 14, y me encontré con que la ultima versión de descarga en la web oficial PgAdmin web oficial no funcionaba correctamente con la versión de base de datos PostgresSql que estamos usando. Así que necesitaba instalar una versión más nueva de la misma herramienta, pero por supuesto como me suele suceder en esta distribución Linux no encuentro un paquete armado que me solucione el problema :D



Así que tuve que recurrir a la ayuda de Slackbuilds.org :D en este post voy a explicar  los pasos para poder utilizar los muchos script de instalación que  gente a aportado a esa web, y nos salvan de tener que configurar por completo la compilación a nosotros y así no equivocarnos en la configuración para el compilador e instalar el programa que necesitemos.

Acá voy a dejar el paso a paso, para el PgAdmin, pero esto se debe repetir para el programa que necesitemos ;)

  1. Primero nos dirigimos a Slackbuilds.org
  2. En la barra de búsqueda escribimos el nombre del programa que deseamos instalar, y antes de iniciar la búsqueda en el botón de al lado especificamos para que versión de Slackware deseamos realizar la instalación.
  3. En este caso el resultado de la búsqueda fue PgAdmin en Slackbuilds.org
  4. De allí debemos descargar dos enlaces, el primero que contiene el código fuente y el segundo que contiene el script de instalación.

Esto lo podemos hacer desde la terminal copiando los enlaces de la web.
~$ wget http://ftp.postgresql.org/pub/pgadmin3/release/v1.12.3/src/pgadmin3-1.12.3.tar.gz
~$ wget http://slackbuilds.org/slackbuilds/14.0/system/pgadmin3.tar.gz

Ahora lo que debemos hacer, es descomprimir el archivo donde se encuentra el slackbuild, desde la terminal.
~$ tar xvf pgadmin3.tar.gz

Movemos el comprimido del código fuente dentro de la carpeta que se creo:
~$ mv pgadmin3-1.12.3.tar.gz pgadmin3

Y nos movemos dentro de la misma carpeta, nos logueamos como root, para compilar y ejecutar el archivo creado para la instalación.
~#./pgadmin2.SlackBuild

Normalmente si todo salio correctamente nos va a mostrar la ruta de donde creo el archivo (en la carpeta /tmp) y que necesitamos usar para instalar el programa, por ejemplo en mi caso fue algo así:
Slackware package /tmp/pgadmin3-1.12.3-x86_64-1_SBo.tgz created.

Una vez hecho eso procedemos a instalar el programa:
~#installpkg /tmp/pgadmin3-1.12.3-x86_64-1_SBo.tgz

Eso simplemente fue todo, puede suceder que mientras compila les diga que les falta instalar algo y no termine de armar el paquete. En ese caso con solo ver el error, en la misma web de slackbuild pueden ver la dependencias del programa que necesitan instalar, por ejemplo en mi caso fue wxPython :D
Espero que a alguno les sirva.

P.D: Puede suceder que no encuentren el script exacto para la instalación de alguna versión en particular del programa o de Slackware, yo les recomiendo buscar el que más se acerca a su búsqueda y modificarlo ;)

Saludos a todos, Gabriel

sábado, 19 de abril de 2014

Como instalo un paquete RPM en Arch y como armo mi propio paquete para Arch Linux?

El otro día me paso que quería hacer una video conferencia por Google Hangout y me encuentro con que para hacerlo necesitaba actualizar el plugin Google Talk  :P
Bueno pensé que no iba a tener problema ya que lo había instalado por yaourt (para el que no lo conoce, es otro repositorio de aplicaciones para Arch que es mantenido por la comunidad y donde tenes muchas otras aplicaciones ;)) Así que intente ver si tenía alguna actualización para instalarlo y me di cuenta que ya tenía la última versión del plugin que estaba en el repositorio.
Por este motivo me dirigí a descargar la última versión del plugin desde la web oficial, pero me encontré con que solo tenían las versiones de paquetes deb y rpm para 32 o 64 bits :P

Entonces me decidí a buscar como instalar alguno de estos paquetes, la verdad que no resulto complicado por lo menos en este caso, pero si un poco molesto :D

Estos son los pasos:

1- Con nuestro gestor de paquetes pacman instalamos el programa rpmextract, que lo podemos hacer con el siguiente comando:
sudo pacman -S rpmextract
2- Descargamos el paquete rpm para la arquitectura que le corresponda a tu SO, en mi caso la versión de 64 bits.
3- Creamos una carpeta y movemos el paquete que descargamos dentro de ella.
4- Corremos el programa rpmextract, de la siguiente forma dentro de la carpeta: rpmextract.sh google-talkplugin_current_x86_64.rpm
5- Como podrán ver nos deja los archivos en la misma estructura de directorios, una forma podría ser directamente copiar los archivos en el lugar que corresponda.

Con eso ya podría tener el plugin corriendo sin problemas, ahora tiene algunas desventajas instalarlo de esa forma. Al instalar las cosas así, no va a tener una desinstalación sencilla, ni va a verificar que no se remueva alguna dependencia. Es por eso que lo mejor sería crear nuestro paquete para Arch.
Para esto básicamente lo único que necesitaríamos hacer es crear un archivo PKGBUILD que contenga toda la información acerca del mismo.
Instrucciones para crear un paquete en Arch
Instrucciones sobre los PKGBUILD

Ejemplo con mi archivo PKGBUILD:

# Maintainer: Gabriel Pozo <jackgris2@gmail.com>
pkgname=google-talkplugin
pkgver=5.2.4.0
pkgrel=4
pkgdesc="Video chat browser plug-in for Google Talk"
arch=('i686' 'x86_64')
url="http://www.google.com/chat/video"
license=('custom:google')
depends=('gtk2>=2.12.0' 'alsa-lib' 'mesa' 'lsb-release')
optdepends=('libnotify' 'pulseaudio')
source=(license.html::http://www.google.com/intl/en/policies/terms/index.html)
sha1sums=('SKIP')

if [ "$CARCH" == x86_64 ]; then
    source+=(https://dl.google.com/linux/talkplugin/rpm/stable/x86_64/${pkgname}-${pkgver}-1.x86_64.rpm)
    sha1sums+=('0570cfc38717e2bdf7779b632813ee5081dd5945')
elif [ "$CARCH" == i686 ]; then
    source+=(https://dl.google.com/linux/talkplugin/rpm/stable/i386/${pkgname}-${pkgver}-1.i386.rpm)
    sha1sums+=('990d199365e8b87234bce54747c00c8311cdcf67')
fi

package() {
    cp -R ${srcdir}/opt ${pkgdir}
    install -d "${pkgdir}/usr/lib"
    cp -R ${srcdir}/usr/lib*/* ${pkgdir}/usr/lib
    # change /usr/lib/chromium-browser to /usr/lib/chromium
    cp -R ${pkgdir}/usr/lib/chromium-browser ${pkgdir}/usr/lib/chromium
    cp -R ${pkgdir}/usr/lib/chromium-browser ${pkgdir}/usr/lib/chromium-dev
    # cleaning up cron update script
    rm -rf ${pkgdir}/opt/google/talkplugin/cron
    # install license file
    install -Dm644 "${srcdir}/license.html" "${pkgdir}/usr/share/licenses/${pkgname}/license.html"
}

Como se puede ver no es muy complicado:
  1. Nombre del programa, en minúsculas y sin espacios.
  2. Versión, como se ve en la descarga, Google le coloca current.
  3. Una versión interna que debería ser un numero que se incremente en uno con el cambio de versión.
  4. Una descripción breve, menos de 80 caracteres.
  5. La arquitectura, por ejemplo en este caso 64 bits.
  6. La URL del sitio oficial del paquete, esto es opcional.
  7. La licencia, GPS, BSD, unknown.
  8. Cualquier dependencia separada por espacios, no por comas.
  9. Las dependencias necesarias para construir el paquete 
  10. Cualquier opción, por ejemplo si se necesita un directorio que luego quedará vacío, para eso la opción 'emptydirs'
  11. Una lista de los archivos fuente, si colocamos URL's  los va a descargar (como en este caso), pero también le podemos colocar archivos de forma local en la misma carpeta que el archivo PKGBUILD
  12. Una suma de chequeo sha1 de los archivos (o MD5), esto lo podemos hacer con el comando 'makepkg -g' si lo ejecutamos en la misma carpeta donde se encuentran los archivos. (nos va a devolver el archivo que configuremos en el pkgbuild)
  13. Y si se fijan al final lo único que hace es copiar y pegar los archivos que se extrajo del paquete a donde corresponde.

Una vez que creamos el archivo PKGBUILD, corremos el comando makepkg en esa misma carpeta, y veremos que nos crea un archivo con extensión .pkg.tar.xz para poder usar con nuestro amado Pacman ;)
Ahora simplemente lo podemos instalar con el comando:
sudo pacman -U nombrepaquete.pkg.tar.xz

Lo bueno de esto, es que te va a advertir sobre las dependencias del mismo, y lo vas a poder desinstalar con pacman -R ;)

Enlaces:
Install rpm packages on Arch Linux
Paquete oficial en AUR

Espero que les allá servidor, por lo menos a mi me ayudo bastante :D 
En los enlaces esta el verdadero archivo PKGBUILD de donde saque el que termine usando, en este caso fue mucho mas sencillo todavía ya que no necesitaba crear un PKGBUILD de cero, solo con cambiar el número pkgrel a uno superior, podemos hacer que descargue el nuevo paquete de Google eh instale el nuevo plugin :D (si hice un poco de trampa, pero no es complicado para nada armar nuestro propio paquetes para Arch)

Saludos a todos, Gabriel

martes, 15 de abril de 2014

Como saber si dos figuras son similares y para que me puede servir?

Bueno para responder la primer parte de la pregunta, les comento que voy a hablar sobre Hausdorff. Seguramente se preguntaran porque, o por lo menos yo no tenia ningún conocimiento de su existencia.



Como primer medida vamos a ver la definición, tomada de Wikipedia:

"""
En matemáticas, la distancia de Hausdorff, o métrica de Hausdorff, también llamada distancia de Pompeiu-Hausdorff, mide cuan lejos se encuentran dos sub-conjuntos de medidas en el espacio el uno del otro.

Convierte el conjunto de subconjuntos compactos no vacíos de un espacio métrico en un espacio métrico en si mismo. Este lleva el nombre de Felix Hausdorff.
Informalmente, dos conjuntos están cerca de la distancia de Hausdorff si cada punto de alguno de los conjuntos está cerca de algún punto de la otra serie de puntos. La distancia de Hausdorff es la distancia más larga a la que puede ser obligado a viajar por un adversario que elige un punto en uno de los dos conjuntos, de donde luego debe viajar al otro conjunto. En otras palabras, es la mayor de todas las distancias de un punto en un juego hasta el punto más cercano en el otro conjunto.

Parece ser que esta distancia se introdujo por primera vez por Hausdorff en su libro Grundzüge der Mengenlehre, publicado por primera vez en 1914.

En computación, la distancia de Hausdorff se puede utilizar para encontrar una plantilla dada en una imagen de destino arbitrario. La plantilla y la imagen a menudo son pre-procesadas a través de un detector de bordes dando una imagen binaria.
A continuación, cada punto en la imagen binaria de la plantilla es tratado como un punto en un conjunto, la "forma" de la plantilla. Del mismo modo, un área de la imagen de destino binario se trata como un conjunto de puntos.
Un algoritmo, trata de encontrar la distancia de Hausdorff entre la plantilla y una cierta área de la imagen de destino. El área en la imagen de destino con la mínima distancia de Hausdorff a la plantilla, puede ser considerado el mejor candidato para la localización de la plantilla en el objetivo.

En gráficos generados por computadora la distancia de Hausdorff se utiliza para medir la diferencia entre dos representaciones diferentes del mismo objeto 3D, especialmente cuando se genera el nivel de detalle para la visualización eficiente de complejos modelos en 3D.

"""

En resumen la distancia de Hausdorff es la distancia máxima de un conjunto hasta el punto más cercano en el otro conjunto.

En mi caso tenia que verificar que dos objetos que eran posicionados por GPS estén realizando el mismo recorrido, ustedes dirán porque no ver si las posiciones que nos envían son iguales. Ahora este es el problema y el motivo de porque termino en la investigación de este algoritmo:

- Los GPS no son absolutamente precisos.
- Los objetos a los que se realiza el seguimiento utilizan diferentes tipos de GPS, por lo tanto las posiciones enviadas por mas que estén utilizando los mismos satélites, pueden enviar diferentes posiciones.
- Las posiciones no son enviadas necesariamente al mismo tiempo.

Al tener estos problemas en mente, no me sirve la simple comparación por ejemplo, si la posición que me enviá el GPS 1, es la misma que la del GPS 2, ya que si una fue enviada con 1 minuto de diferencia de la otra, mas la impresicion que pueden llegar a tener, obviamente que me pueden dar resultados muy diferentes, a pesar de que probablemente estén en el mismo lugar. Lo ideal es tener dos conjuntos de ubicaciones y verificar si estos son relativamente similares, lo que indicaría que están realizando el mismo recorrido, por lo tanto "viajan juntos". De ahí vino que fue necesario utilizar este algoritmo, que debo aclarar, me lo recomendó un ex-compañero del trabajo, Valentin ;)

En este enlace podrán encontrar el código fuente de la función que termine utilizando: Gist
En el código verán que trabajo con valores x e y, esto se debe a que realizó un traspaso, de latitud y longitud a un par de ejes de coordenadas para manejar las ubicaciones ;)

Enlaces de interés:
Hausdorff distance wikipedia
Hausdorff distance between convex polygons
Measuring difference between two meshes





Espero que a alguno le haya resultado de utilidad este post, en realidad puede tener muchas mas utilidades, y es un tema realmente interesante. Otro ejemplo de uso, es el encontrar figuras en imágenes, por ejemplo países como EEUU toman imágenes aéreas y con algoritmo similares a estos en las imágenes buscan por ejemplo aviones de combate u otro tipo de armamento escondido en diferentes lugares. Lo único que se tiene que tener es dos figuras a comparar y un poco de imaginación para lo que se lo pueda utilizar ;)

Saludos a todos, Gabriel

sábado, 5 de abril de 2014

Construyendo aplicaciones web con Golang: entorno de desarrollo (parte 2)

Comandos con Go

Los comandos de Go

El lenguaje Go viene con un grupo de comandos que nos va a ayudar a manejar un grupo de herramientas que nos van a facilitar varias tareas, usted puede ejecutar la línea de comando go para verlos:

Figura 1.3 El comando Go nos muestra información detallada
Todos estos son muy útiles para nosotros, vamos a ver como utilizar algunos de ellos.

go build

Este comando es para compilar los tests, el mismo va a compilar los paquetes de los que dependan si es necesario.
  • Si el paquete no es el principal o main como mymath de la sección 1.2, no se va a generar nada después de ejecutar el comando go build. Si usted necesita empaquetar el archivo .a en $GOPATH/pkg, debe usar el comando go install.
  • Si el paquete es el principal o main, este va a generar un archivo ejecutable en la misma carpeta. Si usted busca que el archivo sea generado en $GOPATH/bin, debe usar go install o go build -o ${PATH_HERE}/a.exe.
  • Si hay muchos archivos en la carpeta, pero solo desea compilar uno de ellos, usted debe agregar el nombre del archivo después del comando go build. Por ejemplo, go build a.go. En cambio go build va a compilar todos los archivos en la carpeta.
  • También podemos especificar con que nombre de archivo queremos que salga una vez compilado. Por ejemplo, tenemos mathapp en la sección 1.2, si usamos go build -o astaxie.exe este va a generar el archivo astaxie.exe en vez de mathapp.exe. El nombre por defecto va a ser el nombre de la carpeta (no en el paquete principal) o el nombre del primer archivo de código fuente(en el paquete principal).
(De acuerdo con Las especificaciones del lenguaje Go, el nombre del paquete debe ser el nombre después de la palabra package en la primera línea del archivo de código fuente, que no necesariamente debe ser el mismo que tiene la carpeta, y el archivo ejecutable va a ser el nombre de la carpeta de forma por defecto.])
  • go build va a ignorar los archivos que comiencen con _ o ..
  • Si usted desea tener diferentes archivos de código fuente para cada sistema operativo, puede nombrarlos con el nombre del sistema como sub-fijo. Supongamos que tenemos algunos archivos de código fuente para cargar algunos arrays, ellos deberían llamarse de la siguiente manera.
    array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go
go build va a escoger el que este asociado con su sistema operativo. Por ejemplo, solo se va a compilar array_linux.go en un sistema Linux, y se van a ignorar todos los otros.

go clean

Este comando es para limpiar los archivos que se generan por los compiladores, incluidos los siguientes archivos.
_obj/            // antiguo directorio de objetos, dejado por Makefiles
_test/           // antiguo directorio de test, dejado por Makefiles
_testmain.go     // antiguo directorio de gotest, dejado por Makefiles
test.out         // antiguo directorio de test, dejado por Makefiles
build.out        // antiguo directorio de test, dejado por Makefiles
*.[568ao]        // archivo objeto, dejado por  Makefiles

DIR(.exe)        // generado por go build
DIR.test(.exe)   // generado por go test -c
MAINFILE(.exe)   // generado por go build MAINFILE.go
Yo suelo usar este comando para limpiar mis archivos antes de subir mi proyecto a Github, estos son útiles para correr los test localmente, pero inútiles para el control de versiones.

go fmt

Las personas que trabajaron o trabajan con C/C++ deben conocer que siempre hay personas argumentando sobre como debe ser el estilo de codificación de el código fuente y siempre hablan sobre el estilo de K&R y el estilo ANSI, que uno es mejor que el otro. Sin embargo en Go, hay un solo estilo en el que deberíamos estar forzado a utilizar. Por ejemplo, tienes que poner la llave izquierda al final de la línea, y no puedes ponerlo en una sola línea, ya que obtendrás un error en la compilación! Afortunadamente, no tenes que recordar todas estas reglas, ya que el comando go fmt hace este trabajo por ti, con solo ejecutar el comando go fmt <Nombre del archivo>.go en la terminal. Yo no utilizo mucho este comando porque los IDEs normalmente lo utilizan automáticamente cuando guardas el archivo fuente, voy a hablar un poco más sobre IDEs en la siguiente sección.
Nosotros normalmente usamos gofmt -w en vez de go fmt, este último no reescribe los archivos fuente después de formatear el código. El comando gofmt -w src le va a dar formato a todo el proyecto.

go get

Este comando es para obtener paquetes remotos, este soporta BitBucket, Github, Google Code, Launchpad y muchos más. Actualmente suceden dos cosas después de ejecutarlo. La primera es la descarga del código fuente, entonces luego de eso ejecuta go install. Antes de usar este comando, debe estar seguro de que tiene instaladas las siguientes herramientas.
BitBucket (Mercurial Git)
Github (git)
Google Code (Git, Mercurial, Subversion)
Launchpad (Bazaar)
Para usar este comando, tiene que instalar estas herramientas de forma correcta. No olvide de configurar el PATH. Por cierto, también es compatible con los nombres de dominio personalizados, utilizando el comando go help remote(go help get) vamos a poder ver más detalles de como utilizarla.

go install

Este comando compila todos los paquetes y genera los archivo que luego son movidos hacia $GOPATH/pkg o $GOPATH/bin.

go test

Este comando carga todos los archivos cuyo nombre incluya *_test.go y genera los archivos de test, luego nos muestra información como la siguiente.
ok   archive/tar   0.011s
FAIL archive/zip   0.022s
ok   compress/gzip 0.033s
...
Esto testea todos los archivos de test de forma predeterminada, utilizando el comando go help testflag vamos a poder ver más detalles.

go doc

Muchas personas dicen que no necesitamos ninguna documentación de terceros para poder programar en Go(De hecho ya eh armado una CHM), Go tiene una poderosa herramienta para manejar la documentación por si mismo.
Entonces, como buscamos información de distintos paquetes en la documentación? Si uno busca obtener más detalles sobre la documentación del paquete builtin, debemos usar el comando godoc builtin, y usar el comando godoc net/http para el paquete http. Si lo que buscamos es más detalles sobre una función específica, debemos usar el comando godoc fmt Printf, y godoc -src fmt Printf para poder ver el código fuente.
Además ejecutando el comando godoc -http=:8080, y luego abriendo nuestro navegador en la dirección 127.0.0.1:8080, debería poder ver el sitio golang.org. Esto no solamente nos va a mostrar información de los paquetes estándar, si no que también vamos a poder ver los paquetes de nuestro $GOPATH/pkg. Por ejemplo esto es genial para personas que sufren por el gran corta-fuegos de China.

Otros comandos

Go nos provee más comando de los que acabamos de hablar.
go fix // nos sirve para actualizar nuestro código de versiones 
//anteriores a go1 hacia la nueva posterior a go1
go version // nos da información de nuestra versión de Go 
  go env // nos muestra las variables de entorno de Go
go list // nos lista todos los paquetes instalados
  go run // compila archivos temporales y ejecuta la aplicación
También podemos encontrar más información de los comandos ejecutando lo siguiente go help <comando>.

Herramientas de desarrollo para Go

En esta sección, les voy a mostrar algunos IDEs que tienen la habilidad de completar y dar formato de manera inteligente. Ellos son multiplataforma, por esto algunos de los pasos que vamos a mostrar no deberían ser muy diferentes si no estas utilizando el mismo sistema operativo.

LiteIDE

LiteIDE es un IDE de código abierto, liviano para el desarrollo unicamente de proyectos creados con Go, desarrollado por visualfc.

Imagen 1.4 Panel principal de LiteIDE
Características de LiteIDE.
  • Multiplataforma
    • Windows
    • Linux
    • Mac OS
  • Compilación cruzada
    • Maneja un entorno para la compilación múltiple
    • Soporta la compilación cruzada de Go
  • Manejo de proyectos estándar
    • Vista de la documentación basado en el $GOPATH
    • Sistema de compilación basado en el $GOPATH
    • Documentación de la API ordenada por índice basada en el $GOPATH
  • Editor de código fuente en Go
    • Esquematización de código
    • Soporte completo para gocode
    • Vista de la documentación de Go e índice de la API
    • Vista del código por medio de F1
    • Salto entre declaración de funciones con F2
    • Soporte para Gdb
    • Auto-formato con gofmt
  • Otros
    • Multi-lenguage
    • Sistema de plugin
    • Temas para el editor de texto
    • Soporte para la sintaxis basado en Kate
    • Completado inteligente basado en full-text
    • Configuración de atajos
    • Soporte para formato
      • Vista previa en tiempo real
      • Configuración por CSS
      • Exportar en HTML y PDF
      • Convertir y unir en HTML y PDF

LiteIDE instalación

  • Instalar LiteIDE
    Va a necesitar instalar antes Go, entonces descargue la versión para su sistema operativo. Descomprima el archivo para poder usarlo directamente.
  • Instalar gocode
    Debe instalar gocode para poder utilizar el auto-completado inteligente
    go get -u github.com/nsf/gocode
    
  • Entorno para la compilación
    Cambie la configuración en LiteIDE para ajustar su sistema operativo. En Windows y la versión de 64-bit para Go, usted debería elegir su entorno win64 en la barra de configuración para el entorno. Entonces elija opinion, busque LiteEnv en la lista de la izquierda, abra el archivo win64.env en la lista derecha.
    GOROOT=c:\go
    GOBIN=
    GOARCH=amd64
    GOOS=windows
    CGO_ENABLED=1
    
    PATH=%GOBIN%;%GOROOT%\bin;%PATH%
    。。。
    
    Reemplace GOROOT=c:\go por el PATH de su instalación de Go y guardela. Si tiene MinGW64, agregue c:\MinGW64\bin en el PATH de su variable de entorno para soportar cgo.
    En Linux y versiones de 64-bit para Go, debería elegir linux64 en la opción de configuración de la barra de herramienta. Entonces elija opinion, busque LiteEnv en la lista izquierda, abra el archivo linux64.env en la lista derecha.
    GOROOT=$HOME/go
    GOBIN=
    GOARCH=amd64
    GOOS=linux
    CGO_ENABLED=1
    
    PATH=$GOBIN:$GOROOT/bin:$PATH   
    。。。
    
    Reemplace GOROOT=$HOME/go por el PATH de su instalación de GO y guárdelo.
  • $GOPATH $GOPATH es la ruta que contiene la lista de proyectos, abra la herramienta de comandos (o presione Ctrl+ en LiteIDE) entonces tipee go help gopath para más detalles. Es muy sencillo para ver y modificar el $GOPATH en el LiteIDE. Vaya a View - Setup GOPATH para ver y modificar este valor.

Sublime Text

Aquí los voy a introducir a ver Sublime Text 2 (solo Sublime para abreviar) + GoSublime + gocode + MarGo. Déjeme explicarles porque.
  • Auto-completado inteligente

    Imagen 1.5 Completado inteligente en Sublime
  • Auto-formateado de los archivos fuentes
  • Manejo del proyecto

    Imagen 1.6 Manejo del proyecto en Sublime
  • Resaltado de sintaxis
  • Versión gratuita de pruebas por siempre, sin funcionalidades limitadas. Aunque les va a mostrar un pop-up cada cierto tiempo recordándonos de que no nos hemos registrado, pero usted solo puede ignorarlo.
Primero, descargue la versión de Sublime y elija la versión para su sistema operativo.
  1. Presione Ctrl+ ` para abrir la herramienta de comandos, eh ingrese el siguiente comando.
    import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Please restart Sublime Text to finish installation'
    
    Reinicie cuando termine la instalación. Entonces va a poder encontrar la opción de Package Control como un ítem en el menú de preferencias.

    Imagen 1.7 Control de paquete en Sublime
  2. Para instalar GoSublime, SidebarEnhancements y Go Build, presione Ctrl+Shift+p para abrir la herramienta Package Control, entonces tipee pcip (abreviación para "Package Control: Install Package").

    Imagen 1.8 Instalación de paquetes en Sublime
    Ahora va a poder tipear GoSublime, presione OK para instalar, siga los mismos pasos para instalar SidebarEnhancements y Go Build. Reinicie cuando termine la instalación.
  3. Para verificar que se instalo todo correctamente, abra Sublime, entonces abra el archivo main.go para ver si tiene el resaltado de sintaxis, tipee import para ver la ayuda import "fmt", luego tipee fmt. Para ver si tiene las funciones de completado inteligente.
    Si todo esta bien, entonces ya esta todo configurado.
    Si no, verifique su $PATH nuevamente. Abra una terminal, tipee gocode, si no puede ejecutarlo, su $PATH no debe estar configurado correctamente.

Vim

Vim es un popular editor de texto para programadores, que fue desarrollado a partir del editor vi. Tiene funciones para el completado inteligente, compilación y resaltado de errores.

Imagen 1.8 Completado inteligente de Vim para Go
  1. Resaltado de sintaxis para Go
    cp -r $GOROOT/misc/vim/* ~/.vim/
    
  2. Configuración del resaltado de sintaxis
    filetype plugin indent on
    syntax on
    
  3. Instalar gocode
    go get -u github.com/nsf/gocode
    
    gocode va a ser instalado en $GOBIN por defecto
  4. Configuración de gocode
    ~ cd $GOPATH/src/github.com/nsf/gocode/vim
    ~ ./update.bash
    ~ gocode set propose-builtins true
    propose-builtins true
    ~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
    lib-path "/home/border/gocode/pkg/linux_amd64"
    ~ gocode set
    propose-builtins true
    lib-path "/home/border/gocode/pkg/linux_amd64"
    
    Explicación de la configuración de gocode.
    propose-builtins: Completado inteligente o no, false es el valor por defecto.
    lib-path: gocode solo busca los paquetes en $GOPATH/pkg/$GOOS_$GOARCH y $GOROOT/pkg/$GOOS_$GOARCH, en esta configuración se pueden agregar otras rutas adicionales.
  5. Felicitaciones! Pruebe ejecutar :e main.go para experimentar el mundo de Go!

Emacs

Emacs llamado muchas veces el armar de Dios. Este no es solo un editor, también puede ser un IDE muy poderoso.

Imagen 1.10 Panel principal del editor de Emacs para Go
  1. Resaltado de sintaxis
    cp $GOROOT/misc/emacs/* ~/.emacs.d/
    
  2. Instalar gocode
    go get -u github.com/nsf/gocode
    
    gocode va a ser instalado por defecto en $GOBIN
  3. Configurar gocode
    ~ cd $GOPATH/src/github.com/nsf/gocode/vim
    ~ ./update.bash
    ~ gocode set propose-builtins true
    propose-builtins true
    ~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
    lib-path "/home/border/gocode/pkg/linux_amd64"
    ~ gocode set
    propose-builtins true
    lib-path "/home/border/gocode/pkg/linux_amd64"
    
  4. Instalar Auto Completado Descargue y descomprima
    ~ make install DIR=$HOME/.emacs.d/auto-complete
    
    Configure el archivo ~/.emacs
    ;;auto-complete
    (require 'auto-complete-config)
    (add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict")
    (ac-config-default)
    (local-set-key (kbd "M-/") 'semantic-complete-analyze-inline)
    (local-set-key "." 'semantic-complete-self-insert)
    (local-set-key ">" 'semantic-complete-self-insert)  
    
    Siga el siguiente link para más detalles.
  5. Configure el archivo .emacs
    ;; golang mode
    (require 'go-mode-load)
    (require 'go-autocomplete)
    ;; speedbar
    ;; (speedbar 1)
    (speedbar-add-supported-extension ".go")
    (add-hook
    'go-mode-hook
    '(lambda ()
        ;; gocode
        (auto-complete-mode 1)
        (setq ac-sources '(ac-source-go))
        ;; Imenu & Speedbar
        (setq imenu-generic-expression
            '(("type" "^type *\\([^ \t\n\r\f]*\\)" 1)
            ("func" "^func *\\(.*\\) {" 1)))
        (imenu-add-to-menubar "Index")
        ;; Outline mode
        (make-local-variable 'outline-regexp)
        (setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....")
        (outline-minor-mode 1)
        (local-set-key "\M-a" 'outline-previous-visible-heading)
        (local-set-key "\M-e" 'outline-next-visible-heading)
        ;; Menu bar
        (require 'easymenu)
        (defconst go-hooked-menu
            '("Go tools"
            ["Go run buffer" go t]
            ["Go reformat buffer" go-fmt-buffer t]
            ["Go check buffer" go-fix-buffer t]))
        (easy-menu-define
            go-added-menu
            (current-local-map)
            "Go tools"
            go-hooked-menu)
    
        ;; Other
        (setq show-trailing-whitespace t)
        ))
    ;; helper function
    (defun go ()
        "run current buffer"
        (interactive)
        (compile (concat "go run " (buffer-file-name))))
    
    ;; helper function
    (defun go-fmt-buffer ()
        "run gofmt on current buffer"
        (interactive)
        (if buffer-read-only
        (progn
            (ding)
            (message "Buffer is read only"))
        (let ((p (line-number-at-pos))
        (filename (buffer-file-name))
        (old-max-mini-window-height max-mini-window-height))
            (show-all)
            (if (get-buffer "*Go Reformat Errors*")
        (progn
            (delete-windows-on "*Go Reformat Errors*")
            (kill-buffer "*Go Reformat Errors*")))
            (setq max-mini-window-height 1)
            (if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t))
        (progn
            (erase-buffer)
            (insert-buffer-substring "*Go Reformat Output*")
            (goto-char (point-min))
            (forward-line (1- p)))
        (with-current-buffer "*Go Reformat Errors*"
        (progn
            (goto-char (point-min))
            (while (re-search-forward "<standard input>" nil t)
            (replace-match filename))
            (goto-char (point-min))
            (compilation-mode))))
            (setq max-mini-window-height old-max-mini-window-height)
            (delete-windows-on "*Go Reformat Output*")
            (kill-buffer "*Go Reformat Output*"))))
    ;; helper function
    (defun go-fix-buffer ()
        "run gofix on current buffer"
        (interactive)
        (show-all)
        (shell-command-on-region (point-min) (point-max) "go tool fix -diff"))
    
  6. Felicitaciones! speedbar esta cerrado por defecto, quite los símbolos de comentarios en la linea ;;(speedbar 1) para tener esta característica, o puede realizarlo a través del comando M-x speedbar.

Eclipse

Eclipse es otra gran herramienta de desarrollo, le voy a mostrar como utilizarla para escribir programas en Go.

Imagen 1.1 Panel principal del editor de Eclipse para Go
  1. Descargue e instale Eclipse
  2. Descargue goclipse http://code.google.com/p/goclipse/wiki/InstallationInstructions
  3. Descargue gocode
    gocode en Github.
    https://github.com/nsf/gocode
    
    Va a necesitar instalar git en Windows, normalmente usamos msysgit
    Instalar gocode desde la linea de comandos
    go get -u github.com/nsf/gocode
    
    Puede instalarlo desde el código fuente si lo desea.
  4. Descargue e instale MinGW
  5. Configure los plugins.
    Windows->Preferences->Go
    (1).Configuración del compilador de Go

    Imagen 1.12 Configuración de Go en Eclipse
    (2).Configuración de gocode(opcional), configure el path de donde tenga el archivo gocode.exe.

    Imagen 1.13 Configuración de gocode
    (3).Configuración de gdb(opcional), configure el path de gdb donde se encuentre el archivo gdb.exe.

    Imagen 1.14 Configuración de gdb
  6. Verifique la instalación
    Cree un nuevo proyecto Go y un archivo hello.go como el siguiente.

    Imagen 1.15 Cree un nuevo proyecto y archivo
    Testee la instalación de la siguiente forma.(necesita tipear estos comandos en la consola de Eclipse)

    Imagen 1.16 Testeo de programas Go en Eclipse

IntelliJ IDEA

Las personas que trabajan con Java deben estar familiarizados con este IDE, el mismo soporta el resaltado de sintaxis para Go, auto-completado y mas por medio de plugins.
  1. Descargue el IDE, no hay diferencia entre la versión Ultimate y la Community Edition

  2. Instale el plugin para Go. Elija File - Setting - Plugins, y entonces haga click en Browser repo.

  3. Busque golang, realice doble click en download and install, espere a que termine la descarga.

    Realice click en Apply, y entonces reinicie.
  4. Ahora vas a poder crear proyectos Go.

    Ingrese la ubicación del SDK de Go en los pasos siguientes, básicamente es su $GOROOT.
( Mire también el post para configurar y utilizar el IntelliJ IDEA con Go paso a paso )

Resumen

En este capitulo, hemos hablado sobre como instalar Go de tres formas diferentes, incluyendo como hacerlo desde el código fuente, el paquete estándar y herramientas de terceros. Luego mostramos como configurar nuestro entorno de desarrollo Go, principalmente hablamos sobre el $GOPATH. Después de eso, hicimos una introducción sobre los pasos para compilar y correr nuestro programas en Go. Entonces hablamos sobre algunos de los comando de Go, estos comandos incluyen compilar, instalar, dar formato, testear. Finalmente, mostramos algunas herramientas poderosas para desarrollar programas en Go, como LiteIDE, Sublime Text, Vim, Emacs, Eclipse, IntelliJ IDEA, etc. Usted puede elegir cualquiera de ellas para comenzar a explorar el mundo de Go.

 Indice

martes, 1 de abril de 2014

Como obtengo el alto, ancho y densidad de pantalla de mi dispositivo?

Nos vemos en otro post, con otras funciones que quizás les puedan resultar útiles ;) En este caso, vamos a obtener el ancho y alto de la pantalla donde este corriendo la aplicación en píxeles y ademas vamos a obtener el valor que representa la densidad de pantalla de la misma.



Primero les muestro una simple clase POJO donde voy a almacenar los valores que nos devuelve la función, con los datos de la pantalla.

public class Screen {

    private int altura;
    private int ancho;
    private float densidad;

    public Screen() {
        this.altura = 0;
        this.ancho = 0;
        this.densidad = 0;
    }

    public Screen(int altura, int ancho, float densidad) {
        this.altura = altura;
        this.ancho = ancho;
        this.densidad = densidad;
    }

    public int getAltura() {
        return altura;
    }

    public void setAltura(int altura) {
        this.altura = altura;
    }

    public int getAncho() {
        return ancho;
    }

    public void setAncho(int ancho) {
        this.ancho = ancho;
    }

    public float getDensidad() {
        return densidad;
    }

    public void setDensidad(float densidad) {
        this.densidad = densidad;
    }
}


Y esta es la función que nos va a devolver los datos de la pantalla.

    @SuppressWarnings("deprecation")
    public Screen configScreen(Activity context) {

        // Datos que vamos a terminar devolviendo en el objeto Screen
        float densidad;
        int alto;
        int ancho;

        // Obtenemos el valor que representa la densidad de 
        // pantalla, que es la cantidad de pixeles que representan
        // un dpi, por ejemplo una densidad de pantalla en 
        // Medium DPI es igual a 1
        Resources r = context.getResources();
        densidad = TypedValue.applyDimension(
                                        TypedValue.COMPLEX_UNIT_DIP,
                                        1, r.getDisplayMetrics());

        // Tomamos la pantalla del dispositivo
        Display display = context.
                           getWindowManager().getDefaultDisplay();
        Point size = new Point();

        // Utilizamos uno u otro metodo para tomar el tamaño 
        // de pantalla, dependiendo de la version de android
        if(Build.VERSION.SDK_INT >=
                             Build.VERSION_CODES.HONEYCOMB_MR2){

            display.getSize(size);
            ancho = size.x;
            alto = size.y;
        }
        else {
            // Esto es deprecated, pero es necesario para 
            // versiones anteriores
            ancho = display.getWidth();
            alto = display.getHeight();
        }
        // Creamos y devolvemos el objeto Screen con los datos 
        // que obtuvimos
        return new Screen(alto, ancho, densidad);
    }


Saludos a todos, Gabriel

lunes, 31 de marzo de 2014

Como puedo comprobar si una activity esta a la vista?

El otro día para un proyecto necesitaba saber si una activity de mi aplicación se encontraba a la vista o no, buscando y mirando código por ahí, termine armando esta función, que quizás a alguno pueda ayudar ;)




@Override
    public boolean comprobarActivityALaVista(
                  Context context, String nombreClase){

        // Obtenemos nuestro manejador de activitys
        ActivityManager am = (ActivityManager)  
                   context.getSystemService(Context.ACTIVITY_SERVICE);
        // obtenemos la informacion de la tarea que se esta ejecutando 
        // actualmente
        List< ActivityManager.RunningTaskInfo > taskInfo =
             am.getRunningTasks(1);
        // Creamos una variable donde vamos a almacenar 
        // la activity que se encuentra a la vista
        String nombreClaseActual = null;

        try{
            // Creamos la variable donde vamos a guardar el objeto 
            // del que vamos a tomar el nombre
            ComponentName componentName = null;
            // si pudimos obtener la tarea actual, vamos a intentar cargar 
            // nuestro objeto
            if(taskInfo != null && taskInfo.get(0) != null){
                componentName = taskInfo.get(0).topActivity;
            }
            // Si pudimos cargar nuestro objeto, vamos a obtener 
            // el nombre con el que vamos a comparar
            if(componentName != null){
                nombreClaseActual = componentName.getClassName();
            }

        }catch (NullPointerException e){

            Log.e(TAG, "Error al tomar el nombre de la clase actual " + e);
            return false;
        }
      
        // devolvemos el resultado de la comparacion
        return nombreClase.equals(nombreClaseActual);
    }

Espero que les sirva, nos vemos en otro post.

Saludos, Gabriel

miércoles, 26 de marzo de 2014

Como se si puedo escribir en la memoria interna o SD??

Muchas veces estamos armando una aplicación, donde necesitamos escribir en la memoria interna del dispositivo o en la memoria SD del mismo, pero que sucede si el dispositivo esta por ejemplo configurado de la siguiente forma? ""almacenamiento masivo""   



Por eso o por cualquier otro motivo existe la posibilidad de que no tengamos permisos para escribir sobre el mismo. Ese es el motivo de esta pequeña función, que quizás les sea de utilidad.

public boolean getStateStorage(Context context){

        File file = context.getCacheDir();
       
        return !Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) &&
                (context.getCacheDir() != null ||
                        (file != null && file.getPath() != null));
    }

Espero que les sirva, nos vemos en otro post ;)

Saludos a todos, Gabriel

viernes, 21 de marzo de 2014

Como verifico si tengo conexión a Internet?

Hola a todos, en este post simplemente les quería pasar una función que seguramente en algún momento les puede resultar de utilidad ;)



 public boolean isConnectingToInternet(Context context) {

        ConnectivityManager connectivity = (ConnectivityManager)
                context.getSystemService(Context.CONNECTIVITY_SERVICE);

        if (connectivity != null) {

            NetworkInfo[] info = connectivity.getAllNetworkInfo();
            if (info != null){
                for(NetworkInfo anInfo : info){
                    if (anInfo.getState() == NetworkInfo.State.CONNECTED) {
                        return true;
                    }
                }
            }

        }
        return false;
    }

Espero que les sea de utilidad :D

Saludos a todos, Gabriel

lunes, 10 de marzo de 2014

Construyendo aplicaciones web con Golang: entorno de desarrollo (parte 1)

Configuración del entorno de desarrollo en Go

Bienvenido al mundo de Go, vamos a comenzar a explorarlo!
Go tiene una compilación muy rápida, recolector de basura, y el lenguaje tiene un sistema orientado a la concurrencia. Esto tiene las siguiente ventajas:
  • Compila grandes proyectos en solo unos pocos segundos.
  • Nos provee un modelo de desarrollo de software sobre el cual es sencillo razonar, evitando la mayor parte de los problemas causados por los archivos de cabecera del estilo de C.
  • Es un lenguaje estático que no tiene niveles en su sistema de tipos, por lo cual los usuarios no deberán pasar demasiado tiempo estudiando las relaciones entre tipos. Es mas un lenguaje orientado a objetos livianos.
  • Realiza la recolección de basura. Proporciona un soporte básico para la concurrencia y la comunicación.
  • Esta diseñado para equipos de mas de un núcleo.
Go es un lenguaje compilado. Combina la eficiencia de los lenguajes interpretados o dinámicos con la seguridad de los lenguajes estáticos. Va a ser el lenguaje de elección para las computadoras de varios núcleos conectadas a la red. Por estos motivos, hay algunos problemas que tienen que resolver el propio lenguaje, como un rico sistema expresivo ligero de tipos, concurrencia y la recolección de basura estrictamente regulada. Desde hace algún tiempo, no han salido paquetes o herramientas que resuelvan estos problemas de manera pragmática, por esto nació la motivación para el lenguaje Go.
En este capitulo, te voy a mostrar como realizar la instalación y configuración tu entorno de desarrollo Go.

Instalación

Tres formas de instalar Go

Hay varias formas de configurar el entorno de desarrollo Go en nuestro equipo, usted puede elegir el que mas le guste. Estas son las tres formas más comunes.
  • Instalación del paquete oficial.
    • El equipo de Go nos ofrece paquetes para una instalación cómoda en Windows, Mac, Linux y otros sistemas operativos. Esta es la forma más sencilla de empezar.
  • Instalarlo desde el código fuente.
    • Esta forma es popular para los desarrolladores que están familiarizado con sistemas operativos Unix-like.
  • Usar herramientas de terceros.
    • Hay muchas herramientas de terceros y manejadores de paquetes para instalar Go, como apt-get en Ubuntu y homebrew para Mac.
En caso de desear instalar más de una versión de Go en su computadora, debería mirar la herramienta llamada GVM. Es la mejor herramienta que eh visto hasta ahora para lograr este trabajo, de lo contrario deberá saber como hacer frente a este problema por su cuenta.

Instalar desde el código fuente

Debido a que algunas partes de Go están escritas en Plan 9 C y en ensamblador AT&T, hay que instalar un compilador C antes de tomar el siguiente paso.
En una Mac, una vez instalado Xcode, usted ya tendrá el compilador instalado.
En sistemas Unix-like, usted necesita instalar gcc o un compilador similar. Por ejemplo, utilizando el manejador de paquetes apt-get incluido en Ubuntu, uno puede instalar todos los requerimientos del compilador con lo siguiente: sudo apt-get install gcc libc6-dev
En Windows, necesita instalar MinGW con el fin de instalar gcc. No se olvide de configurar las variables de entorno después de que allá finalizado la instalación.
El equipo de Go utiliza Mercurial para manejar el código fuente, entonces usted deberá instalar esta herramienta para poder descargar el código fuente.
En este punto ya podrá ejecutar los siguientes comando para clonar el código fuente de Go, y comenzar a compilar.( Esto va a clonar el código fuente en el directorio actual, así que antes cambie a su directorio de trabajo. Esto puede tomar algún tiempo. )
hg clone -u release https://code.google.com/p/go
cd go/src
./all.bash 
Una instalación correcta terminara con el mensajes "ALL TESTS PASSED."
En Windows, se puede lograr lo mismo ejecutando el archivo all.bat.
Si usted esta usando Windows, el paquete de instalación va a configurar las variables de entorno automáticamente. En cambio en los sistemas Unix-like, usted necesita configurar estas siguientes variables de forma manual.(Si su versión de Go es mayor a la 1.0, no va a necesitar configurar $GOBIN, y automáticamente se va a relacionar con su $GOROOT/bin, del que vamos a hablar en la siguiente sección)
export GOROOT=$HOME/go
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOROOT/bin
Si usted ve la siguiente información en la pantalla, usted a configurado todo.

Figura 1.1 Información después de la instalación desde el código fuente
Una vez que vea la información para el uso de Go, esto significa que ha instalado Go de forma exitosa en su equipo. Si dice "no such command", verifique que su variable de entorno $PATH contenga la ruta de instalación de Go.

Utilice los paquetes de instalación estándar

Go tiene paquetes de instalación de un solo clic para todos los sistemas operativos. Estos paquetes van a instalar Go en /usr/local/go (c:\Go en Windows) de forma predeterminada. Por supuesto que uno puede cambiarlo, pero en ese caso deberá modificar todas las variables de entorno de forma manual, como se mostró anteriormente.

Como comprobar si tu sistema operativo es de 32-bit o 64-bit?

Nuestros siguientes pasos depende de nuestro tipo de sistema operativo, así que debemos verificarlo antes de descargar los paquetes de instalación estándar.
Si esta utilizando Windows, presione Win+R y luego ejecute la herramienta de comandos, tipeando el comando systeminfo y eso nos va a mostrar alguna información bastante útil solo por unos segundos. Busque la linea con "system type", si usted ve "x64-based PC" eso significa que su sistema operativo es de 64-bit, en caso contrario será de 32-bit.
Recomiendo fuertemente la descarga de la versión del paquete de 64 bits si sos un usuario de Mac, porque Go ya no es compatible con los procesadores de 32 bits puros de MacOs
Los usuarios de Linux pueden tipear en la terminal el comando uname -a para ver la información del sistema. Las versiones de 64 bits se muestran de la siguiente manera.
<alguna descripción> x86_64 x86_64 x86_64 GNU/Linux
// Algunas maquinas por ejemplo como Ubuntu 10.04 muestran lo siguiente
x86_64 GNU/Linux
Las versiones de sistemas de 32-bit muestran lo siguiente.
<alguna descripción> i686 i686 i386 GNU/Linux

Mac

Vaya a la pagina de descarga, elija go1.0.3.darwin-386.pkg para sistemas de 32-bit o go1.0.3.darwin-amd64.pkg para sistemas de 64-bit. Vaya durante todo el camino presionando "next" o "siguiente", ~/go/bin va a ser añadido al $PATH después de finalizada la instalación. Ahora abra una terminal y escriba go. Usted debería ver lo que se muestra en la figura 1.1.

Linux

Vaya a la [página de descarga]((http://code.google.com/p/go/downloads/list), elija go1.0.3.linux-386.tar.gz para sistemas de 32-bit o go1.0.3.linux-amd64.tar.gz para sistemas de 64-bit. Supongamos que desea instalar Go en la ruta $GO_INSTALL_DIR, descomprima tar.gz en esa ruta con el comando tar zxvf go1.0.3.linux-amd64.tar.gz -C $GO_INSTALL_DIR. Entonces configure su $PATH export PATH=$PATH:$GO_INSTALL_DIR/go/bin. Ahora abra una terminal y ejecute go. Usted debería ver lo que se muestra en la figura 1.1.

Windows

Vaya a la [página de descarga]((http://code.google.com/p/go/downloads/list), elija go1.0.3.windows-386.msi para sistemas de 32-bit o go1.0.3.windows-amd64.msi para sistemas de 64-bit. Siga el proceso presionando "next" o "siguiente", esto va a añadir c:/go/bin a su path. Ahora abra una linea de comandos de Windows y ejecute el comando go. Usted debería ver lo que se muestra en la figura 1.1.

Utilizar herramientas de terceros

GVM

GVM es una herramienta para el control de versiones de Go desarrollada por terceros, como rvm en ruby. Es bastante sencilla de utilizar. Instale gvm escribiendo el siguiente comandos en su terminal.
bash < <(curl -s https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer)
Luego podemos instalar Go con el siguiente comando.
gvm install go1.0.3
gvm use go1.0.3
Después de que el proceso termine, ya estará todo listo y configurado.

apt-get

Ubuntu es la versión de Linux para escritorio mas popular. Este utiliza el administrador de paquetes apt-get. Nosotros podemos instalar Go utilizando los siguientes comandos.
sudo add-apt-repository ppa:gophers/go
sudo apt-get update
sudo apt-get install golang-stable

Homebrew

Homebrew es un programa para la gestión de herramientas utilizando comúnmente en Mac para manejar nuestro software. Solo tienes que tipear el siguiente comando para instalar Go.
brew install go
 

$GOPATH y nuestro entorno de trabajo

$GOPATH

Todos los comando en Go confían en una importante variable de entorno llamada $GOPATH. Note que esta no es la variable $GOROOT que es donde Go es instalado. Esta variable indica cual es el área de trabajo de Go en nuestra computadora. (Yo utilizo este path en mi computadora, si usted no tiene la misma estructura de directorio, por favor sustitúyala por la de usted.)
En sistemas Unix-like, la variable debería ser utilizada de forma similar a esta.
export GOPATH=/home/apple/mygo
En Windows, es necesario crear una nueva variable de entorno llamada GOPATH, entonces podemos configurar un valor como c:\mygo( Este valor va a depender donde queremos localizar nuestro espacio de trabajo )
Se puede tener mas de una ruta (espacio de trabajo) en $GOPATH, pero recuerde que necesita utilizar :(; en Windows) para romper con ellas. En este punto, go get va a salvar el contenido en su primera ruta en el $GOPATH.
En $GOPATH, usted debería tener tres carpetas, de la siguiente manera.
  • src para el código fuente con la extensiones .go, .c, .g, .s.
  • pkg para los archivos compilados de extensión .a.
  • bin para los archivos ejecutables
En este libro, utilizo mygo como mi única ruta en el $GOPATH.

Carpeta para los paquetes

Crear un paquete con archivos de código fuente y capetas como $GOPATH/src/mymath/sqrt.go (mymath es el nombre del paquete) ( El autor usa mymath como su nombre de paquete, y el mismo nombre para la carpeta que contiene los archivos del paquete)
Cada vez que usted cree un paquete, debería crear una nueva carpeta en el directorio src, las carpetas son nombradas normalmente de la misma forma que lo hacemos con el paquete que vamos a utilizar. Usted puede tener varios niveles de directorios si lo queremos. Por ejemplo, creamos los directorios $GOPATH/src/github.com/astaxie/beedb, entonces la ruta del paquete es github.com/astaxie/beedb. El nombre del paquete va a ser el ultimo directorio de la ruta del mismo, que en este caso es beedb.
Ejecute los siguientes comandos. ( Ahora el autor vuelve a hablarnos sobre algunos ejemplos )
cd $GOPATH/src
mkdir mymath
Creamos un nuevo archivo llamado sqrt.go, y dentro colocamos el siguiente contenido.
// Código fuente de $GOPATH/src/mymath/sqrt.go
package mymath

func Sqrt(x float64) float64 {
    z := 0.0
    for i := 0; i < 1000; i++ {
        z -= (z*z - x) / (2 * x)
    }
    return z
}
Ahora mi directorio del paquete es creado y el código funcional esta hecho. Yo recomiendo que mantengan el mismo nombre para el paquete y la carpeta que contiene los archivos fuentes del mismo.

Paquete compilados

Ya hemos creado nuestro paquete como lo escribimos arriba, pero, como compilamos esto de forma práctica? Hay dos maneras para hacer esto.
  1. Diríjase hacia la ruta donde se encuentra su paquete y ejecute el comando go install.
  2. Ejecutar el comando anterior con el nombre del paquete, por ejemplo: go install mymath.
Después de compilar, nosotros podemos abrir la siguiente carpeta.
cd $GOPATH/pkg/${GOOS}_${GOARCH}
// Se puede ver que se generó el archivo
mymath.a
El archivo con extensión que se generó .a es un archivo binario de su paquete, y como podemos usarlo?
Obviamente, nosotros necesitamos crear una nueva aplicación que lo use.
Creamos una nueva aplicación llamada mathapp.
cd $GOPATH/src
mkdir mathapp
cd mathapp
vim main.go
codigo
//$GOPATH/src/mathapp/main.go código fuente.
package main

import (
    "mymath"
    "fmt"
)

func main() {
    fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
}
Para compilar esta aplicación, debemos cambiar al directorio donde se encuentra la aplicación que es en este caso $GOPATH/src/mathapp, entonces ejecutamos el comando go install. Ahora deberíamos ver un archivo ejecutable llamado mathapp que fue generado en el directorio $GOPATH/bin/. Para ejecutar el programa, debemos usar el comando ./mathapp, entonces deberíamos ver los siguiente en la terminal.
Hello world. Sqrt(2) = 1.414213562373095

Instalar paquetes remotos

Go tiene una herramienta para instalar paquetes remotos, que es el comando llamado go get. Este tiene soporte para la mayoría de las comunidades de software libre, incluidas Github, Google Code, BitBucket, and Launchpad.
go get github.com/astaxie/beedb
Usted puede utilizar el comando go get -u … para actualizar estos paquetes remotos, y esto va a instalar automáticamente todos los paquetes de los que depende también.
Esta herramienta utiliza diferentes herramientas de control de versiones para las diferentes plataforma “Open Source”. Por ejemplo, git para Github, hg para Google Code. Por lo tanto, uno debe instalar estas herramientas para el manejo de control de versiones para poder utilizar la herramienta go get.
Despues de ejecutar los anteriores comandos, la estructura de directorios debería ser similar a la siguiente.
$GOPATH
    src
     |-github.com
         |-astaxie
             |-beedb
    pkg
     |--${GOOS}_${GOARCH}
         |-github.com
             |-astaxie
                 |-beedb.a
Lo que realmente realizar go get, es clonar el código fuente hacia el directorio $GOPATH/src y en sistema de archivos local, y luego ejecuta el comando go install.
Utilizaremos los paquetes remotos de la misma manera que usamos los paquetes que creamos localmente.
import "github.com/astaxie/beedb"

Estructura de directorio completa

Si siguió todos los pasos, su estructura de directorio debería verse como la siguiente.
bin/
    mathapp
pkg/
    ${GOOS}_${GOARCH}, such as darwin_amd64, linux_amd64
  mymath.a
  github.com/
    astaxie/
      beedb.a
src/
    mathapp
        main.go
    mymath/
        sqrt.go
    github.com/
        astaxie/
            beedb/
                beedb.go
                util.go
Ahora puede ver claramente la estructura de directorios , bin va a contener los archivos ejecutables, pkg va a contener archivos compilados, y src va a contener los archivos de código fuente.
(El formato de las variables de entorno en Windows es %GOPATH%, este libro utiliza principalmente el estilo usado por sistemas Unix-like, por eso los usuarios Windows necesitaran reemplazarlo por su cuenta.)
 
 Indice