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!