Nueva etapa.

Una vez concluidos mis estudios en de licenciatura en la UNAM, he decidido entrar a la Maestría en la Universidad Autónoma de México. Será de Ciencias de la Computación, así que espero compartir con todos ustedes las experiencias y los nuevos apredizajes que tendré. Sobre el tema de la tesis que iré trabajando aún no estoy seguro si deba seguir sobre mi línea de algoritmia de búsqueda de caminos en gráficos o un sistema de NLP sobre idioma wixarika.

Mi implementación del algoritmo Fringe Search para la búsqueda de caminos que tienden a ser óptimos en gráficos de maya.

El algoritmo Fringe Search propuesto en http://webdocs.cs.ualberta.ca/~holte/Publications/fringe.pdf por Yngvi Bjornsson Markus Enzenberger, Robert C. Holte y Jonathan Schaeffer produce caminos que tienden a ser óptimos, pero mejoran la velocidad de ejecución de A* de una manera significativa. Pongo a disposición de todos el código fuente usado en mi tesis titulada: "El Algoritmo Fringe Search como solución superior a A* en la búsqueda de caminos sobre gráficos de malla" presentada en la UNAM, en el cual implemento este algoritmo en lenguaje C. Espero sea útil. 

El código puede ser descargado o clonado desde: https://github.com/pywirrarika/fringesearch

Mi implementación del algoritmo A* para gráficos de malla.

Dejo a disposición de todo aquel interesado mi repositorio de GitHub donde se puede encontrar el código de mi implementación del algoritmo A* escrito en C. He usado una skiplist para la lista cerrada junto con arreglos de punteros para un acceso rápido y un buen nivel de optimización para mejorar el tiempo de ejecución. El programa lee un archivo

BMP del cual cargará las partes negras como obstáculos o como nodos intransitables. Como salida genera un archivo BMP nuevo donde se representa el área en la cual se ha buscado y el mejor camino del nodo de inicio al nodo de destino.

Para obtener el código simplemente será necesario introducir el siguiente comando en la terminal:

git clone https://github.com/pywirrarika/astarmesh

O descargarlo directamente de la página: https://github.com/pywirrarika/astarmesh

Python: Convertir todos las las imágenes de una carpeta a otro tamaño.

Pequeño script que convierte todas las imágenes de una cierta carpeta a un nuevo tamaño que se especifica en los argumentos de la línea de comandos.

# -*- coding:utf-8 -*-
# Author: Jesús Mager
# Licence: GPL v.3


import os, sys
import Image

if len(sys.argv) != 3:
    print "Syntaxis: imgsize.py xsize ysize"
    exit()
else:
    try:
        x = int(sys.argv[1])
        y = int(sys.argv[2])
    except ValueError:
        print "The arguments must be integers."
        exit()
    size = x,y

def makethumb(inf):
    out = inf + ".new"
    if inf.split(".")[-1]=="new":
        print "%s: Skiped" % inf
        return 0
    
    if inf is not out: 
        try:
            im = Image.open(inf)
            im.thumbnail(size, Image.ANTIALIAS)
            im.save(out, "JPEG")
            print "%s: Done" % inf
        except IOError:
            print "Error opening %s" % inf


if __name__ == "__main__":
    files = [ f for f in os.listdir(".") if os.path.isfile(os.path.join(".",f)) ]
    for f in files:
        makethumb(f)

Adecuar la navegación hjkl de VIM a una posición más cómoda.

Sólo quiero compartiles una configuración muy simple en VIM que podría ayudar a varios haciendo más fácil la navegación. En vez de usar el desnaturalizado HJKL que viene por defecto en VIM para subir, bajar, e ir a izquierda y derecha, prefiero usar JKLÑ en mi teclado o para los teclados ingleses JKL;.
He aquí el código que hay que agregar a .vimrc en nuestro directorio $HOME.

set nocompatible
noremap ñ l
noremap l k
noremap k j
noremap j h

 De esta manera podremos usar ñ para ir a la izquierda, j para ir a la derecha,  k para bajar y l para subir.

Contar líneas de código C

¿Quieres saber cuántas líneas de código en C que has escrito en tus archivos de código fuente en una carpeta dada? ¿Además quieres contar sólo las líneas de código sin contar los comentarios y las líneas en blanco? Aquí un pequeño comando en nuestra terminal GNU/Linux o en cualquier sistema *nix.

cat * | sed '/^\s*#/d;/^\s*$/d' | wc -l

Obviamente se puede ajustar a todas las necesidades.

¿Por qué sigue usándose Turbo C/C++ en las escuelas?

Turbo C es un compilador creado por Borland en 1987 para el desarrollo en MS-DOS(aunque también hubo versiones para Atari y OS/2)  el cual fue reemplazado por Turbo C++ en 1990.La última versión de Turbo C++, la 3.01, en 1992, con lo que posteriormente se concentraría la empresa en su producto Borland C++ y C++ Builder.

A pesar de ser un compilador histórico, donde muchos de nosotros dimos nuestros primeros pasos en la programación en C y C++, se debe reconocer que nuestro compilador de 16bits ha pasado a la historia y su lugar es estar en una vitrina en el museo de la informática. 

Sin embargo, un gran número de escuelas, tienen como su compilador de cabezera ese viejo conocido: ¡Turbo C! No es extraño encontrarnos hoy en día, en diversos foros de programación código que usa las viejas bibliotecas.

¿Me pueden ayudar con este código? ... y se lee: gotoxy(23,5); clrscr(); etc. 

Parecería ser que el tiempo no ha cambiado en nada, que MS-DOS sigue siendo un sistema operativo, y no una terminal emulada por los sistemas windows modernos. A este ritmo no nos sorprendería ver código que invoque resoluciones de 320x200 con 256 colores indexados.

                            void SetVideo (void)
                            {
                                    asm{
                                                mov ah,0
                                                mov al,13h
                                                int 10h
                                          }
                            }

A pesar de que tenemos buenos recuerdos, y extrañamos los hacks del Modo 13h y Modo X, y otras curiosidades, es una verdadera barbaridad que a los alumnos no se enseñe a escribir código en compiladores modernos. Pareciera ser que los maestros, sin ganas de desarrollar nuevos retos de programación para sus alumnos, intentan reproducir una y otra vez los mismos ejercicios obsoletos.
El problema no solo es que la lógica no se puede reducir a producir cuadros de texto con colores en una consola de los años 90's sobre MS-DOS, sino que no dejan una verdadera experiencia de como se realiza la programación en C y C++ para sistemas modernos (lo cual no necesariamente quiere decir que se requiera una GUI.)
Recomiendo, para todos aquellos a quienes aún les estén enseñando con este compilador obsoleto, guardarlo en una carpeta llamada muso y descargar la versión del compilador GCC u otro compilador de nueva generación (como VC++ en Windowos) para su sistema operativo. Si requiere alguien de programación gráfica para ver los resultados de su lógica palpables en la pantalla puede usar SDL, que es una excelente biblioteca gráfica multiplataforma. 

• Para Windows recomiendo ampliamente usar la distribución más actual de MingW, en concreto esta: http://nuwen.net/mingw.html (Evite usar Dev-C++ que su desarrollo ha sido parado, y si requiere un entorno gráfico use http://wxdsgn.sourceforge.net/ a pesar de también ya llevar 2 años sin actividad.)
• En GNU/Linux: Instalar el compilador GCC desde su repositorio. ej. en debian like: sudo apt-get install build-essential
• En Mac OS X: Instale sus herramientas de desarrollador que incluirán la versión más adecuada de GCC. 

Tux4Kids: Mentor en Google Code-In

Nuevamente Tux4Kids ha sido aceptado en el Google Code-In que es un concurso para jóvenes menores a 18 años, en el cual pueden contribuir de diversas formas a proyectos se software libre y abierto. Desde imágenes, investigaciones, hasta código, los jóvenes pueden incorporar sus esfuerzos a diversos proyectos que todos conocemos. Este año participan, además de Tux4Kids, FreeBSD, GNOME, OpenSUSE, Perl, VideoLAN, PySoy, KDE, entro otros.
Los premios por participante comienzan al realizar una contribución, ganando 25 dólares y una playera. Pero los premios aumentan hasta 500 dolares y un viaje todo pagado a GooglePlex en Mountain View California.
Para cualquier ayuda o comentario, estaré de asesor para el Proyecto Tux4Kids y pueden ponerse en contacto por este blog o por la lista oficial del proyecto. Espero se animen.

Flask: Un mundo poderoso y minimalista para la programación Web

He descubierto el mundo de los "microframework"s en Python. Estoy tratando de escribir un nuevo proyecto web, con la intención de hacerlo a mi medida. La herramienta tradicional: Django. que suelo utilizar me ha comenzado a poner piedras en el camino al querer hacer ciertas cosas que no están dentro del estándar.

Al investigar, me tomé la molestia de experimentar con varias alternativas. Entre ellas TG, pyramid, cherrypy, web2py, etc... Pero me encantó la elegancia de Flask. Ya con anterioridad había llegado a la página, pero no me había tomado la molestia de revisar su documentación. Resulta ser una de las aplicaciones mejor documentadas, minimalistas, pero a la vez flexibles para todo los que necesito.

En mi proyecto utilizaré Jinja2 (que es por cierto mi sistema de Templates preferido) y que viene integrado desde la caja con Flask, junto con el ORM SQLAlchemy, que tiene una exención hecha para Flask. Les presento un rápido extracto de código para que se puedan dar una idea de lo confortable que es trabajar con este microframework.


from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
return 'Index Page'

@app.route('/hello')
def hello():
return 'Hello World'

if __name__ == '__main__':
app.run()


Para más información pueden visitar la página de Flask en http://flask.pocoo.org/ Estaré informando de las diversas dificultades, que seguramente enfrentaré, al desarrollar mi proyecto.

Usuarios independientes en el Admin de Django

Muchas veces los programadores de Django quieren usar la poderosa herramienta del Admin para permitir funcionar como un centro de administración para los diversos usuarios que se registran en un sitio. Pero al generar usuarios de staff con acceso al admin, estos pueden editar cualquier campo, a pesar de no ser el suyo. Para evitar esto, es posible configurar nuestro archivo admin.py para sobre heredar el administrador y sobre escribir dos funciones. Veamos el código:


from django.contrib import admin
from myproject.pages.models import pagesPage



class pagesPageAdmin(admin.ModelAdmin):
def save_model(self, request, obj, form, change):
if getattr(obj, 'added_by', None) is None:
obj.added_by = request.user
obj.last_modified_by = request.user
obj.save()

def queryset(self, request):
qs = super(pagesPageAdmin, self).queryset(request)

#If super-user, shows all rows
if request.user.is_superuser:
return qs
return qs.filter(added_by=request.user)


admin.site.register(pagesPage, pagesPageAdmin)

Tomando en cuenta que hemos declarado en models.py los necesarios campos, como lo es added_by como foreign key a User, de Auth. Espero ayude!

Autocompletado de Django en VIM

Para poder usar el autocompletado de VIM en projectos Django es necearios tener estas lineas en nuestro archivo .vimrc

syntax on

autocmd FileType python set omnifunc=pythoncomplete#Complete
autocmd FileType javascript set omnifunc=javascriptcomplete#CompleteJS
autocmd FileType html set omnifunc=htmlcomplete#CompleteTags
autocmd FileType css set omnifunc=csscomplete#CompleteCSS

Y con esto listo, copiar este script que podemos colocar en alguna dirección dentro del path como lo es /usr/local/bin o crear un directorio para el path local en el home.

#!/bin/bash

# Name:         djvim
# Description:  Script to automate the setup of the
#               enviroment vars to use omicomplete in vim
#               for Django projects. 
# Usage:        djvim filename
#
# Author:       Jesús Manuel Mager Hois
# Copyright:    GPL v3 or later


#Set the global vars to the Django project
function startvim(){
    local arr=$(echo $1 | tr "/" "\n")
    for x in $arr
    do
        #echo "[$x]"
        local PROJECT=$x
    done
    echo $PROJECT
    cd ..
    local DIR=`pwd`
    export PYTHONPATH=$PYTHONPATH:$DIR
    export DJANGO_SETTINGS_MODULE=$PROJECT.settings 
    vim $ARGS
}

#Iter the directory tree to find setting.py
function finddjbase(){
    cd ..
    local DIRF=`pwd`
    local FILEF=`echo "$DIRF/settings.py"`
    if [ $DIRF == '/' ]
    then
        echo "Couldn't find the Django base directory"
        exit
    fi
    echo "Trying in $DIRF"
    if ( ! fileexists $FILEF )
    then
        finddjbase
    else
        startvim "$DIRF"
        exit
    fi
}

#Check if we can find setting.py
function fileexists(){
    local f="$1"
    if [ ! -f $f ]
    then
        echo "This is not the Django base directory... trying"
        return 1
    else
        echo "settings.py FOUND at $1"
        return 0
    fi
}

#Main block

ARGS=$@
DIRN=`pwd`
FILEN=`echo "$DIRN/settings.py"`

if ( ! fileexists $FILEN )
then
    finddjbase
else
    startvim $DIRN
    exit
fi

Y listo, podemos abrir nuestro archivo con fjvim nombredelarchivio.py

Primera impresión del iPad2 de un programador de Software Libre

La semana pasada mi madre ha decidido comprarse un iPad2 por razones de movilidad. El simpático computador pesa alrededor de 600 gramos, y goza de una muy buena fama. Escogió el modelo con opción 3G y con 32 GB en disco duro. Por mi parte, no encontré ningún motivo para evitar esta compra para un usuario con modestas pretensiones. ¿Cuáles son estas pretensiones?

• Escribir en un procesador de textos decente.
• Proyectar películas desde YouTube, o presentaciones desde archivos PowerPoint.

La propaganda oficial argumenta una gran variedad software disponibles desde AppStore, las cuales es posible adquirir ya sea comprando o descargando gratuitamente. Desde que salió el iPhone, desconfié de esta plataforma cerrada, pero no había tenido la posibilidad de probarla en carne propia.
Al ayudar a mi madre en la configuración de su iPad para que pudiera cumplir sus expectativas me encontré con un verdadero calvario que comprobó mis reservas iniciales. Enumeraré lo peor que pude encontrar:

• De las aplicaciones disponibles desde el AppStore son muy contadas las que ofrecen verdadera calidad, incluso dentro de las aplicaciones con costo.
• No pude encontrar un Procesador de Textos decente. Un trabajo de investigación necesariamente requiere de citas y pies de página. Ni Pages(creado por Apple y la aplicación más avanzada en este sector) pudo ofrecer esta característica tan elemental. Las demás aplicaciones ofimáticas ofrecían aún menos capacidades.
• La conectividad es pésima. El dispositivo se encuentra tan cerrado que no puede acceder libremente una red e imprimir en algún servidor de impresiones.
• Si bien Pages es el procesador de texto más avanzado, su productor no permite conectarse a servicios tan importantes como Dropbox y sólo se limita a sus propios servicios (iDisk y iCloud).

Al final mi madre terminó usando DocsToGo para estar constantemente interactuando con su computadora vía Dropbox, aún a costa de características de Pages. En lo particular extrañé compilar las aplicaciones de mi preferencia, usar Python y en general gozar de una verdadera computadora.
El harware tiene buena pinta, el problema es lo cerrado del sistema. Yo no compraría uno de estos equipos y no los recomiendo, pero si alguien quiere gastar más de diez mil pesos para escuchar música, ver alguna película y jugar, adelante, quizá esta curiosidad es para ustedes.

Hacer que autoconf detecte LUA 5.1

He tenido algunos problemas para poder hacer detectar las librerías de LUA en autotools. He logrado realizar esto con algunas pruebas de nombres y así lograr incluir las bibliotecas y las cabeceras. AUX_LUA.m4 no logra detectar LUA en Debian, pero no se si también tiene dificultades en otras distribuciones. Al parecer en Ubuntu también existe un problema semejante.

Aquí el código básico del configure.ac que busca LUA 5.1.

AC_INIT([luaexp], [1.0], algo@correo.com)

AC_PREREQ(2.61)
AC_CANONICAL_HOST
AC_CANONICAL_BUILD
AC_CANONICAL_TARGET

AM_INIT_AUTOMAKE([foreign -Wall -Werror])
AC_PROG_CC

dnl Check for LibLua: --------------------------------------------------------

AC_MSG_CHECKING([for Lua package name])
PKG_CHECK_EXISTS([lua5.1], [LUA="lua5.1"],
    [PKG_CHECK_EXISTS([lua-5.1], [LUA="lua-5.1"], [LUA="lua"])])
AC_MSG_RESULT([$LUA])

PKG_CHECK_MODULES([LUA],
 [$LUA],
 ,
 [ [echo "$LUA not found via pkg_config, checking AC_CHECK_LIB:"]
      AC_CHECK_LIB([$LUA],
 [lua_newstate],
 ,
 [AC_MSG_ERROR([LUA no found! http://www.lua.org/download.html])]
 )
 [echo "$LUA successfully located"]
 ] 
)

AC_DEFINE([HAVE_LUA],[1],[Define to 1 if you have the `LUA` library])


CFLAGS="$CFLAGS $LUA_CFLAGS"
LIBS="$LIBS $LUA_LIBS"

AC_CONFIG_HEADERS([config.h])
AC_CONFIG_FILES([Makefile src/Makefile])

AC_OUTPUT

Espero esto ayude a cualquier otra persona que necesite incluir LUA en su proyecto. En negrita resalto el código específico para la detección.

Google Code-In en acción!

Muchos jovenes de menos de 18 años están participando en un verdadero maratón, resolviendo las tareas más variadas que les ponen en el mundo del software libre y abierto. El premio: $500 dólares y una invitación a google de los jóvenes más destacados. Tux4Kids, con todos sus proyectos también está participando, y los primeros resultados son muy halagadores.
En este momento me encuentro subiendo al repositorio un arquero que un joven creó para TuxHistory. también tuxMath ha tenido un avance muy importante; la reorganización de sus asteroides en niveles.
Inivito a todos lo interesados a darse una vuelta por www.google-melange.com para participar, o simplemente para observar el avance del concurso.

El verano ha terminado: TuxHistory

Les muestro la primera versión de prueba, limitada, pero funcional como resultado del Google Summer of Code. Falta mucho camino por recorrer para volver a este juego en una opción real de entretenimiento, pero las bases han sido creadas. Lo veo después de mucho esfuerzo, y siento que falta aún tanto.

Corrupción de memoria? La solución es

Esto será una entrada corta. Programando en C uno no puede menos que pensar que en algún momento los punteros, allocs y por supuesto los arreglos no funcionarán como uno espera. Pero encontrar estos errores entre míles de líneas de código definitivamente no es algo agradabale, claro. sin la ayuda de buenas herramientas.
Programando Tuxhistory me encontré con una muy desagradable sorpresa, un fallo de segmentación que se daba en los lugares mas diversos. Parecería como si hubiera una sinfín de ellos esparcidos por tódo el código. El debugging simple no daba con el responsable, gdb arrojaba lugares exactos donde sedaban, pero nada parecía estar mal, hasta que, gdb señaló al culpable a glib, malloc, etc... Esto no parecía ser más que una corrupción grave de memoria.
Por suerte logré encontrar el fabuloso VALGRIND! Wow! Una estupenda herramienta para poder identificar el verdadero orígen del problema y analizar las errores de escritura, lectura, corrupcion y leaks de memoria. Logré descubrir que el verdadero problema se encontraba en un arreglo que se debordaba con el paso del tiempo y corrompía la memoria aledaña. En verdad, si se encuentran en una situación como esta, les recomiendo ampliamente usar Valgrind http://valgrind.org/ y su excelente documentación: http://valgrind.org/docs/manual/manual.html
Y lo mejor es LIBRE bajo GPL!

Mi configuración VIM

Agrego mi configuración de mi archivo .vimrc Lo hago para compartirlo con el todos y sobre todo para poderlo usar en otras computadoras.

syntax on
set hls
set expandtab
set textwidth=0
set tabstop=4
set softtabstop=4
set shiftwidth=4
set autoindent
set backspace=indent,eol,start
set incsearch
set ignorecase
set ruler
set wildmenu
set smarttab
set nu
set mouse=a

filetype indent on
filetype on
filetype plugin on

let g:pydiction_location = '/home/julio/.vim/after/ftplugin/pydiction/pydiction-1.2/complete-dict'

autocmd FileType python set omnifunc=pythoncomplete#Complete
autocmd FileType javascript set omnifunc=javascriptcomplete#CompleteJS
autocmd FileType html set omnifunc=htmlcomplete#CompleteTags
autocmd FileType css set omnifunc=csscomplete#CompleteCSS
autocmd FileType xml set omnifunc=xmlcomplete#CompleteTags
autocmd FileType php set omnifunc=phpcomplete#CompletePHP
autocmd FileType c set omnifunc=ccomplete#Complete

map <C-s>:setlocal spell spelllang=es_mx<CR>
map <C-e>:setlocal spell spelllang=en_us<CR>
map <C-q>:setlocal nospell<CR>

Arreglos dinámicos multidimensionales en C

En muchas ocaciones no queremos crear un arreglo que se utilice sólo la menoria necesaria en tiempo de ejecución. Sin embargo no resulta tan claro crear este tipo de arreglos de forma dinámica. Peor aún, si creamos un arreglo dentro de una función y queremos revolver el valor de un arreglo estatico esto sería imposible, ya que como es una variable local de la función se elimina antes de poder pasar el valor. Por lo tanto incluyo este pequeño código para poder realizar estas funciones.

#include <stdlib.h>
#define FREE(p)   do { free(p); (p) = NULL; } while(0)

int **alloc_array(int, int);
void free_array(int **, int);

int **alloc_array(int x_size, int y_size)
{
   int i;
   int **array;
   array = malloc(x_size * sizeof(int *));
   if(array == NULL)
   {
 return NULL;
   }
   for(i = 0; i < x_size; i++)
   {
       array[i] = malloc(y_size * sizeof(int));
       if(array[i] == NULL)
       {
           return NULL;
       }
   }
   return array;
}

void free_array(int **array, int x_size)
{
   int i;
   for(i = 0; i < x_size; i++)
      FREE(array[i]);
   FREE(array);
}

Como vemos, tambien es necesario liberar la memoria que hemos reservado para nuestra memoria. Es necesario hacer esto para cada una de las variables y a su vez referenciar todos los punteros a NULL.

Grep Recursivo

Agrego una rápida entrada, que es mas bien para provecho personal :P El comando grep en UNIX nos permite encontrar texto en archivos, una herramienta muy util a la hora de programar. Sin embargo esta magnífica herramienta no tiene una forma de iterar por los directorios hijos. Por lo tanto agrego una combinación entre find y grep que nos permite esto. Sientanse libres de jugar con el comando:

find . -type f -print | xargs grep "lo que se desea buscar" 

Aceptado otra vez en Google Summer of Code

Con la noticia de que he sido aceptado para este Google Summer of Code 2010, con Tux4Kids. Este año inscribí dos proyectos, uno en Oregon State University Open Source Lab con la idea de un Web Crawler Distribuido basado en Pydra, y otro para Tux4Kids, con la idea de crear un Juego RTS (Real Time Strategy) estilo Age of Empires para enseñar historia.
Fue aceptada el projecto para Tux4Kids. Espero sea del interés ver como se va creando el juego. Es un projecto ambicioso, y espero tener la capacidad para poder complirlo, pero creo que el gusto por este tipo de juegos es más importante que otra cosa :).
En este blog iré publicando los avances que trendré. Mientras tanto espero terminar el semestre lo antes posible y así dedicarme de lleno.
Saludos!