2014-07-12

Maschefacts

Mascherano puede decir si cualquier programa termina o no

Mascherano resuelve el camino del viajante antes del almuerzo.
Mascherano encuentra la preimagen de un SHA-256.
Mascherano factoriza números primos y encuentra muchos factores.
Mascherano escribió todos los dígitos de pi.
Mascherano hackea a Bruce Schenier
Mascherano escribe GOTO y no lo consideran perjudicial.
Mascherano sabe el estado de un q-bit antes de que colapse.
Mascherano paseó por Königsberg, pasó una vez por cada puente y volvió al punto del que salió.
Mascherano hizo una máquina de estados que encuentra números primos.
Mascherano resolvio todos los problemas NP en O(1) (Éste es de Gabriel Benmergui)

2014-07-09

Restaurando el agua caliente

El lunes hubo una gran bajante en el Río de la Plata, que hizo que no haya presión de agua y se vaciara el tanque de mi casa. Cuando volvió el agua ayer a la noche, empezó a andar el agua fría, pero no el agua caliente. Mi diagnóstico fue que quedó alguna burbuja de aire en un codo de una cañería, así que llené las cañerías de agua caliente con agua fría. ¿Cómo hice eso? Fui al baño, abrí el agua caliente (no salió nada), tapé la canilla con la mano y abrí el agua fría. Eso hizo que circulara el agua fría para el otro lado. Estuve un minuto así y cerré todo. Abrí de nuevo el agua caliente, dejé circular un poco de agua y ¡empezó a salir el agua caliente! ¡Felicidad! Me puedo volver a bañar en mi casa.
Happy hacking,
Aureliano.

2014-07-07

Notación de tango. Objetivos

Recientemente, empecé la búsqueda de una o varias formas de anotar los pasos que bailamos en tango salón y sus danzas aledañas, milonga, vals y canyengue. Ahora quiero explicar cuáles son las ideas que tengo atrás de esto.
En primer lugar, yo creo que hay algo de cierto en la hipótesis de Sapir-Whorf, y creo que las cosas que podemos concebir están fuertemente limitadas por las cosas que podemos expresar en los lenguajes que manejamos. También creo que la notación musical es muestra de ello y hace que la música sea mucho más rica, inclusive cuando no se la usa directamente. Hace más de 10 años que estoy incluído en el mundo del tango y noto que no hay acuerdo sobre cómo nombrar las cosas que hacemos cuando bailamos. Esta fragmentación hace que no podamos compartir conocimientos eficientemente y, por lo tanto, no evolucionemos. Esto se nota particularmente cuando tomamos clases. Todo hay que mostrarlo y aprenderlo kineticamente. Las clases avanzadas solo tienen secuencias más largas pero, por no existir los elementos del lenguaje que lo permitan, no avanzan en otros aspectos del baile que quedan relegados a lo que la intuición de cada quién pueda hacer. El primer objetivo de la notación es dar un lenguaje que permita destrabar esto.
En segundo lugar, una notación sensata debería habilitar otras cosas. Si hubiera una notación buena y completa, sería posible hacer algo equivalente a un MIDI player de tango. Y mostrar animaciones de baile en 3D y con robots.
Una tercera cosa que se me ocurre es un sistema de reconocimiento de video en 3D que corrija los pasos de tango, como si fuera un@ profesor@ human@.
Happy hacking,
Aureliano.

2014-07-04

Complicando la notación de tango

Hace unos días propuse una notación de pasos de tango, que consiste en una partitura en clave de 2 en tercera línea y asignar notas a los cambios de peso que hacen los bailarines. Hoy voy a extender la notación, para anotar dirección de los pasos. Como necesito más notas, voy a desdoblar los pasos conductor y conducido, cada uno en su partitura como las partituras para piano. Respetando como anoté antes, arriba van los pasos del conductor y abajo los del conducido, y arriba van los cambios de peso con la pierna izquierda y abajo los cambios de peso con la pierna derecha. Esto, si se mantienen las costumbres heteronormativas de baile, le da la clave de sol al hombre y la clave de fa a la mujer; al revés de lo que pasa cuando se escriben partituras para el canto.
La línea central de cada pentagrama nunca se usa. El espacio inmediatamente arriba o abajo es un cambio de peso en el lugar, la siguiente línea representa un cambio de peso desplazándose hacia atrás, el espacio siguiente un cambio de peso hacia adelante y la línea de afuera es una apertura.
El pentagrama representa un balanceo en el lugar, pisando primero con la derecha, después 2 pasos para atrás, dos pasos para adelante y una apertura para cada lado. ¿Se animan a hacer esto manteniendo cerrado el abrazo?

Siguiendo la tradición del post anterior, voy a poner en esta notación extendida el básico. Noten que sigo sin mostrar el cruce de la mujer en el paso 5.
Y acá está en esta notación el básico cruzado con contratiempo. También se nota que toma un compás menos.

En otros posts espero seguir desarrollando la notación del baile del tango.

Me voy a ver el mundial,
Aureliano.

2014-07-02

Post 256

Cuando empecé con este blog en agosto del 2006, nunca pensé que iba a escribir tantas cosas ni que iba a mantener la constancia de escribir acá por tanto tiempo. Mirando estos casi 8 años en retrospectiva, muchas cosas cambiaron, pero sigo disfrutando escribir por acá.Escribir cosas acá también me trajo algunas satisfacciones inesperadas. La más grosa creo que fue reencontrarme con mis compañer@s de la escuela primaria, ¡que encontraron este blog googleandome!
Desde que empecé a chequear tráfico en Google Analytics hubo 39,672 sesiones, con una mediana de aproximadamente 500 por mes y un pico en febrero de 2010 de 1855. Es un número extraño. Es muchísimo para ser muy poco y muy poco para ser muchísimo.
Una de las cosas que más me gusta de mirar las estadísticas del blog es mirar de dónde se conectan. Por supuesto que mi principal audiencia está en Argentina (más del 40% de las sesiones). Pero a veces aparece gente de lugares extraños como Corea, Mozambique o Nueva Caledonia. ¡Tengo visitas desde todos los continentes salvo Antártida!
Otra cosa que me gusta de este blog es que si quiero hacer una publicación, lo ve mucha más gente que si publicara en una revista especializada o los proceedings de una conferencia.
En definitiva, estoy muy contento de haber tenido la constancia de haber llegado hasta acá y ¡ojalá nos leamos en el post 65536!
Happy hacking,
Aureliano.

2014-06-30

Pensando una notación para el tango

La música tiene una forma de anotarse, con partituras, que hace más fácil pensar sobre ella, aprender y autocorregirse. Lamentablemente no conozco nada parecido para el mundo del tango, aunque en la danza en general algo existe.
Hace años que vengo pensando en cómo hacer para tener las ventajas de una partitura. Mi idea es tratar de adaptar las partituras para anotar pasos. Hacer esto tiene como ventaja que una parte del esfuerzo de notación, la rítmica, ya viene resuelto.
Lo que propongo es anotar los pasos armando una clave de do en tercera línea. La mitad de arriba del pentagrama representa los pies del conductor y la mitad de abajo los pies del conducido. En particular, fa es el pie izquierdo del conductor, re es el pie derecho del conductor, si es el pie izquierdo del conducido y sol el pie derecho del conducido. Para acordarse, imagen una pareja tomada por el lado cerrado del abrazo de tango, pero un al lado del otro, caminando por los espacios que quedan entre las líneas del pentagrama.
Si alguna de esas notas está presente, quiere decir que ese pie tiene peso en el piso durante el tiempo de la nota.
Por ejemplo, así se representa la pareja parada sobre ambos pies durante un compás (en un tango en 2x4):

Teniendo esto, podemos empezar a anotar cosas como el básico. Solo están los cambios de peso, no hay cambios de dirección ni el cruce del conducido en el paso 5:
O el básico con base cruzada. Noten como se toma un compás menos por los contratiempos en los compases 2 y 4.
En futuros posts voy a ir desarrollando la notación, siguiendo otros movimientos comunes en el tango salón. Mientras tanto espero ideas y críticas constructivas.

Nos vemos en la milonga y happy hacking,
Aureliano.

2014-06-19

TDA en VLC

Como puse en este post, me compré una sintonizadora de tele digital (TDA). El programa que viene con la placa para ver la tele es una bosta. Así que me las arreglé para mirar usando VLC, basándome en esto. Para hacerles la vida fácil, armé el archivo que hace falta. Bájenselo y ábranlo con el VLC.

Feliz mundial,
Aureliano.

2014-06-12

Lockeando LXDE

Recién me instalé un LXDE para usarlo como manejador de ventanas en un Ubuntu 14.04, y una de las cosas que le faltaba es la posibilidad de lockear la terminal con una combinación de teclas. Googleando un toque encontré esta pregunta donde explican como hacerlo para Lubuntu, así que básandome en eso inferí cómo hacer lo mismo en LXDE y parece que le pegué. Lo dejo acá por si me olvido o alguien necesita hacerlo.
Para hacer que la combinación de teclas lockee el desktop, hay que editar el archivo .config/openbox/lxde-rc.xml y agregarle, dentro del tag keyboard, lo siguiente:

  <keybind key="W-l">
     <action name="Execute">
       <command>xscreensaver-command -lock</command>
     </action>
  </keybind>



Una vez esto hecho, te deslogueás y relogueas y listo el pollo.
Happy hacking,
Aureliano

2014-06-10

Conectandome a mi VM nateada

Para laburar, me gusta tener los ambientes de los proyectos en los que laburo separados en VMs. Eso hace que pueda desarrollar simultáneamente proyectos con requerimientos incompatibles (un caso clásico es ver una versión vieja del mismo proyecto). Setupear todo suele no ser fácil. En particular, manejar el networking entre host y guest puede ser complicado. Por default, en VirtualBox, no es posible conectarse por tcp al guest si el mismo tiene la red configurada como NAT.
Después de googlear un rato, descubrí como hacer para poner reglas del tipo "el puerto 2222 del host es el 22 de mi_vm, y solo es accesible desde el host". Es así:

$ VBoxManage modifyvm "mi_vm" --natpf1 "ssh,tcp,127.0.0.1,2222,,22"

Si quisieran sacar la regla hay que hacer:

$ VBoxManage modifyvm "mi_vm" --natpf1 delete "ssh"

Si quieren ver que reglas de forwarding tiene su VM, pueden hacer:

$ VBoxManage showvminfo "mi_vm" | grep NIC

Para más detalles pueden mirar en la sección 6.3.1 del manual de VirtualBox.

Happy hacking!

2014-06-08

Agua destilada

Hola a todos,

Estoy feliz de anunciarles que está en YouTube la edición en calidad HD del corto que filmamos con varios amigos durante 2012 y 2013, y que me tiene como protagonista. Acá les dejo el link:
http://youtu.be/pAUmaNOTJs0.

Y si quieren verlo directamente, también una ventanita:

Espero que les guste!

2014-06-01

cgoban y java 1.7

Si tratan de correr cgoban con Java Web Start, como dice en gokgs.com, puede ser que les de un error en la firma del jnlp (como a mi). Para workaroundear el problema, lo que yo hice es bajarme el .jar de http://files.gokgs.com/javaBin/cgoban.jar y correrlo localmente.

Espero que les sirva, y si quieren jugarse una partidita de go conmigo pueden buscarme en Dragon Go Server, mi usuario es aurelianito y, al momento de escribir este post, soy 11k.

2014-05-31

Drivers para PlayTV USB SBTVD en Windows 7 64 bits

Ayer me compré un sintonizador para la televisión digital abierta (TDA). El modelo exacto es PV-231U(RN)-F. Y el CD con el que vino tiene los drivers para Windows 7 pero no te da la opción de instalarlos :-/.

Así que tuve que instalarlos a mano. Lo que encontré es como hacerlo desde la línea de comando. Corriendo cmd como "Administrador", fui al directorio donde están los drivers (e:\driver\vista64) y corrí pnputil -a *.inf. Le dije que sí a los 2 drivers (tienen problemas en las firmas :-/) y ahora puedo ver los partidos del mundial en la compu :).

Espero que les haya servido,
Aureliano.

2014-05-27

Scl, gnu-screen, flask y python 2.7

Update (2014-05-28): Quiero aclarar que si sólo instalo python y screen me muestra la versión de python 2.7 en el shell corriendo adentro del screen.

Arranco en AWS desde 0 con un AMI de un RHEL 6.5, RHEL-6.5_GA-x86_64-7-Hourly2 (ami-aa8bfe9a). Instalo python 2.7, screen, pip y flask usando pip.

$ sudo yum -y install python27
$ sudo yum -y install screen
$ sudo scl enable python27 "easy_install pip"
$ sudo scl enable python27 "pip install flask"

Activo un shell con python27 y corro python

$ scl enable python27 bash
$ python --version
Python 2.7.5

Y veo que configuró la carga de bibliotecas para cargar las libs de python 2.7.

$ echo $LD_LIBRARY_PATH

/opt/rh/python27/root/usr/lib64


Pero, si hago lo mismo en un screen:

$ scl enable python27 bash
$ python --version

python: error while loading shared libraries: libpython2.7.so.1.0: cannot open shared object file: No such file or directory

Y no tiene configurada la carga de bibliotecas para cargar las libs de python 2.7.

$ echo $LD_LIBRARY_PATH


(no aparece nada :-( )

¿Alguien sabe que está pasando? ¿Qué hice mal?

Happy hacking, 
Aureliano.

2014-04-28

Bindings extraños en python

El comportamiento de locals() en python es extraño. ¿Por qué no me muestra siempre todas las variables por las que clausura? (pero sí muestra algunas :-/). ¿Como hago para obtenerlas todas?

Abajo pongo el POC que muestra que no anda como quiero:

>>> def foo():
...   a = 1
...   def bar():
...     print locals()
...   bar()
... 
>>> foo()
{}

Como ven, no muestra a como posible variable.

En cambio, en este ejemplo, que debería tener el mismo comportamiento, sí muestra a como variable.

>>> def foo():
...   a = 1
...   def bar():
...     a
...     print locals()
...   bar()
... 
>>> foo()
{'a': 1}


¿Cómo hago para armar el diccionario de las variables que se pueden usar en una función en python?

Todo esto lo probé en una consola corriendo python 2.7.6.

Happy hacking,
Aureliano.

2014-04-15

Recuperando mi mongo en debian

Update: La máquina en la que hice esto es un debian. De todas maneras en ubuntu seguramente es muy parecido.

Chequeo el estado de mi server mongo en mi debian y me dice:
$ sudo service mongodb status
[FAIL] Checking status of database: mongodb apparently not running failed!


Entonces miro en /var/log/mongodb/mongodb.log y encuentro esta línea:
Unclean shutdown detected.
Please visit http://dochub.mongodb.org/core/repair for recovery instructions.

¿Hago lo que dice ahí de una? No. Porque el mongo en ubuntu corre con un usuario específico. Mejor hago
$ sudo -u mongodb mongod -f /etc/mongodb.conf  --repair

Espero un rato, y termina de correr el script. Después hago:

$ sudo service mongodb start
[ ok ] Starting database: mongodb.

Happy hacking,
Aureliano.

2014-04-11

Pipeando procesos en python

A veces uno quiere correr varios procesos en python y enchufar el standard output de un proceso con el stdin del siguiente. Esto sería equivalente a hacer en el shell:
$ prog1 param1 | prog2 param21 param22 | prog3

Para poder hacer algo así en python hice este método:
import subprocess
def pipe(*args):
    last_proc = None
    for command in args:
        in_file = last_proc.stdout if last_proc else tempfile.TemporaryFile()
        proc = subprocess.Popen(command, stdin=in_file, stdout=subprocess.PIPE)
        if last_proc:
            last_proc.stdout.close()
        last_proc = proc
        

    last_proc.communicate()

Para hacer lo mismo que el comando de arriba hay que hacer:
pipe(
  ("prog1", "param1"),
  ("prog2", "param21", "param22"),
  ("prog3",)
)

La única limitación es que no puedo procesar la salida de standard output del último proceso. 

Happy hacking,
Aureliano.

2014-04-08

scl y screen

En RedHat existe un mecanismo para tener en el mismo host diferentes versiones del mismo software que se activa corriendo desde línea de comando. Por ejemplo, para activar python27 (en vez del 2.7, default de la distro) hay que correr scl enable python27 bash.

El problema es que si después corrés screen, ese seteo no pasa en forma limpia al shell que corre adentro del screen. Por lo tanto, lo que hay que hacer es hacer el enable "adentro" del screen. Por ejemplo, para correr un bash en screen con soporte para python 2.7 hay que correr screen scl enable python27 bash

La idea de cómo hacer esto la saqué de la documentación de CentOS. Busquen "coreutils component" dentro de la página para ver el detalle.

Happy hacking,
Aureliano.

Hacer un pem con clave a partir de uno sin clave

Tengo un .pem sin clave que me sirve para acceder a un server y me parece demasiado inseguro. Entonces corro:

openssl rsa -des -in orig.pem -out con-clave.pem 

Me pide la clave y en con-clave.pem tengo el .pem con clave, así que puedo borrar el otro (pero lo pruebo antes por las dudas).

Happy hacking,
Aureliano

2014-04-07

Nombres para sandro

Estoy pensando los nombres para los subcomponentes de sandro. Voy a seguir la línea del primer intento y usar nombres de canciones de Sandro (compuestas o interpretadas por él) para nombrarlos.
Acá les tiro mis ideas:

  • rosa: sistema de templating.
  • tengo: persistencia.
  • ya: sistema de caché.
  • asi: unit-testing framework.
  • penumbras: el sistema de base. Carga módulos, integra con la JVM.
  • maniqui: mock objects.
  • ave_de_paso: lib de promises.
  • camino: routing (la canción es "Por algún camino").
  • nada_mas: colección de helpers.
Voy a ir agregando cosas a la lista a medida que se me ocurran o me las sugieran.

Espero sus sugerencias, 
Aureliano.

2014-03-30

sandro reboot

Hace ya casi 4 años empecé un proyecto para hacer más fácil hacer páginas web seguras al que llamé sandro. Ahora estoy empezando el mismo proyecto de nuevo, siguiendo con mismas ideas rectoras:

  • Un solo lenguaje en todos lados, JavaScript.
  • Templating client-side y server side compartiendo código.
  • Validación de datos en el cliente y server compartiendo código.
  • Seguro por defecto. El diseño del framework debería hacer que sea más fácil hacer aplicaciones seguras que inseguras.
La primera versión va a estar basada en rhino, igual que la vez anterior, pero va a haber algunos cambios que creo que son importantes:
  • No va a estar enfocado a correr en app-engine.
  • Para mantener la idea de que haya JavaScript en todos lados, el motor de base de datos elegido va a ser mongodb.
  • Para reconciliarme con la naturaleza asíncrona y mono-thread del browser, voy a cambiar el manejo de módulos de commonjs por requirejs en el cliente y una API compatible con requirejs en el server.
Si quieren ir viendo el avance del proyecto, está en un proyecto público de bitbucket.

Espero feedback y, sobre todo, pull requests.

Happy hacking,
Aureliano.

2014-03-16

Cabeceo, técnica y táctica

En muchas milongas es de mala educación acercarse directamente a una persona y preguntarle si quiere bailar. Yo entiendo que es porque si no quiere, la forzás a elegir entre 2 opciones que son una cagada. La primera es bailar con vos de todas maneras y la segunda es exponerlos a ambos a que quede claro que no quiso bailar con vos.
Para evitar esto, existe un procedimiento que se llama cabeceo y es así (en su forma heteronormativa):

  1. Hombre y mujer establecen contacto visual.
  2. El hombre, sin romper el contacto visual, inclina su cabeza levemente hacia la pista.
  3. La mujer, sin romper el contacto visual, asiente con la cabeza.
  4. El hombre, sin romper el contacto visual, se acerca a donde la mujer esté sentada.
  5. Ambos van juntos hacia la pista.
Aunque parezca bastante machista, en realidad no lo es. El secreto está en el contacto visual. Si alguno de los 2 no quiere bailar con el otro, todo lo que tiene que hacer es romper el contacto visual. Así la otra parte sabrá que no quiere bailar y evita el escarnio público del rechazo (el rechazo en sí me parece que es inevitable).
Ahora la táctica. Si sos mujer y querés bailar, lo que tenés que hacer es:
  1. Estar bien sentada, tu postura corporal es lo que nos dice si querés bailar o no.
  2. Prestá atención a los bailarines con los que querés bailar, y tratá de establecer contacto visual con ellos. Si estás hablando con la chica que está sentada al lado tuyo, sin prestar atención a tu alrededor, es mucho más difícil invitarte a bailar. Esto es especialmente importante durante el primer tango de la tanda. 
Si sos hombre, 
  1. Tenés que hacer que te vean. Para eso en muchas milongas es normal circular por el pasillo (o borde de la pista)
  2. Salvo que tenga mucha confianza con la bailarina, o estés en una milonga que el cabeceo no se use, no invites a bailar a alguien sin seguir el procedimiento de arriba.
El procedimiento de arriba sirve para evitar malos entendidos. Si 2 bailarines invitan a la misma bailarina. La bailarina va a mantener contacto visual con el que haya elegido, y el otro podrá retirarse sin que nadie se de cuenta lo que pasó. Lo mismo si 2 bailarinas piensan que las invitó el mismo bailarín.

Nos vemos en las milongas,
Aureliano.

2014-03-14

Selección de los hijos

En este post no estoy proponiendo al hijo del Kun para la selección de fútbol sino que quiero mostrar una solución a un problema puntual en d3. Hace un tiempito postié cómo hacer para hacer un selector de CSS que busque solo en los hijos de un nodo. El objetivo era hacer más robustas las selecciones de nodos en los gráficos que hago con d3. Lamentablemente ese truco no anda con un montón de browsers, pero encontré otro mucho más simple. Si queremos una selección con todos los nodos hijos de la selección actual, lo más fácil es hacer:

my_selection.selectAll(function() { return this.childNodes })

Al final era bastante fácil. No entiendo porqué esto no está en ningún lado. Casi siempre cuando uso selectAll quiero obtener los hijos de los nodos de la selección actual.

Happy hacking,
Aureliano.

2014-03-10

Como esto pero distinto, no en CSS

Quiero poder decir, esta clase es como tal otra, pero el font es de tamaño x; y no puedo.

Acá está el detalle: http://stackoverflow.com/questions/1065435/can-a-css-class-inherit-one-or-more-other-classes.

Otro motivo más que muestra porqué habría que tener un lenguaje de programación y una lib estándar en vez del hack horrible de CSS.

Happy hacking,
Aureliano.

2014-02-20

Word wrap en SVG

El elemento text de svg no tiene forma de decirle que corte el texto en líneas respetando un ancho, ni como cambiar el font de una parte del texto, etc. Por suerte existe otro elemento que se llama foreignobject y sirve, entre otras cosas para embeber html. Y obvio que el html embebido puede hacer word wrap (como siempre en html). Cuando pueda lo voy a probar bien, por ahora pueden ver en este artículo como usarlo.

Happy hacking,
Aureliano

2014-02-13

CSS selector, hijo de un nodo

Update: Lo probé en Firefox 24 y no anda. La funcionalidad está implementada pero no está habilitado en la configuración por defecto (https://developer.mozilla.org/en-US/docs/Web/CSS/:scope).

En un montón de bibliotecas para el browser, como d3 o jquery podemos usar selectores de CSS para elegir nodos que son descendientes de un conjunto de nodos dado. Esta funcionalidad, casi siempre está basada en el método elem.querySelectorAll(css_selector). Hoy descubrí algo muy interesante de este método. Hay una pseudo-clase de css que se llama :scope y cuando es usada en el selector del método de arriba refiere al elem sobre el que se hizo la consulta.
Ésta pseudo-clase, la podemos usar para elegir a los hijos de un elemento que cumplan cierta condición. Por ejemplo, elem.querySelectorAll(":scope > .klass") busca todos los elementos hijos (y solo hijos, no nietos) de elem que tienen klass como clase.
Como las bibliotecas que mencioné al principio usan esto en sus entrañas, también se puede usar en las mismas cuando buscás nodos. Por ejemplo, en d3 sería algo así: my_selection.selectAll(":scope > g").
Happy hacking,
Aureliano.
PD: La información original sobre cómo hacer esto la saqué de acá.
PD2: Lo probé con d3 en mi Chrome y anda. La documentación de Firefox también dice que anda, pero no lo probé. El resto de los browsers son un misterio para mi. Si lo prueban en otros contextos, avisen.

2013-12-31

Ema Ortuzar

Si entran a http://www.smn.gov.ar/dpd/tiepre/mercobras/mb3uv.htm pueden la información meteorológica de la estación automática de observación que tiene el servicio meteorológico en la Ciudad de Buenos Aires.

2013-11-29

Delicias del JavaScript

>> 1 == "1"
true
>> 1 === "1"
false

Conclusión, no usar == nunca más

2013-11-27

His road to go

Mi amigo frandibar estrena su blog sobre sus experiencias jugando al go. ¡En una de esas hasta vean partidas mías por ahí!

Éxitos Fran!!!!!

2013-11-22

D3 tips and tricks

Hace un tiempito que descubrí una fabulosa biblioteca que sirve para hacer visualizaciones y muchas más cosas, que se llama d3. Les recomiendo fuertemente que si quieren hacer cosas para browsers modernos le den una ojeada. Y buscando ejemplos y documentación sobre la misma encontré un libro on-line que me gustó, llamado D3 tips and tricks. En particular, me llamó la atención lo grosas que quedan las tablas cuando las hacés usando d3.


Happy hacking,
Aureliano.

2013-10-28

Fracciones de Peano

Las últimas 2 semanas estuve haciendo en el laburo el curso de diseño orientado a objetos que da Hernán Wilkinson de 10 Pines. Dentro del curso, hay un ejercicio para hacer single dispatch que consiste en modelar números enteros y fracciones.
Como usar los números que me da el lenguaje para modelar los números me pareció choto, hice una implementación de los números de Peano y con eso hice las fracciones.

Abajo les dejo la primera versión que pasa los tests, pero que es media fea porque tiene ifs de la forma if isinstance(sumando, Enteros): #código. Si miran al final, van a ver los tests de unidad que tiene que pasar el código. Antes está la implementación.


import unittest

class Numero:

    DESCRIPCION_DE_ERROR_DE_DIVISION_POR_CERO = 'No se puede dividir por 0'
   
    def esCero(self):
        self.shouldBeImplementedBySubclass()
   
    def esUno(self):
        self.shouldBeImplementedBySubclass()
   
    def __add__(self,sumando):
        self.shouldBeImplementedBySubclass()
   
    def __mul__(self,factor):
        self.shouldBeImplementedBySubclass()
   
    def __div__(self,divisor):
        self.shouldBeImplementedBySubclass()
   
    def shouldBeImplementedBySubclass(self):
        raise NotImplementedError('Should be implemented by the subclass')
   
    def __le__(self, other):
        return self < other or self == other

class Entero(Numero):
    pass

class Zero(Entero):
   
    def esCero(self): return True
   
    def esUno(self): return False
   
    def __eq__(self, other):
        return self.__class__ == other.__class__
   
    def __add__(self,sumando):
        return sumando
   
    def __mul__(self, factor):
        return self
   
    def __repr__(self): return "0"
   
    def __lt__(self, other): return not self == other

class Next(Entero):

    def __init__(self, before):
        self.before = before
   
    def esCero(self): return False
   
    def esUno(self): return self.before.esCero()
   
    def __add__(self,sumando):
   
        if isinstance(sumando, Entero):
            return Next(self.before + sumando)
       
        return sumando + self
   
    def __mul__(self, factor):
   
        return factor + self.before * factor
   
    def __repr__(self): return "N" + repr(self.before)
   
    def __eq__(self, other):
   
        if isinstance(other, Fraccion):
            return other == self
   
        if self.__class__ != other.__class__: return False

        return self.before == other.before
   
    def __lt__(self, other):
   
        if self.__class__ != other.__class__: return False
        return self.before < other.before
   
    def __div__(self, other):
   
        if isinstance(other, self.__class__):
            return Fraccion(self, other)
   
        if isinstance(other, Fraccion):
            return Fraccion(other.d * self, other.n)
   
        raise Exception("No se puede dividir por %r" % other)

class Fraccion(Numero):

    def __init__(self, n, d):
        if (d.esCero()):
            raise Exception(Numero.DESCRIPCION_DE_ERROR_DE_DIVISION_POR_CERO)
           
        self.n = n
        self.d = d

    def __add__(self, other):

        #a/b + c/d = (a.d + c.b) / (b.d)
   
        if isinstance(other, self.__class__):
            return Fraccion((self.n * other.d + other.n * self.d), self.d * other.d)
       
        if isinstance(other, Entero):
            return Fraccion(self.n + other * self.d, self.d)
       
        raise Exception("No se sumar %r" % other)

    def __mul__(self, other):

        # (a/b) * (c/d) = (a.c) / (b.d)
        if isinstance(other, self.__class__):
            return Fraccion(self.n * other.n, self.d * other.d)
       
        if isinstance(other, Entero):
            return Fraccion(self.n * other, self.d)

    def __div__(self, other):
   
        # (a/b) / (c/d) = (a.d) / (b.c)
       
        if isinstance(other, self.__class__):
            return Fraccion(self.n * other.d, other.n * self.d)
       
        if isinstance(other, Entero):
            return Fraccion(self.n, self.d * other)
       
        raise Exception("No se dividir %r" % other)

    def __eq__(self, other):
   
        if isinstance(other, self.__class__):
            return self.n * other.d == self.d * other.n
       
        if isinstance(other, Entero):
            return self.n == self.d * other
       
        return False

    def __repr__(self): return repr(self.n) + "/" + repr(self.d)

class NumeroTest(unittest.TestCase):

    def createCero(self):
        return Zero()
   
    def createUno(self):
        return Next(self.createCero())
   
    def createDos(self):
        return Next(self.createUno())
   
    def createTres(self):
        return Next(self.createDos())
   
    def createCuatro(self):
        return Next(self.createTres())
   
    def createCinco(self):
        return Next(self.createCuatro())
   
    def createSeis(self):
        return Next(self.createCinco())
   
    def createSiete(self):
        return Next(self.createSeis())
   
    def createUnQuinto(self):
        return Fraccion(self.uno, self.cinco)
   
    def createDosQuintos(self):
        return Fraccion(self.dos, self.cinco)
   
    def createDosVeinticincoavos(self):
        return Fraccion(self.dos, self.cinco * self.cinco)
   
    def createUnMedio(self):
        return Fraccion(self.uno, self.dos)
   
    def createCincoMedios(self):
        return Fraccion(self.cinco, self.dos)
   
    def createSeisQuintos(self):
        return Fraccion(self.seis, self.cinco)
   
    def createCuatroMedios(self):
        return Fraccion(self.cuatro, self.dos)
   
    def createDosCuartos(self):
        return Fraccion(self.dos, self.cuatro)
   
    def setUp(self):
   
        self.cero = self.createCero()
        self.uno = self.createUno()
        self.dos = self.createDos()
        self.tres = self.createTres()
        self.cuatro = self.createCuatro()
        self.cinco = self.createCinco()
        self.seis = self.createSeis()
        self.siete = self.createSiete()
       
        self.unQuinto = self.createUnQuinto()
        self.dosQuintos = self.createDosQuintos()
        self.dosVeinticincoavos = self.createDosVeinticincoavos()
       
        self.unMedio = self.createUnMedio()
        self.cincoMedios = self.createCincoMedios()
        self.seisQuintos = self.createSeisQuintos()
        self.cuatroMedios = self.createCuatroMedios()
        self.dosCuartos = self.createDosCuartos()
   
    def testAEsCeroDevuelveTrueSoloParaElCero(self):
   
        self.assertTrue (self.cero.esCero())
        self.assertFalse (self.uno.esCero())
   
    def testBEsUnoDevuelveTrueSoloParaElUno(self):
   
        self.assertTrue (self.uno.esUno())
        self.assertFalse (self.cero.esUno())
   
    def testCSumaDeEnteros(self):
   
        self.assertEqual (self.dos,self.uno+self.uno)
   
    def testDMultiplicacionDeEnteros(self):
   
        self.assertEqual(self.cuatro, self.dos*self.dos)
       
    def testEDivisionDeEnteros(self):
   
        self.assertEqual(self.uno, self.dos/self.dos)
   
    def testFSumaDeFracciones(self):
   
        sieteDecimos = Fraccion( self.siete, self.dos * self.cinco ) # <- br="" corresponda="" lo="" por="" que="" reemplazar="">       
        self.assertEqual (sieteDecimos,self.unQuinto+self.unMedio)
       
        #
        # La suma de fracciones es:
        #
        # a/b + c/d = (a.d + c.b) / (b.d)
        #
        # SI ESTAN PENSANDO EN LA REDUCCION DE FRACCIONES NO SE PREOCUPEN!
        # NO SE ESTA TESTEANDO ESE CASO
        #
   
    def testGMultiplicacionDeFracciones(self):
   
        self.assertEqual (self.dosVeinticincoavos,self.unQuinto*self.dosQuintos)
       
        #
        # La multiplicacion de fracciones es:
        #
        # (a/b) * (c/d) = (a.c) / (b.d)
        #
        # SI ESTAN PENSANDO EN LA REDUCCION DE FRACCIONES NO SE PREOCUPEN!
        # TODAVIA NO SE ESTA TESTEANDO ESE CASO
        #
   
    def testHDivisionDeFracciones(self):
   
        self.assertEqual (self.cincoMedios,self.unMedio/self.unQuinto)
       
        #
        # La division de fracciones es:
        #
        # (a/b) / (c/d) = (a.d) / (b.c)
        #
        # SI ESTAN PENSANDO EN LA REDUCCION DE FRACCIONES NO SE PREOCUPEN!
        # TODAVIA NO SE ESTA TESTEANDO ESE CASO
        #
        #
   
    # Ahora empieza lo lindo! - Primero hacemos que se puedan sumar enteros con fracciones
    # y fracciones con enteros
    #
    def testISumaDeEnteroYFraccion(self):
   
        self.assertEqual (self.seisQuintos,self.uno+self.unQuinto)
   
    def testJSumaDeFraccionYEntero(self):
   
        self.assertEqual (self.seisQuintos,self.unQuinto+self.uno)
   
    #
    # Hacemos lo mismo para la multipliacion
    #
    def testKMultiplicacionDeEnteroPorFraccion(self):
   
        self.assertEqual(self.dosQuintos,self.dos*self.unQuinto)
   
    def testLMultiplicacionDeFraccionPorEntero(self):
   
        self.assertEqual(self.dosQuintos,self.unQuinto*self.dos)
   
    #
    # Hacemos lo mismo para la division
    #
   
    def testMDivisionDeEnteroPorFraccion(self):
   
        self.assertEqual(self.cincoMedios,self.uno/self.dosQuintos)
   
    def testNDivisionDeFraccionPorEntero(self):
   
        self.assertEqual(self.dosVeinticincoavos,self.dosQuintos/self.cinco)
   
    #
    # Ahora si empezamos con problemas de reduccion de fracciones
    #
   
    def testOUnaFraccionPuedeSerIgualAUnEntero(self):
   
        self.assertEquals(self.dos,self.cuatroMedios)
   
    def testPLasFraccionesAparentesSonIguales(self):
   
        self.assertEquals(self.unMedio,self.dosCuartos)
   
    #
    # Las fracciones se reducen utilizando el maximo comun divisor (mcd)
    # Por lo tanto, para a/b, sea c = mcd (a,b) => a/b reducida es:
    # (a/c) / (b/c).
    #
    # Por ejemplo: a/b = 2/4 entonces c = 2. Por lo tanto 2/4 reducida es:
    # (2/2) / (4/2) = 1/2
    #
    # Para obtener el mcd pueden usar el algoritmo de Euclides que es:
    #
    # mcd (a,b) =
    # si b = 0 --> a
    # si b != 0 -->mcd(b, restoDeDividir(a,b))
    #
   
    # Ejemplo:
    # mcd(2,4) ->
    # mcd(4,restoDeDividir(2,4)) ->
    # mcd(4,2) ->
    # mcd(2,restoDeDividir(4,2)) ->
    # mcd(2,0) ->
    # 2
    #
   
    def testQLaSumaDeFraccionesPuedeDarEntero(self):
   
        self.assertEquals (self.uno,self.unMedio+self.unMedio)
   
    def testRLaMultiplicacionDeFraccionesPuedeDarEntero(self):
   
        self.assertEquals(self.dos,self.cuatro*self.unMedio)
   
    def testSLaDivisionDeEnterosPuedeDarFraccion(self):
   
        self.assertEquals(self.unMedio, self.dos/self.cuatro)
   
    def testTLaDivisionDeFraccionesPuedeDarEntero(self):
   
        self.assertEquals(self.uno, self.unMedio/self.unMedio)
   
    def testUNoSePuedeDividirEnteroPorCero(self):
   
        try:
            self.uno/self.cero
            self.fail()
        except Exception as e:
            self.assertEquals(self.descripcionDeErrorDeNoSePuedeDividirPorCero(),e.message)
   
    def testVNoSePuedeDividirFraccionPorCero(self):
   
        try:
            self.unQuinto/self.cero
            self.fail()
        except Exception as e:
            self.assertEquals(self.descripcionDeErrorDeNoSePuedeDividirPorCero(),e.message)
       
    # Este test puede ser redundante dependiendo de la implementacion realizada
   
    def testWNoSePuedeCrearFraccionConDenominadorCero(self):
   
        try:
            self.crearFraccionCon(self.uno,self.cero)
            self.fail()
        except Exception as e:
            self.assertEquals(self.descripcionDeErrorDeNoSePuedeDividirPorCero(),e.message)
   
    def crearFraccionCon(self, numerador, denominador):
   
        return Fraccion(numerador, denominador)
   
    def descripcionDeErrorDeNoSePuedeDividirPorCero(self):
   
        return Numero.DESCRIPCION_DE_ERROR_DE_DIVISION_POR_CERO


En futuros posts voy a ir factorizando este código para que quede más lindo.

Happy hacking,
Aureliano.

2013-09-16

Instalando python 2.5

Estuve colaborando en impacket y agregué paquetes para parsear EAP y WPS. Como impacket anda a partir de python 2.5, me instalé un python 2.5 en un Linux Mint para ver que no rompí nada. Instalar un python 2.5 con soporte para crypto es difícil. Abajo les dejo las instrucciones:

Bajar tarballs de:

  • python 2.5 (link)
  • sqlite3 (tarball con autoconf) (link)
  • openssl (link)
  • libsasl2 (link)
  • pycrypto (link)
Una vez que tengan todo eso hay que compilar. Yo decidí hacerlo en un lugar separado ($HOME/p25) para no mezclar las cosas con el resto de mi instalación.

Hay que destarear todo e instalarlo. Para eso, hacé esto (el orden de las instalaciones es importante):

sqlite3:
$ ./configure --prefix=$HOME/p25
$ make
$ make install

openssl:
$ ./config --prefix=$HOME/p25 -shared
$ make
$ make install

libsasl2:
$ ./configure --prefix=$HOME/p25
$ make
$ make install

python:
$ ./configure --prefix=$HOME/p25
$ make
$ make install

pycrypto:
$ PATH=$HOME/p25/bin:$PATH
$ python setup.py build
$ python setup.py install

Y con eso tengo un python 25 en $HOME/p25/bin que puede correr los tests de impacket.

Espero que les sirva,
Aureliano.

2013-08-18

Homeopatía, animales y efecto placebo

El viernes pasado, mientras estábamos almorzando en el trabajo, tuvimos una charla re interesante sobre la homeopatía. Yo afirmé que la homeopatía es puro efecto placebo y un compañero de laburo me dijo que eso era mentira porque él trató a su perro con un tratamiento homeopático. Después de eso yo dije que el efecto placebo seguramente también afecta a animales domésticos, pero ese argunmento no fue lo suficientemente fuerte. Después de eso, me dijo que "no todo lo puede explicar la ciencia" (sic).
Si quieren que yo refute algo, decirme algo así es un buen método. Entonces me puse a googlear y estuvo complicado, porque casi todos los papers de veterinaria están atrás de paywalls :(. Pero al final encontré un survey del año 1999 que se llama The placebo effect in animals pubicado en el "Journal of the American Veterinary Medical Association". También encontré este artículo, que cita varios papers (incluyendo al que mencioné antes).
Si los leen, van a ver que hay evidencia que hace pensar que es significativo el efecto placebo en perros. ¿Saben de alguna referencia mejor que apoye o refute la existencia del efecto placebo en animales?

2013-07-29

Bouncer aggiornado

Después de mucho tiempo volví a programar un toque en ruby. Por necesidades laborales, tuve que usar de nuevo mi bouncer.rb, pero lamentablemente "rdoc/usage" no está en ruby 1.9. Así que lo adapté para que no lo necesite más. Abajo pongo el código:

#!/usr/bin/env ruby

# == Synopsis
#
# redirect.rb: Redirects TCP connections to distant machines. Handles simultaneously many connections.
#
# == Usage
#
# ruby redirect.rb [OPTION]
#
# -h, --help:
#   Show help
#
# --ip ip, -i ip:
#   Accept connections from ip (default 127.0.0.1)
#
# --port port, -p port:
#   Listen on port (default 12345)
#
# --target ip:port, -t ip:port
#   Connect to ip:port (default 127.0.0.1:23456)
#

require 'getoptlong'
#require 'rdoc/usage'
require 'socket'

class Redirect
 def initialize( source_ip, listening_port, target_ip, target_port )
  @source_ip = source_ip
  @target_ip = target_ip
  @target_port = target_port

  @server_socket = TCPServer.new( "", listening_port )
    @server_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
   
  @descriptors = [ @server_socket ]
  @next_step = {}
 end

 def handle_new_connection
  incoming = @server_socket.accept
  if incoming.peeraddr[3] == @source_ip
   begin
    outgoing = TCPSocket.new( @target_ip, @target_port )
   
    @next_step[ incoming ] = outgoing
    @next_step[ outgoing ] = incoming

    @descriptors += [ incoming, outgoing ]
   rescue
    silent_close( incoming )
   end
  else
   silent_close( incoming )
  end
 end

 def silent_close( sock )
  begin
   sock.close
  rescue
   #do nothing intentionally
  end
 end

  def propagate(sock)
    next_sock = @next_step[sock]
    next_sock.write(sock.read_nonblock(1000 * 1000))
  end

 def finish_connection(sock)
  next_sock = @next_step[sock]
  [ sock, next_sock ].each do
   |s|
   silent_close(s)
   @descriptors.delete(s)
   @next_step.delete(s)
  end
 end

 def run
  loop do
   connections = select( @descriptors )
   connections[0].each do
    |sock|
    if sock == @server_socket then
     handle_new_connection
    else
     begin
      sock.eof? ? finish_connection(sock) : propagate(sock)
     rescue
      finish_connection(sock)
     end
    end
   end
  end
 end
end

if $0 == __FILE__ then

 opts = GetoptLong.new(
   [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
   [ '--ip', '-i', GetoptLong::REQUIRED_ARGUMENT ],
   [ '--port', '-p', GetoptLong::REQUIRED_ARGUMENT ],
   [ '--target', '-t', GetoptLong::REQUIRED_ARGUMENT ]
 )

 ip = '127.0.0.1'
 port = '12345'
 target = '127.0.0.1:23456'

 opts.each do
  |opt, arg|
  case opt
  when '--help'
   print """\
Usage:
ruby bouncer.rb [options]

options:
 -i [ip] --ip=[ip]
 -p [port] --port=[port]
 -t [host:port] --target=[host:port]
"""
   exit
  when '--ip'
   ip = arg
  when '--port'
   port = arg
  when '--target'
   target = arg
  end
 end

 port = port.to_i
 target = target.split(":")

 trap("SIGINT") do
   exit
 end

 Redirect.new(ip, port, target[0], target[1].to_i).run
end



Happy hacking,
Aureliano

2013-05-29

No entiendo porqué uno anda y el otro no

Quiero ejecutar cscope buscando recursivamente en un directorio los archivos que van a ser indexados, para eso hago:

$ find . -type f -and \( -name "*.c" -or -name "*.h" \) | xargs cscope

y abre el cscope una décima de segundo y se cierra

pero si hago

$ cscope `find . -type f -and \( -name "*.c" -or -name "*.h" \)`

anda bien.

¿Se les ocurre que puede ser?

2013-05-03

Debugueando en root con pydev

Update: Cambié el código para que standard output y standard error salgan en la consola del debugger.

Quiero poder debuguear cosas que estoy desarrollando y requieren root. Para eso, me hice un pequeño wrapper que sirve para ejecutar cualquier programa de python y se conecta a un pydevd server

#!/usr/bin/env bash
PYDEVD_LOCATION=/home/aure/Aptana_Studio_3/plugins/org.python.pydev_2.7.0.2013032300/pysrc
export PYTHONPATH=$PYDEVD_LOCATION:$PYTHONPATH
echo "Check the pydev debug console for output"
python $PYTHONARGS -c "import pydevd;pydevd.settrace(suspend=False,trace_only_current_thread=False,stdoutToServer=True,stderrToServer=True);import sys;sys.argv=sys.argv[1:];execfile(sys.argv[0])" $@


Para usarlo, copienlo en un archivo ejecutable que esté en el path y cambien PYDEVD_LOCATION para que apunte a dónde tienen pydev (en el script de arriba está como es en mi compu).

A partir de ahora puedo debuguear en root haciendo sudo pydevd my_script_que_corre_como_root.py y lo abre en el debugger de eclipse.

Happy hacking,
Aureliano.

2013-04-04

Invalid private key

Poner un certificado nuevo en un ELB debería ser fácil, pero no. Genero un .csr y una clave privada a partir de un .conf usando openssl, lo mando a la autoridad certificante y cuando lo quiero subir a AWS se queja, "Invalid private key".  ¿Qué carajo te pasa AWS?

Lo que pasa es que es hincha bolas. Solo toma claves RSA. Si tu clave privada empieza así:
-----BEGIN PRIVATE KEY-----

Hay que transformarla en una que empiece así:
-----BEGIN RSA PRIVATE KEY-----

Para eso, hay que correr un comandito en openssl:
openssl rsa -in my.private.key -text

La salida está en el formato que necesito :D. Por suerte esto ya lo habían descubierto antes, porque sino hubiera estado mucho más tiempo para encontrarlo.

Happy hacking,
Aureliano.

2013-03-29

Cambiando el MTU

Por algún motivo, mi conexión wifi está dropeando paquetes. No creo que sea el aparato, ya que probé con 2 distintos. Ahora voy a probar otra cosa. Lo que voy a hacer es cambiar el MTU (o sea el tamaño máximo de cada paquete) para la conexión wifi para ver si eso lo arregla.

Hacer eso en Windows 7 es re-oscuro. Googleando encontré acá cómo hacerlo. Dejo las instrucciones abajo para que quede claro:


  1. Abrí un cmd cómo Administrator (botón derecho en Todos los Programas > Accessorios > Símbolo de Sistema y elegí Ejecutar como administrador) ...
  2. Escribí netsh y esperá el prompt
  3. Escribí interface y esperá el prompt
  4. Escribí ipv4 y esperá el prompt
  5. Escribí show interfaces y fijate cuál es la conexión que querés tocar (en mi compu fue Conexión de red inalámbrica)
  6. Escribí set subinterface "Aca va el nombre de la conexion que queres cambiar" mtu=1400 store=persistent
Creo que eso arregla el problema.

Happy hacking,
Aureliano.

2013-03-27

Línea de comando svn por proxy http

Para salir a través de un proxy usando la línea de comando de svn hay que cambiar la configuración del cliente de svn. Una opción es ir a tocar el archivo ~/.subversion/servers, otra opción es pasarle por línea de comando host y port del proxy así:

svn --config-option servers:global:http-proxy-host=the.proxy.server --config-option servers:global:http-proxy-port=3128  checkout http://some.svn/repo

Happy hacking!

2013-03-19

¿Cómo cierro conexiones nesteadas de ssh?

Cuando una conexión de ssh se caga, para poder seguir usando la terminal hay que hacer: ENTER ~. ENTER y la conexión de ssh se corta.

El problema es que no sé como hacer para hacer algo similar para una conexión nesteada.

Desde mi workstation me ssheo al host A y desde el host A al B.

Las conexiones quedan así:

W ----ssh-----> A ------ssh-----> B

Y por algún motivo se caga la conexión entre A y B, todo el quilombo queda así:

W ----ssh-----> A --ssh(cagó)---> B

Para romper la conexión entre A y B hay que hacer: ENTER ~~. ENTER

El ñuflo extra es para escapar el ~ de la primera conexión y que le llegue a la segunda.

Happy hacking!

2013-02-21

gnome-terminal y keepass2

Keepass2 en Linux (corriéndolo con mono), pone el password en un clipboard (cuando hacés Ctrl-C)  que gnome-terminal no usa por default (mirando con xset, lo pone en el clipboard "clipboard", pero no en el "secondary"). Por lo tanto, no anda ni CTRL-V ni el menú para hacer paste del password (o el usuario) sacado de keepass2. Este problema lo vi en Linux Mint, pero debería darse en cualquier interacción entre mono y gnome-terminal.

Workarounds:

  1. Extrañamente, CTRL-SHIFT-INSERT sí pega las cosas que pusiste en el clipboard con keepass2 (fuente: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=645200).
  2. Drag-and-drop de keepass2 a la gnome-terminal correspondiente.
Happy hacking,
Aureliano.

2013-02-03

Bug Brother's Design Rules


  • War is Peace: assume you are at war, all input is an attack, and then you can be at peace.
  • Slavery is Freedom: the more you constrain your code's behavior, the more freedom you have to act. The smaller your interface, the smaller your attack surface.
  • Ignorance is Strength: the less your code knows about, the fewer things it can break. This is the principle of least authority.

2013-02-02

Manejo de passwords

La vida me transformó en un devop por un rato, así que estoy teniendo algunos problemas de sysadmin. Entre ellos, estoy buscando un buen sistema de manejo de passwords. Hay passwords que son sólo míos (muejeje!) y passwords que tenemos que tener varias personas. Por último, estaría bueno tener acceso a esos passwords desde varias compus.

Para tener los passwords en una sola compu, keepass o password safe están bien. Para manejar los passwords que uso por la web, last pass parece estar bueno, pero ¿puedo tener passwords que uso en la línea de comando? (ejemplo, claves para desencriptar archivos .pem).

¿Pero, cómo hago para compartir algunos de estos passwords con otras personas? La solución que se nos ocurrió en el laburo es meter el archivo de keepass en el control de versiones (svn). Los problemas de esto es que si por algún motivo hay un conflicto, la resolución es un quilombo y que tener derecho más granulares sobre los passwords no parece algo fácil (¿diferentes archivos de keepass, con diferentes passwords, en función del dominio de seguridad?).

¿Alguien probó last pass premium? (que permite compartir passwords)

¿Alguna otra sugerencia?

Happy hacking,
Aureliano.

2012-12-27

Cómo convencerme de que las cartas natales funcionan

Update: Parece que hicieron un estudio parecido al que yo propongo en la década del 80, y los resultados no fueron nada alentadores para los defensores de la astrología.

Ayer estaba charlando y se me ocurrió un experimento que se puede hacer para validar o refutar que las cartas natales funcionan.
Ingredientes:

  • Varias personas que sepan hacer e interpretar cartas natales (que llamaré "adivinos").
  • Varias personas que estén dispuestas a no revelar su fecha y lugar de nacimiento en una entrevista con un adivino (que llamaré "cobayos").
Mecanismo:
  1. Los cobayos son divididos en 2 grupos que tienen igual cantidad de miembros, los "mentirosos" que son aquellos a los que se les cambia levemente la fecha de nacimiento (+- 1 semana) y los "realistas", a los que se les deja la fecha de nacimiento como es. Cada cobayo no sabe si es realista o mentiroso.
  2. Cada adivino es asignado con la misma cantidad de mentirosos y realistas, y usando la información de momento y lugar de nacimiento (que está mal solo para los mentirosos) prepara las cartas natales de cada cobayo.
  3. Los adivinos se reúnen con cada uno de sus cobayos individualmente y tienen una charla de una hora. En esa charla está prohibido que hablen de la fecha exacta o lugar exacto de nacimiento del cobayo. El objectivo de la charla es que el adivino pueda establecer si la fecha y lugar de nacimiento que le dieron del cobayo es correcta o no, viendo si el mismo "matchea" con la carta natal que preparó.
  4. Después de terminar cada entrevista, cada adivino deja escrito si piensa que el cobayo es mentiroso o realista.
  5. Por último, teniendo todas las respuestas de los adivinos, hacemos un test de significación estadística para ver si los adivinos son efectivos distinguiendo a los realistas de los mentirosos.
Si el test estadístico dice que hay diferencias significativas, entonces voy a empezar a creer en esas cartas natales. Mientras tanto, y siguiendo el principio de la navaja de Occam, voy a seguir creyendo que son una paparruchada. 

Happy hacking,
Aureliano.

PD: Tarea para el hogar, diseñar un test parecido para el horóscopo.

2012-12-01

Comida fácil de preparar: Hoy, berenjenas a la plancha.

  1. Prenda el fuego y ponga la plancha encima
  2. Lave una berenjena y córtela en rodajas de aproximadamente 4 milímetros
  3. Ponga las rodajas en la plancha y tíreles un chorrito de aceite de oliva
  4. Espere 5 minutos y délas vuelta.
  5. Espere 5 minutos y apague el fuego
  6. Sirva en un plato.


2012-11-27

Cómo empecé a hacer stand up

El otro día fui a ver a un amigo a hacer standup y eso me inspiró para escribir un monologuito sobre algunos aspectos del tango como baile social. Cualquier parecido o divergencia con la realidad es pura coincidencia. El título del mismo es "Cómo empecé a hacer stand up"

Hola,
yo soy Aureliano, sí mis viejos me la hicieron complicada, y bailo tango.

Ustedes se preguntaran como puede ser que baile tango. (con voz de viejo todo encorvado) No tengo 80 años, soy carilindo (guiño de ojos), parezco un cantante de glam de la década del 80, o me parezco a Jesús (peinado a 2 aguas mientras miro el piso, cuando termino miro al público).

Bueno, ¿cuántos de ustedes bailan tango? (Mirando al público)

Veo que no hay nadie (o hay muy poquitos) que saben bailar tango acá. Pensé que estábamos en la cuna del tango, donde nació Gardel, donde compusieron la Cumparsita, donde se ponía en pedo Piazzolla (pausa). Buenos Aires es la cuna del tango. Bueno, les voy a contar un poco como funciona todo esto porque sino no van a entender ningún chiste.

El baile del tango viene en dos sabores, escenario y salón. El tango escenario es el que pueden ver en un teatro, o en Caminito un domingo al mediodía. Una o más parejas haciendo piruetas.  Los chabones, (reflexionando) ¿chabón si que es una palabra tanguera, no?, los chabones disfrazados de muñeco de torta, con una flor roja en el ojal. Las minas con medias de red y un vestido largo rojo con un tajo al costado (señalo con el brazo opuesto haciendo el recorrido del tajo) que les llega hasta la axila. Bueno (pausa), yo no hago eso.

Lo mío es el tango salón, o tango social. Ese tango es el tango que bailaban nuestros abuelos, rechazaron nuestros padres. Se baila en unos lugares que se llaman milongas. Yo tengo identificados tres circuitos en los que clasifico a las milongas.

El primero es el turístico, es el que más conoce la gente que no baila. Suelen ser milongas que están por el centro. Hay principalmente turistas de todo origen, edad, sexo, nivel de baile y peso.También hay argentinos tratando de rapiñar algo, ¡cuándo no!. Hay profesores y profesoras de tango buscando alumnos, gente que alquila alojamiento, taxi-dancers, que son algo así como las putas del baile. Algún o alguna patadura no quiere planchar en la milonga y le paga a un bailarín o bailarina para que los baile. Y, como no, siempre hay alguien en busca de sexo ocasional (cara de inocente) y/o un viajecito a Europa desde arriba.

El segundo circuito es el de las milongas de viejos. Éstas abren generalmente más temprano y son en lugares como el Cuartel de Bomberos Voluntarios de Lanús. Estas milongas son extrañas. No hay nada más bizarro que ver a una señora de la edad de tu abuela vestida con un traje de leopardo pegado al cuerpo, al lado otra que está con una minifalda y con ellas una tercera que en un traje largo parece un matambre. Acá no van a encontrar ni un turista.

Por último está el circuito joven. Aunque su epicentro está por Palermo, también es fuerte por la zona de San Telmo. Hay un montón de turistas en este circuito, y también un montón de argentinos y argentinas, y, como dice el nombre, acá vienen el grueso de la gente de menos de 40. Este circuito se caracteriza por la violencia de las patadas que se propinan en la pista. Por ejemplo el otro día presencié como una mina tiró un voleo alto y cortó el muslo de otra mina con el taco aguja.

En cualquiera de los circuitos funciona el cabeceo. El mismo consiste en hacer un movimiento en diagonal ascendente apuntando hacia la pista mientras estableces contacto visual con una mina (mirar a alguien del público y hacer el movimiento lentamente). Si la mina está de acuerdo con la invitación asiente con la cabeza y espera a que la vaya a buscar. ¡Chicas! no se levanten directamente que si el cabeceo no es para ustedes es un bochorno.

Te acercás a la pista, y muchas veces sin mediar una sola palabra, te fundís en un abrazo. Esto es de lo más lindo del tango, y un tanguero que se precie puede, solo con ese abrazo, saber muchas cosas de la mina con la que está. ¿Estás nerviosa? ¿Está triste? ¿Se bañó? ¿Tiene las tetas operadas? (gesto de tetas con las manos, pausa). Podés saber todo eso antes de saber como se llama.

En las milongas se bailan grupos de 4 tangos, que se llaman tandas y que están separados entre sí por una canción no bailable, que se llama cortina. Una vez que termina la tanda, todos se van de la pista.

Entre tango y tango, dentro de una tanda, la pareja de bailarines tiene unos 20 segundos para tener una pequeña charla. Y, la verdad, nunca supe bien qué decir en esos momentos. Sí les puedo contar que intenté.

Yo: Qué linda tanda
Ella: qué orquesta es?
Yo: ni idea (cara de :-\ )

Yo: "La milonga está re-llena"
Ella: Y?
Yo: (cara de y en donde me meto)

Yo: "La milonga está re-llena"
Ella: Me estás diciendo gorda?

Yo. De dónde sos?
Ella. Eurasia.
Yo. Y eso qué es?

También probé no decir nada. A veces está todo bien, pero no siempre. Es especialmente malo cuando el disk jockey tarda en poner el siguiente tango. Son 5, 10 o 20 segundos fatales. De mirarse sin decir nada.

Lo peor, para mi, es preguntar el nombre de mi bailarina.

Yo: Cómo te llamas? (cara de langa)
Ella: Ya es la cuarta de vez que me preguntás mi nombre.
Yo: ups
Ella: Y a una amigas ya le preguntaste 2 veces
Yo: (hago un pozo con una pala y me entierro)

Aunque a veces zafo un poco más.

Yo: Dejé de preguntar nombres porque siempre me olvido.
Ella: Yo siempre me olvido también. ¿Cómo te llamás?
Yo: Aureliano.
Ella: Mi nombre también es complicado.
Yo: ¿Cómo es?
Ella: Emanuela
Yo: Mi segundo nombre es Emanuel
Ella: ¡Me parece que ya tuvimos esta conversación alguna vez!
Yo: ¡Esto lo voy a poner textual en el monólogo que estoy escribiendo!

Una cosa que me funcionó llamativamente bien es decir "no sé qué decir entre tango y tango", el problema es que como ahora sé que decir, ahora no sé qué decir y ahora que no sé qué decir sé que decir. ¡Bertrand Russell estaría orgulloso de mi!

Y reflexionando sobre esto me di cuenta que de da para hacer de esto un guión y así empecé a hacer standup.