El Ornitorrinco Enmascarado

#Monotremas: HabbitRPG, MyScriptFont y Lino

2013-03-18T09:00:00.000Z

En mi afán de animar un poco el blog, voy a empezar una sección (etiqueta #Monotremas) con las utilidades, aplicaciones, páginas o servicios que más me han llamado la atención en Internet. No descarto poner algún día una chorrada, si me parece graciosa, pero seran raras excepciones. vamos con Los monotremas de la semana:

HabbitRPG

HabbitRPG te permite convertir tus metas y tus objetivos en un Juego de Rol. Si lo haces bien, ganas puntos de experiencia y monedas de plata y oro con las que puedes conseguir nuevas armas, escudos, armaduras y demás parafernalia. Si fallas, pierdes puntos de vida; si fallas miserablemente, pierdes todo lo ganado y tienes que empezar de nuevo. Quien sabe, quiza sea el extra de motivación que algunos necesitamos. Tiene una Campaña en Kickstarter para mejorar el producto.

MyScriptFont

MyScriptFont es una aplicación web que te permite obtener una fuente o tipografia a partir de tu propia letra manuscrita. Es muy sencillo de usar; te descargas desde la web una plantilla,la rellenas con tu letra, la escaneas y la subes. Tras unos pocos segundos, obtienes un fichero con la tipografía en formato TrueType. Lo que ya no resulta tan sencillo es que tengas una letra bonita que merezca el esfuerzo. Ojo con la orientación, tamaño y posición relativa de los caracteres. Mi primera versión ha sido un truño, si consigo algo mas presentable la publicaré aquí.

Lino

Lino es un servicio de publicación y compartición de notas, fotos, vídeos, enlaces, y lo que se ocurra, sobre una pizarra virtual. Es como el tablero de corcho de toda la vida, pero en la nube. Es sencillo de usar y puede ser una gran herramienta de trabajo colaborativo. Los tableros pueden ser privados, públicos pero sólo para lectura (cualquiera puede ver el tablero, pero no modificarlo), o totalmente públicos. El registro es gratuito, y solo necesitas un navegador moderno y/o un smartphone para usarlo. Puedes acceder a una demostración de lino -sin necesida de registrarte- desde su página web.

Google Reader ha muerto, larga vida a Feedly

2013-03-14T14:09:00.000Z

¿Te sientes dolido, casi traicionado por la anunciada muerte de Google Reader? Una rápida búsqueda en Google y parece que su próximo sucesor apunta maneras: Feedly. Como no hay mejor suerte que estar en el sitio preciso en el momento preciso (¿Verdad, Eddard Stark?), los de feedly parece que se venían oliendo que esto iba a pasar, y llevan trabajando en un reemplazo, el proyecto Normandía, una reimplementación compatible a nivel de API de los servidores de GoogleReader, y ejecutandose sobre Google App Engine, por añadir un poco de sal a la herida.

Feedly tienen aplicaciones nativas para teléfonos iOS, Android y Kindle, y plugins para Chrome y Firefox. Puedes usarlo simplemente registrándote con tu cuenta de Google, y el día fatídico en que se cierre el servicio de Google las aplicaciones empezarán a usar Normandy, con lo cual el usuario no debería notar ningún problema. Parece que han añadido más servidores para evitar el colapso ante la avalancha de usuarios que, presumiblemente, les caerá encima.

Por lo que he podido ver usa más o menos los mismos atajos de teclado (J/K para avanzar/retroceder, ? para la ayuda), y tiene diferentes formas de visualización, por defecto nos muestra una llamada magazine, bastante atractiva, pero tiene la posiblidad de cambiar a una vista más resumida, title, solo con los títulos de las entradas; esto es imprescindible para poder filtrar rápido cuando tienes, como yo, poco tiempo y muchos feeds. En esta página hay más consejos para sentirte cómodo en feedly si vienes de Google Reader (en Inglés).

Pygments: Embellece tu código fuente

2013-03-13T14:42:00.002Z

Pygments es una librería, plugin y utilidad, todo en uno, que nos permite embellecer nuestro código, añadiendo resaltado de palabras claves y colores que facilitan la lectura del mismo. Es especialmente útil para foros, wikis, blogs o cualquier sistema de enseñanza on-line que necesiten mostrar código fuente. por ejemplo, lo usa mi repositorio de código favorito, bitbucket.

Pygments está escrito en Python, pero entiende muchos tipos de lenguaje, incluyendo los lenguajes de programación más populares como Python, Ruby, JavaScript, C, C++, C#, Java, Lua, Perl, lenguajes clásicos como Pascal, Common Lisp o Fortran, lenguajes nuevos como CoffeeScript o Clojure, lenguajes de plantillas como los de Django, Jinja, ERB (Ruby templating), Mako o Myghty y mil cosas más: ficheros de configuración de Apache, hojas de estilo CSS, SQL, etc... Esta variedad viene dada por lo sencillo que resulta escribir nuevos analizadores léxicos; la mayoría de los lenguajes solo necesitan definir algunas expresiones regulares.

Puede usarse como herramienta de línea de comandos: pygmentize, como librería para uso interno o como plugin o añadido para sistemas ya existentes: Wordpress, MoinMoin y REsT entre otros. Es muy fácil tanto de utilizar como de extender; puedes personalizar la hoja de estilos para reflejar tus gustos estéticos (Pero recuerda, marrón y azul rara vez combinan). La salida más común es Html, pero también podemos obtener la salida en RTF, LaTex o códigos ANSI para la consola.

Para integrarlo con Blogger usé la línea de comandos para obtener los estilos CSS correspondientes (pygmentize -f html -S colorful) y los incluí en mi plantilla.

Como creo fervientemente en las virtudes didácticas de los ejemplos, he aquí un cacho de código Python (¡Mi primer código publicado en Python 3!) antes de Pygments:

granos = 1
for escaque in range(1, 65):
    print ("En el escaque #{0} hay #{1} granos".format(escaque, granos))
    granos *= 2

Y después:

granos = 1
for escaque in range(1, 65):
    print ("En el escaque #{0} hay #{1} granos".format(escaque, granos))
    granos *= 2

Veamos otro ejemplo, esta vez con Ruby. Antes:

granos = 1
64.times do |escaque|
    puts "En el escaque #{escaque+1} hay #{granos} granos"
    granos *= 2
    end

Y después:

granos = 1
64.times do |escaque|
    puts "En el escaque #{escaque+1} hay #{granos} granos"
    granos *= 2
    end

Como escribir una calculadora en 70 líneas de Python, mediante un analizador descendente recursivo

2013-03-12T13:57:00.001Z

Este post es una traducción del artículo original de Erez, publicado en su blog Stories For Sad Robots. El original puede consultarse aquí:

http://blog.erezsh.com/how-to-write-a-calculator-in-70-python-lines-by-writing-a-recursive-descent-parser/

Hay referencias a un artículo anterior, si alguien está interesado un que lo traduzca también que me deje un comentario y se hará lo que se pueda.

Hace tres meses, escribí un post detallando el proceso de implementar una calculadora usando una librería de parsing. La respuesta popular, sin embargo, mostró que la mayoría de los lectores estaban más interesados en ver una calculadora implementada desde cero, usando solo las "pilas incluidas". Y me dije ¿Por qué no?

Implementar una calculadora es fácil, si usas algunos trucos específicos de las expresiones aritméticas, pero usar estos trucos siempre produce lo mismo: La solución pierde elegancia, no se puede extender y se hace difícil de comprender intuitivamente. Como parecía un desafío interesante, y puede conducir a un post útil, he decidido escribirlo usando un analizador descendente recursivo (recursive descent parser en wikipedia) genérico. Con la mismo filosofía de la vez anterior, quiero mantener el menor número de líneas que sea razonable, así que el código estará lleno de trucos y hacks, pero estarán a un nivel superficial y no serán específicos de la tarea que tenemos entre manos.

Este artículo es una explicación detallada, paso a paso, de la implementación. Si quieres pasar directamente al código e intentar entenderlo por tu cuenta, solo tienes que ir a la última parte. Con suerte una vez leído y entendido el artículo tendrás una mejor comprensión del funcionamiento interno de un analizador sintáctico. Luego puedes incluso utilizar una librería de análisis sintáctico de verdad y ahorrarte todos estos enojosos detalles.

Para entender este artículo, hace falta tener un conocimiento más o menos completo de Python, y es recomendable tener al menos una idea de lo que son los analizadores sintácticos o parsers y para que sirven. Si no estás seguro, te recomiendo que leas el artículo anterior How To Write A Calculator in 50 Python Lines (Without Eval), en el que se explica la gramática que usaremos aquí.

Paso 1: Tokenizar (Tokenize)

Para poder evaluar una expresión, el primer paso será convertirla en una lista de símbolos individuales, o tokens. Esta es la parte más fácil, y no es el tema central de interés en este artículo, así que haremos un poco de trampa para facilitar las cosas.

En primer lugar, definiremos los tokens (Se observará que falta la definición de números, eso es porque vamos a considerarlos el valor por defecto):

token_map = {'+':'ADD', '-':'ADD',
             '*':'MUL', '/':'MUL',
             '(':'LPAR', ')':'RPAR'}
Token = namedtuple('Token', ['name', 'value'])

Y este es el código que usaremos para tokenizar una expresión dada, expr:

split_expr = re.findall('[\d.]+|[%s]' % ''.join(token_map), expr)
tokens = [Token(token_map.get(x, 'NUM'), x) for x in split_expr]

La primera línea es un truco que divide la expresión en sus componentes básicos, de forma que:

'1.2 / ( 11+3)' --> ['1.2', '/', '(', '11', '+', '3', ')']

La siguiente línea asigna nombres a los tokens, para que el parser pueda reconocerlos por categoría:

['1.2', '/', '(', '11', '+', '3', ')']
-->
[Token(name='NUM', value='1.2'), Token(name='MUL', value='/'),
Token(name='LPAR', value='('), Token(name='NUM', value='11'),
Token(name='ADD', value='+'), Token(name='NUM', value='3'),
Token(name='RPAR', value=')')]

Se asume que cualquier token que no esté en el diccionario token_map corresponderá a un número. Nuestro tokenizador carece de la virtud de la validación, que evitaría que se aceptaran cosas que no fueran números, pero por suerte el evaluador realizará más tarde esta tarea por nosotros.

Ahora que ya tenemos una lista de tokens, nuestro siguiente paso será parsearlo para obtener un AST.

Paso 2: Definir la gramática

El parser que usaremos en esta implementación es un versión un tanto ingenua de parser recursivo descendente (recursive descent parser), que es una versión simplificada del parser LL (LL parser). Este tipo de parser es el más fácil de implementar, y de hecho solo nos ocupará unas 14 líneas de código. Es un tipo de parser descendente, lo que significa que primero intenta emparejar la regla más alta (como expression), y continua de forma recursiva intentado emparejar subreglas hasta que alcanza las reglas de más bajo nivel (como por ejemplo, number). Para expresarlo de otra manera, mientras que un parser ascendente (Como un LR Parser o Analizador sintáctico LR en español) intenta de forma gradual "plegar" o "comprimir" tokens y reglas dentro de otras reglas, hasta que solo quede una, un parser descendente irá expandiendo las reglas, usando cada vez reglas menos abstractas, hasta el punto en que haya emparejado completamente los tokens de entrada.

Pero antes de entrar en materia con el parser, hablemos un poco de la gramática. En el post anterior usamos un parser LR, y se definió la gramática así (las mayúsculas son tokens):

add: add ADD mul | mul;
mul: mul MUL atom | atom;
atom: NUM | '(' add ')' | neg;
neg: '-' atom;

Note

Si no entiendes esta gramática, deberías leer el artículo anterior: How To Write A Calculator in 50 Python Lines (Without Eval).

esta vez usaremos un parser LL, así que definiremos la gramática de esta otra forma:

rule_map = {
    'add' : ['mul ADD add', 'mul'],
    'mul' : ['atom MUL mul', 'atom'],
    'atom': ['NUM', 'LPAR add RPAR', 'neg'],
    'neg' : ['ADD atom'],
}

Hay un cambio sutil: Las definiciones recursivas de add y mul están invertidas. Este detalle es muy importante, y necesita su aclaración.

La versión LR de esta gramática usa lo que se llama recursividad por la izquierda (left recursion en inglés). Cuando un parser LL se encuentra con una llamada recursiva, la ejecuta de inmediato, en un intento de emparejar la regla que está utilizando, por lo que puede entrar en un bucle infinito. Incluso parsers LL bastante avanzados como ANTLR se enfrentan a esta problema, aunque probablemente, en vez de dar vueltas indefinidamente, como hace nuestro parser de juguete, terminarán con un conveniente mensaje de error .

La recursividad por la izquierda se soluciona de forma sencilla cambiándola por recursividad por la derecha, que es justo lo que acabamos de hacer con nuestro sutil cambio. Pero como nada en la vida es fácil cuando tratamos con parsers, se ha creado otro problema: Mientras que la recursividad por la izquierda analiza 3-2-1 correctamente como (3-2)-1, la recursividad por la derecha lo analiza, de forma incorrecta, como 3-(2-1). No sé como solucionar esto de forma fácil, así que para mantener las cosas sencillas he optado por mantener la forma incorrecta y resolverlo en una etapa posterior (véase el paso 4).

Paso 3: Obtener un AST (Árbol de Sintaxis Abstracta)

El algoritmo es sencillo. Vamos a definir una función recursiva que acepta dos parámetros: El primero es el nombre de la regla que estamos intentando capturar, y el segundo es una lista de los tokens que nos quedan por comprobar. Empezaremos con add, -que es la regla más alta- y con la lista de todos los tokens, y haremos que las sucesivas llamadas recursivas sean cada vez más específicas. La función retorna una tupla: La correspondencia encontrada y una lista de los tokens que faltan por comprobar. Con el propósitos de reducir en lo posible el código, este será capaz de encontrar tokens también (En los dos casos son cadenas de texto: en un caso con todas las letras en mayúsculas y en el otro con todas las letras en minúsculas).

Este es el código del parser:

RuleMatch = namedtuple('RuleMatch', ['name', 'matched'])

def match(rule_name, tokens):
    if tokens and rule_name == tokens[0].name:      # Match a token?
        return RuleMatch(tokens[0], tokens[1:])
    for expansion in rule_map.get(rule_name, ()):   # Match a rule?
        remaining_tokens = tokens
        matched_subrules = []
        for subrule in expansion.split():
            matched, remaining_tokens = match(subrule, remaining_tokens)
            if not matched:
                break   # no such luck. next expansion!
            matched_subrules.append(matched)
        else:
            return RuleMatch(rule_name, matched_subrules), remaining_tokens
    return None, None   # match not found

Las líneas 4-5 comprueban si rule_name es realmente un token, y si coincide con el token actual. Si lo hace, devuelve la coincidencia, junto con el resto de los tokens que aun faltan por consumir.

La línea 6 itera sobre las subreglas de rule_name, de forma que cada una pueda ser analizada recursivamente. Si rule_name es un token, la llamada a get() devolverá una tupla vacía y el código continuará hasta alcanzar el return final, que devuelve una tupla sin valores.

Las líneas 9-14 iteran sobre cada elemento de la subregla actual, e intenta hacerlas coincidir de forma secuencial. Cada iteración intenta consumir tantos tokens como le sea posible. Si un elemento no coincide, se descarta toda la regla. Si, por el contrario, se consigue casar todos los elementos, alcanzaremos la cláusula else y devolveremos nuestra coincidencia para rule_name, junto con el resto de tokens que faltan por casar.

Vamos a ejecutarlo con 1.2 / ( 11+3) como entrada:

>>> tokens = [Token(name='NUM', value='1.2'), Token(name='MUL', value='/'),
              Token(name='LPAR', value='('), Token (name='NUM', value='11'),
              Token(name='ADD', value='+'), Token(name='NUM', value='3'),
              Token(name='RPAR', value=')')]
>>> match('add', tokens)
(RuleMatch(name='add', matched=[RuleMatch(name='mul',
matched=[RuleMatch(name='atom', matched=[Token(name='NUM', value='1.2')]),
Token(name='MUL', value='/'), RuleMatch(name='mul',
matched=[RuleMatch(name='atom', matched=[Token(name='LPAR',
value='('), RuleMatch(name='add', matched=[RuleMatch(name='mul',
matched=[RuleMatch(name='atom', matched=[Token(name='NUM', value='11')])]),
Token(name='ADD', value='+'), RuleMatch(name='add',
matched=[RuleMatch(name='mul', matched=[RuleMatch(name='atom',
matched=[Token(name='NUM', value='3')])])])]), Token(name='RPAR',
value=')')])])])]), [])

El resultado es una tupla, como era de esperar, y podemos ver que no queda ningún token para analizar. La coincidencia actual no es fácil de leer, vamos a representarla gráficamente para que se entienda mejor:

add
    mul
        atom
            NUM '1.2'
        MUL '/'
        mul
            atom
                LPAR    '('
                add
                    mul
                        atom
                            NUM '11'
                    ADD '+'
                    add
                        mul
                            atom
                                NUM '3'
                RPAR    ')'

Esta es la pinta que presenta un AST, en concepto. Es una buena práctica ejecutar mentalmente el parser, o quizá con la ayuda de papel. Me atrevería a decir que es necesario si realmente quieres entenderlo. Puedes usar este AST como referencia para asegurarte de que lo estás haciendo bien.

En este punto, henos escrito un parser capaz de analizar correctamente operaciones binarias, operadores unitarios, paréntesis y precedencia,

Solo hay una cosa que hace mal, y vamos a arreglarla a continuación.

Paso 4: Post Procesado

El parser no es perfecto en muchos aspectos. El más importante ahora es que no puede manejar la recursividad por la izquierda, lo que obliga a que la gramática sea recursiva derecha. En consecuencia, analizar la cadena 8/4/2 nos genera el siguiente AST:

add
    mul
        atom
            NUM 8
        MUL '/'
        mul
            atom
                NUM 4
            MUL '/'
            mul
                atom
                    NUM 2

Si intentamos resolver esta expresión con este árbol, tendríamos que calcular primero 4/2, que es incorrecto. Algunos parsers LL eligen arreglar la asociatividad en el árbol. Pero esto llevaría demasiadas líneas ;). En vez de eso, lo que vamos a hacer en "aplanarlo". El método es sencillo: Para cada regla en el AST que:

necesite ser arreglada,

sea una operación binaria (tiene tres subreglas), y

el operando por la derecha resulta ser la misma regla

entonces "aplanaremos" la última en la primera. Por "aplanar" quiero decir reemplazar un nodo por sus hijos, en el contexto de su padre. Como nuestro recorrido por el árbol es DFS post-order, esto significa que empieza por los bordes del árbol y va progresando hacia la raíz, de forma que los efectos son acumulativos. Este es el código:

fix_assoc_rules = 'add', 'mul'

def _recurse_tree(tree, func):
    return map(func, tree.matched) if tree.name in rule_map else tree[1]

def flatten_right_associativity(tree):
    new = _recurse_tree(tree, flatten_right_associativity)
    if tree.name in fix_assoc_rules
        and len(new)==3
        and new[2].name==tree.name:
            new[-1:] = new[-1].matched
    return RuleMatch(tree.name, new)

Este código convertirá cualquier composición secuencial de sumas o multiplicaciones en una lista plana (sin mezclar unas con otras). Los paréntesis rompen la secuencia, por supuesta, así que no se ven afectados.

A partir de aquí se podría reconstruir la estructura en forma asociativa por la izquierda, usando código como:

def build_left_associativity(tree):
    new_nodes = _recurse_tree(tree, build_left_associativity)
    if tree.name in fix_assoc_rules:
        while len(new_nodes)&gt;3:
            new_nodes[:3] = [RuleMatch(tree.name, new_nodes[:3])]
    return RuleMatch(tree.name, new_nodes)

Pero no lo vamos a hacer. Queremos reducir el número de líneas de código, y cambiar el código de evaluación para que pueda manejar listas conlleva menos líneas que reconstruir el árbol.

Nota

DFS post order: DFS significa "búsqueda en profundidad", y significa que a medida que recorremos el árbol, se visitan primero los nodos que están en los niveles inferiores (O, dicho de otra manera, los más profundos). Hay dos tipos de búsquedas en profundidad, en preorden o postorden. La diferencia entra las dos es el momento en que se añade un nodo a la salida, antes o después de visitarlo)

Paso 5: Evaluar

Evaluar el árbol es muy sencillo. Lo único que hace falta es navegar por él de forma similar a como lo hicimos en el código de post-proceso (Es decir, DFS post-order) y evaluar cada regla que nos encontramos. Como hemos evaluado primero los nodos más profundos, cada vez que alcanzamos un nodo de tipo regla, sus hijos no pueden ser otra cosa más que números. Este es el código:

bin_calc_map = {'*':mul, '/':div, '+':add, '-':sub}

def calc_binary(x):
    while len(x) &amp;gt; 1:
        x[:3] = [ bin_calc_map[x[1]](x[0], x[2]) ]
    return x[0]

calc_map = {
    'NUM' : float,
    'atom': lambda x: x[len(x)!=1],
    'neg' : lambda (op,num): (num,-num)[op=='-'],
    'mul' : calc_binary,
    'add' : calc_binary,
}

def evaluate(tree):
    solutions = _recurse_tree(tree, evaluate)
    return calc_map.get(tree.name, lambda x:x)(solutions)

Hemos escrito calc_binary para que evalúe tanto la suma como la multiplicación (y sus contrapartidas). También evalúa listas, dado el caso, de manera asociativa por la izquierda. De esa forma resolvemos el problema que teníamos con nuestra pequeña gramática LL.

Paso 6: El REPL (Read–Eval–Print Loop)

La forma más sencilla posible sería:

if __name__ == '__main__':
    while True:
        print( calc(raw_input('&gt; ')) )

Que no precisa más explicación. Espero :)

Apéndice: Todo el código en uno: una calculadora en 70 líneas

Este es el código final:

'''A Calculator Implemented With A Top-Down, Recursive-Descent Parser'''
# Author: Erez Shinan, Dec 2012

import re, collections
from operator import add,sub,mul,div

Token = collections.namedtuple('Token', ['name', 'value'])
RuleMatch = collections.namedtuple('RuleMatch', ['name', 'matched'])

token_map = {'+':'ADD', '-':'ADD', '*':'MUL', '/':'MUL', '(':'LPAR', ')':'RPAR'}
rule_map = {
    'add' : ['mul ADD add', 'mul'],
    'mul' : ['atom MUL mul', 'atom'],
    'atom': ['NUM', 'LPAR add RPAR', 'neg'],
    'neg' : ['ADD atom'],
}
fix_assoc_rules = 'add', 'mul'

bin_calc_map = {'*':mul, '/':div, '+':add, '-':sub}
def calc_binary(x):
    while len(x) &amp;gt; 1:
        x[:3] = [ bin_calc_map[x[1]](x[0], x[2]) ]
    return x[0]

calc_map = {
    'NUM' : float,
    'atom': lambda x: x[len(x)!=1],
    'neg' : lambda (op,num): (num,-num)[op=='-'],
    'mul' : calc_binary,
    'add' : calc_binary,
}

def match(rule_name, tokens):
    if tokens and rule_name == tokens[0].name:      # Match a token?
        return tokens[0], tokens[1:]
    for expansion in rule_map.get(rule_name, ()):   # Match a rule?
        remaining_tokens = tokens
        matched_subrules = []
        for subrule in expansion.split():
            matched, remaining_tokens = match(subrule, remaining_tokens)
            if not matched:
                break   # no such luck. next expansion!
            matched_subrules.append(matched)
        else:
            return RuleMatch(rule_name, matched_subrules), remaining_tokens
    return None, None   # match not found

def _recurse_tree(tree, func):
    return map(func, tree.matched) if tree.name in rule_map else tree[1]

def flatten_right_associativity(tree):
    new = _recurse_tree(tree, flatten_right_associativity)
    if tree.name in fix_assoc_rules and len(new)==3 and new[2].name==tree.name:
        new[-1:] = new[-1].matched
    return RuleMatch(tree.name, new)

def evaluate(tree):
    solutions = _recurse_tree(tree, evaluate)
    return calc_map.get(tree.name, lambda x:x)(solutions)

def calc(expr):
    split_expr = re.findall('[\d.]+|[%s]' % ''.join(token_map), expr)
    tokens = [Token(token_map.get(x, 'NUM'), x) for x in split_expr]
    tree = match('add'&lt;div&gt;&lt;/div&gt;, tokens)[0]
    tree = flatten_right_associativity( tree )
    return evaluate(tree)

if __name__ == '__main__':
    while True:
        print( calc(raw_input('&amp;gt; ')) )

Hasta aquí el artículo original. Si quieres que traduzca el artículo anterior al que se hace referencia en el texto, déjame una nota en los comentarios.

Edición especial Python de Full Circle Magazine

2013-03-01T13:43:00.002Z

La revista Full Circle Magazine ha sacado un especial agrupando la serie de artículos sobre programación en Python. Se puede descargar libremente desde aquí:

Full Circle magazine Python Special edition Volume 06

Es la edición número 6, así que supongo que en algún lado estarán las ediciones anteriores, ~~si las encuentro las pondré también~~. Dicho y hecho:

Ediciones anteriores

Big Culo Day 2013

2013-02-18T15:59:00.000Z

Mi aportación al gran Big Culo Day 2013. En esta ocasión, cortesía de Russ Heath:

Extra bonus: Por si está repetida:

¡Ah! ¡Qué satisfacción da el deber cumplido! Hasta el año que viene.

FAQ sobre el fin del mundo 2012

2012-12-21T11:06:00.000Z

Pregunta: ¿Se acabará el mundo en el 2012?

Respuesta: No

Nos vemos en la Barcelona Developers Conference

2012-11-23T14:16:00.000Z

Del 6 al 8 de diciembre voy a asistir a la Barcelona Developers Conference (hashtag #bcndevcon), encuentro organizado por desarrolladores para desarrolladores con una pinta muy interesante.

Me encanta el look apocalípico del evento. Tremendas las profecías de la abeja esa.

Me atraen especialmente los tracks sobre javascript y alternativas (coffeescript sobre todo), desarrollo para android, arduino y hardware abierto, bases de datos NoSql y, como no, Python. En caso de que en los tracks no haya nada interesante -perece poco probable- siempre se puede uno acercar al taller de robótica y sacar ideas para el Plan de Conquista Mundial, que tan abandonado tengo.

Si vas a estar por la conferencia o cercanías, dame un toque por los canales habituales, teléfono, twitter (@jileon), email, etc o, si todo lo anterior falla, deja un comentario en el post. Como mínimo te invitaré a un café.

¡Nos vemos en Barcelona!

Nuevo Blogs and Gofio: XXXVIII edición triunfal

2012-10-08T09:54:00.000+01:00

El ínclito compañero jfrechin ha convocado la muy necesaria y esperada XXXVIII edición de los Blogs & Gofio; básicamente una reunión informal de gente inquieta con ganas de pasarlo bien y conocer personas interesantes. Copio y pego de la convocatoria oficial:

Será el próximo jueves 11 de octubre de 2012*, a partir de las 21:30 horas, en La Casa Abierta de La Laguna.

Si te quieres inscribir, solo es necesario dejar un comentario en esta entrada diciéndolo y listo.

Preguntas y respuestas habituales:

¿Quién puede asistir? -> Cualquiera, tanto si escribes blogs, como si los lees, incluso si no sabes lo que es un blog y quieres pasar un buen rato.

¿Qué es un Blog & Gofio? -> Una reunión de gente relacionada con los blogs (o no) que se reúne de vez en cuando para verse las caras y echarse unas risas.

¿Eso es un rollo de frikis? -> No, la gente que asiste es totalmente normal, o al menos eso cree.

Quiero ir, pero me da rollo porque no conozco a nadie -> No pasa nada, la curva de progreso en la amistad durante los blogs & gofio es, sin exagerar, un millón de veces mayor que en otros ámbitos.

* Si, lo sabemos, es jueves, pero el viernes es fiesta, está todo estudiado.

Me encanta el cartel:

Keep Calm And Code On

2012-09-27T08:34:00.000+01:00

Visto en el tumblr de h4xg33k.

Presentación del Taller sobre Django

2012-08-03T10:33:00.000+01:00

Acabo de subir a Slideshare la presentación que hice para el taller "Introducción al desarrollo web con Django", realizado en la Tenerife Lan Party 2012.

Taller de introducción al desarrollo web con Django from Juan Rodríguez

Esta era la descripción del taller, para que no haya sorpresas:

"Django es código abierto, modular, escrito en Python, y muy potente. En este taller daremos una introducción a Django, e implementaremos desde cero una aplicación web para gestionar los informes secretos de SHIELD. Con registro de usuarios, acceso a base de datos, páginas dinámicas y servicios web."

Creo que a la gente que asistió le gustó el taller, y baso mi suposición en que no me tiraron ni un solo tomate^*. Q.E.D.

^*Aunque tampoco podemos descartar el hecho de que el precio de los tomates se ha disparado últimamente.

Taller de Introducción a Django en la TLP

2012-07-18T10:56:00.001+01:00

Actualización: La presentación que use para este taller. Este viernes, 20 de julio, daré un taller de Introducción a Django en la Tenerife Lan Party, dentro de la seccion TLP Innova. En el taller se intentará implementar una aplicación web en menos de cuatro horas, a la vez que damos un repaso por encima de las posibilidades de Django. Django es un mundo, así que no saldremos convertidos en expertos, pero si, espero, con una idea de las posibilidades de este framework.

Siguiendo el espítitu friki que rodea tanto al evento como a este humilde blog, la estructura del taller será la siguiente: Eres un agente recién incorporado a S.H.I.E.L.D., la agencia de inteligencia y antiterrorismo del Universo Marvel. El mismisimo Nick Furia, mirándote fijamente con su ojo derecho (tampoco es que pueda elegir) te ha encargado que desarrolles una aplicación para realizar el seguimiento de las actividades de los llamados "superheroes" (amenazas enmascaradas, según el editor del Daily Bugle). Las respuestas que Nick Furia espera obtener de tu aplicación son, entre otras:

¿Qué poderes tiene un determinado superheroe?
¿Podemos clasificar a los superheroes en distintos niveles de potencia?
Dado un poder determinado, ¿Qué superheroes lo tienen? ¿Cuáles no? ¿Qué superheroes pueden volar?
¿Qué superheroes forman parte de un determinado grupo, por ejemplo, los Cuatro Fantásticos?
¿Dónde fue la última vez que se ha visto a La Masa (Hulk)?
¿Dónde suele verse con más frecuencia a Spiderman? ¿Podemos mostrar estos avistamientos en un mapa de googleMaps?
Y sobre todo, lo más importante: ¿Quién puede más, La Cosa o La Masa?

Si después de este planteamiento, no te atrae el curso, lo entenderé. Además, a la misma hora Yeray Darias, de A software developer cookbook, dará un taller sobre CoffeScript: Javascript bien hecho con muy buena pinta, al que yo mismo iría si pudiera, pero queda muy feo escaquearse del propio curso. Eso si, si te apuntas, prepárate para tu primer día en S.H.I.E.L.D. ¿Coulson, dices que te llamas?
PD: No olviden que el sábado tenemos otra cita con las DesCon2.

Uso de python y Appy/POD para generar documentos automáticamente

2012-06-29T12:29:00.000+01:00

Una presentación que hice para el trabajo sobre el framework Appy/POD, que nos permite generar documentos LibreOffice/openOffice desde Python, usando documentos como plantillas.

Presentación appy/pod

View more presentations from Juan Rodríguez

Quiza útil. Pero para nada divertido. All work and no play makes the Masked Platypus a dullboy.

Aprender fotografía con un simulador

2012-06-13T12:40:00.001+01:00

Hacia tiempo que no veía una de esas ideas a la vez sencillas (de imaginar, que no de implementar, claro) y poderosas; aprender los conceptos básicos de fotografía, como sensibilidad ISO, tiempo de obturación, profundidad de campo, apertura de diafragma, etc... con un simulador que te permite hacer mil y una perrerías en los ajustes, disparar a un sujeto en movimiento y ver que pasa:

http://camerasim.com/camera-simulator/

Mi hija se aburrió soberanamente en un curso de fotografía al que fue hace poco, y en el que no daban casi ninguno de estos conceptos. Quizá con esta herramienta se interese algo más.

Un boceto hecho en el taller "Dibujando Criaturas Fantásticas"

2012-06-05T08:48:00.000+01:00

Un boceto hecho en el taller "Dibujando Criaturas Fantásticas", organizado por la buena gente del Colectivo de Ilustradores Canarias. Se suponía que tenía que hacer un monstruo horripilante, pero al final me salió este con cara de buena persona. O sapo. O lo que sea. Me lo pasé pipa en el taller.

Su título es Simpática alienigena retratada mientras repara su nave en los alrededores de Magerath-VI.

Nuevo y triunfal Blog & Gofio, el XXXVIII, en Adeje

2012-05-04T13:17:00.000+01:00

Nada menos que El Irreductible se ha decidido a convocar la que, según todos los indicios, será la XXXVIII edición de los Blogs&Gofio, encuentro cultural, social y visceral -pero no virtual- de la gofioesfera. Las tres preguntas importantes son:

¿Dónde?: En Adeje. Si señor, coincidiendo con el encuentro tecnológico Adejetec 2012, así aprovechas el viaje si vienes del gélido norte.
¿Cuándo?: El 17 de mayo de 2012, al medio día y después de las charlas.
¿Por qué?: porque sí.

Más detalles en el post de la convocatoria: La Aldea Irreductible - Blog and Gofio - Edición XXXVII.

Aquí el poster que dibujó algún desustanciado:

PD: Hay una Versión No Oficial del cartel, si alguien quiera verla que me la pida por email. O por twitter. O yo que sé.

Hoy empieza a aplicarse la ley Sinde ...

2012-03-01T10:34:00.002Z

... Y tenemos otro día más de vergüenza ajena. Acabamos de ponernos a la altura de China en lo que respecta a libertad de expresión y censura gubernamental ¹. Que ganas tienen de que no se hubiera inventado Internet.

Y como es una obligación moral oponerse a una ley injusta, aquí va mi enlace a wertdeenlaces.net:

Bájame

Ya está, ya pueden demandarme. La única duda que tengo es si deberían juzgarnos a los disidentes en tribunal español o norteamericano, ya que en última instancia estamos desobedeciendo a aquellos.

¹Quizá no de forma efectiva, pero si conceptual. El tiempo lo dirá. Lo más probable es que se convierte en otra más de las leyes embudo típicas de Españistan: Se aplicará con extrema dureza y ejemplar dedicación a los enemigos, se hará la vista gorda y tolerante a los amiguitos, y al resto que le vayan dando.

Fabric - Simplifica la gestión de tus servidores

2012-02-17T09:00:00.000Z

Fabric es un módulo y conjunto de utilidades que nos simplifica enormemente el realizar muchas tareas, normalmente repetitivas y tediosos, un una o varias máquinas simultáneamente. Es una especie de make con esteroides.

Fabric tiene varias características interesantes, entra las que destacan que es software libre, y que resulta sencillo de utilizar y de instalar. Pero tiene el interés añadido de que está escrito en Python, por lo cual es relativamente fácil añadir nuevas funcionalidades. Además, los ficheros fabfile, que vendrían a ser los equivalente a los Makefile para make o a los ficheros de configuración build.xml de Apache Ant, son en si programas Python. Por cierto, soy de los que piensan que los ficheros de configuración necesitan del XML tanto como un pez necesita una bicicleta. Si eres un xml-zombie puedes ir a la parte de comentarios e insultar allí directamente. De nada.

Veamos un ejemplo: supongamos que tenemos una máquina de desarrollo, 'alfa', otra de pruebas, 'beta', y una tercera de explotación, 'omega'. Queremos, desde la máquina de desarrollo, subir una actualización de código al repositorio, previo control de nuestra batería de pruebas. Si todo es correcto, deseariamos actualizar los servidores. Podemos crear un fichero fabfile.py con el siguiente contenido:

from fabric.api import run, cd, local

def deploy_up():
    code_dir = '/home/euribates/workarea/proyecto'
    with cd(code_dir):
        local('nosetests')
        local('hg commit')
        local('hg push')

def deploy_down():
    code_dir = '/var/www/django/proyecto'
    with cd(code_dir):
        run('hg pull')
        run('hg update')
        run('service apache2 restart')

El uso de las utilidades de Fabric como cd o run hacen que el fichero sea fácil de escribir y, lo que es más importante, fácil de leer. Estoy usando Nose para las pruebas unitarias y Mercurial como sistema de control de versiones, pero esto son mis opciones personales, fácilmente sustituibles por otras. Con este fichero, ahora puedo hacer:

fab deploy_up

Y fabric hará el trabajo sucio por mi. Fabric aborta el proceso si alguno de las programas devuelve un código de error, así que si no se pasan todos los tests, no se ejecutarán ni el commit ni el push, algo bastante de agradecer.

Si todo ha ido bien, puedo hacer:

fab deploy_down -D beta

Para que actualice el código en 'Beta' y reinicie el servidor Apache2. Si eres persona animosa y de corazón valiente, también puedes actualizar en las dos máquinas a la vez, con:

fab deploy_down -D beta,omega

Nota: local y run son equivalentes, ambas ejecutan el comando que se les indica, pero local siempre lo hace en la máquina local, mientras que run lo hará en las maquinas que le indiquemos, usando ssh. Por eso podemos hacer deploy_up sin indicar nada, pero si intentamos hacer un deploy_down sin especificar al menos una máquina, fabric protestará.

Hay muchas cosas más que se pueden hacer con esta herramienta, y podemos aprenderlas en el Tutorial de Fabric.

Curso de Python en la ULL (Posible)

2012-01-13T20:48:00.002Z

La Universidad de La Laguna está pensado organizar unos cursos intensivos de Python, dirigidos a "aquellos interesados en introducirse o conocer el lenguaje Python y sus posibilidades para su uso particular o para introducirlo en sus clase con los alumnos".

El curso sería, en principio, los días 23, 24 y 25 de enero, durante tres horas (09:00 a 12:30 con descanso en medio) en el aula 19 de la Facultad de Física.

El temario propuesto, orientado claramente a un perfil científico, sería el siguiente:

Introducción a Python: Variables estructuradas. Control de flujo. Calculo simbólico.
Cálculo numérico con numpy (paquete numérico). Dibujos y graficos con matplotlib (paquete gráfico). Ajustes de funciones.
Otros paquetes de cálculo científico (scipy y otros que puedan interesar).
Utilización de programas (en Fortran o C o ...) dentro de Python.

Para más información, consultar con la Oficina de Software Libre - Curso de Python.

Avances en detección de mentiras

2011-12-24T15:54:00.001Z

Muy interesante, instructiva y provechosa la charla TED de Pamela Meyer: ¿Cómo descubrir a un mentiroso?

Tiene un libro en que explica el tema con más detalle: Liespotting: Proven Techniques to Detect Deception. Ya lo tengo en la lista para próximas compras. Hubiera caído ya, si no fuera por esa manía que les ha dado ahora a algunas editoriales de poner el ebook más caro que la versión impresa. Por ahí no paso.

Nota de advertencia: No sirve para analizar la política en Españistán. Ahí mienten todos y no tiene gracia.

Teaser trailer de "La Noche de los Muertos Votantes"

2011-11-09T08:56:00.001Z

El teaser Trailer de "La Noche de os Muertos Votantes":

Con su cartel a juego:

XXXIV Blogs and Gofio

2011-10-05T11:51:00.001+01:00

Esther, de Atarecos. Dicho así, suena a nombre de filósofo griego: Zeón de Elea, Tales de Mileto, Esther de Atarecos. Mola. Pero a lo que vamos, que me desvío, Esther, de Atarecos, convoca la XXXIV convocatoria de Blogs & Gofio, esta vez en Gran Canaria. Las grandes preguntas que, cual filósofos griegos, debemos responder, son las siguientes:

¿Dónde?

En Gran Canaria, en el Restaurante La Barbería (c/ Mendizábal, 14).

¿Cuándo?

El viernes 14 de octubre, a las 20:30 horas

¿Quién?

En general, cualquiera que desee asistir. En particular, tú, que estás leyendo esto. No lo niegues, sé que lo estás leyendo justo ahora. No me preguntes cómo lo sé, es uno de mis superpoderes. Si piensas ir, no te olvides de dejar un comentario en el post convocante, más que nada para el tema de reservar en el restaurante.

El cartel oficial del Blogs & Gofio XXXIV, obra del gran Morgan:

Python unittest: Eliminar información redundante en los informes

2011-09-29T08:00:00.000+01:00

En la actualizacion a Python 2.7, el módulo unittest ha modificado la forma que tiene de presentar los resultados. Antes te mostraba una única línea de texto por test, con la primera línea de las descripción del test, si lo hubiera, o el nombre de la clase y función del test, si no lo hubiera. Por ejemplo, el siguiente código:


import unittest

class A(unittest.TestCase):

    def test_A(self):
        pass

    def test_B(self):
        '''este es el test B.
        '''
        pass

Nos daba este limpio resultado:


test_A (__main__.A) ... ok
este es el test B. ... ok

Pero en la 2.7 han cambiado este comportamiento, y ahora imprime el nombre de la clase y el método del test siempre, y si hay una descripción, la incluye como segunda línea. Es decir, produce este resultado:


test_A (__main__.A) ... ok
test_B (__main__.A)
este es el test B. ... ok

Si preferimos la manera antigua, la forma más sencilla de conseguirlo, por ahora, es incluir el siguiente código al principio de tus test (visto en esta respuesta a una pregunta en Stack Overflow: how to change the test description of python (2.7) untitest).


from unittest.runner import TextTestResult
TextTestResult.getDescription = lambda _, test: str(test.shortDescription())

Un hack un poco feo. pero funciona. Es una tontería, pero me tenía de los nervios. Suelo (o intento) documentar casi todos mis tests, con lo que, para mi, el añadido era solo ruido.

Eliminar las nuevas barras de desplazamiento de Ubuntu/Unity

2011-09-27T13:45:00.000+01:00

Al principio me parecieron buena idea, pero después de estar usándolas durante semanas, las nuevas barras de desplazamiento de Ubuntu me han acabado pareciendo un tremendo coñaz*. Ahorrarme 10 pixels en pantalla no se merece tener que estar buscando arriba y abajo cada vez que tengo que hacer un scroll. Además, me daban problemas con un nuevo editor que estoy probando, Editra, por ahora con muy buena pinta. Para eliminarlas de Ubuntu 11.04 (mientras nos dejen) la receta es:

sudo apt-get remove overlay-scrollbar liboverlay-scrollbar-0.1-0

Nota para los diseñadores de Ubuntu: Solo porque puedas hacer algo, no significa que tengas que hacerlo.

Visto en: WEB UDP8 - How To Disable The Overlay Scrollbars In Ubuntu 11.04 [Quick Tip].

Quien puede más: ¿Dora la Exploradora o Lara Croft?

2011-09-15T20:13:00.000+01:00

Hace tiempo que tengo esta duda, que me reconcome:

¿Quién puede más^*? ¿Dora la Exploradora o Lara Croft?

Mi hijo lo tiene clarísimo. Yo tengo dudas...

^*Obsérvese que la pregunta es ¿Quién puede más? NO quien es más fuerte, ni más poderoso, ni ningún otro criterio que sea mínimamente objetivo.

Nota: Añado este comentario que me hizo el amigo Alvaro de Felipe por correo, y que me parece particularmente esclarecedor del nivel intelectual exhibido repetidas veces por Dora:

En realidad Dora la Exploradora es hija natural de Bob Esponja, lo que pasa es que nunca la hicieron la prueba de paternidad y el no la reconoció oficialmente. Yo creo que Dora la Exploradora tiene una capacidad de absorción superior a la de Lara Croft y exclusivamente con ese criterio "abierto", creo que Dora "puede más". Camilo José Cela, en una entrevista televisiva en directo, también aseveró tener una capacidad de absorción de hasta tres litros de agua, pero en este caso por vía rectal. No se ha podido establecer relación alguna entre Bob Esponja y D. Camilo José. Al menos yo no he podido.