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